class TicTacToeApp(App):
game = ObjectProperty(None)
sm = ObjectProperty(None)
winning_screen = ObjectProperty(None)
def build(self):
menu = MenuScreen(name="Menu")
self.winning_screen = FinalScreen(name="Win")
self.sm = ScreenManager()
self.game = GameScreen(False, name="Tic Tac Toe")
self.sm.add_widget(menu)
self.sm.add_widget(self.game)
self.sm.add_widget(self.winning_screen)
#Clock.schedule_interval(game.botTurn, 0.5)
return self.sm
#return Symbol()
def new_game(self, human):
if self.sm.has_screen("Tic Tac Toe"):
self.sm.remove_widget(self.game)
self.game = GameScreen(human, name="Tic Tac Toe")
self.sm.add_widget(self.game)
self.sm.current = "Tic Tac Toe"
def display_winner(self, winner):
self.winning_screen.update_winner(winner)
self.sm.current = "Win"
class TripPriceApp(App):
def __init__(self):
super().__init__()
self.changeable_screens = {}
self.screen_manager = ScreenManager()
self.login_page = LoginPage(name='Login')
self.screen_manager.add_widget(self.login_page)
self.main_page = MainPage(name='Main')
self.screen_manager.add_widget(self.main_page)
self.manage_account_page = ManageAccountPage(name='Account')
self.screen_manager.add_widget(self.manage_account_page)
self.new_trip_page = NewTripPage(name='New')
self.screen_manager.add_widget(self.new_trip_page)
for i in ids:
self.trip_page = TripPage(trip_id=i, name='Trip' + str(i))
self.changeable_screens['Trip' + str(i)] = self.trip_page
self.screen_manager.add_widget(self.trip_page)
def remove_screen(self, screen_name):
scr = self.changeable_screens.pop(screen_name, None)
if scr:
self.screen_manager.remove_widget(scr)
def add_screen(self, screen_instance):
self.screen_manager.add_widget(screen_instance)
self.changeable_screens[screen_instance.name] = screen_instance
def build(self):
return self.screen_manager
class MyScreen(Singleton):
def __init__(self):
self.screenMgr = ScreenManager(size=WH)
self.name = "Root Screen"
self.transition = WipeTransition()
# or self.transition = SlideTransition(direction="down")
self.emptyScreen = Screen(name="empty screen")
#self.emptyScreen.add_widget(Label(text="empty.screen"))
self.add_screen(self.emptyScreen)
self.current_screen(self.emptyScreen)
def prev_screen(self):
prev_screen = self.screenMgr.previous()
if prev_screen:
self.screenMgr.current = prev_screen
def add_screen(self, screen):
if screen.name not in self.screenMgr.screen_names:
self.screenMgr.add_widget(screen)
def current_screen(self, screen):
if True or self.screenMgr.current != screen.name and self.screenMgr.has_screen(
screen.name):
self.screenMgr.current = screen.name
def remove_screen(self, screen):
if screen.name in self.screenMgr.screen_names:
self.screenMgr.remove_widget(screen)
self.prev_screen()
def get_current_screen(self):
return self.screenMgr.current
class MyScreen(Singleton):
def __init__(self):
self.screenMgr = ScreenManager(size=WH)
self.name = "Root Screen"
self.transition = WipeTransition()
# or self.transition = SlideTransition(direction="down")
self.emptyScreen = Screen(name = "empty screen")
#self.emptyScreen.add_widget(Label(text="empty.screen"))
self.add_screen(self.emptyScreen)
self.current_screen(self.emptyScreen)
def prev_screen(self):
prev_screen = self.screenMgr.previous()
if prev_screen:
self.screenMgr.current = prev_screen
def add_screen(self, screen):
if screen.name not in self.screenMgr.screen_names:
self.screenMgr.add_widget(screen)
def current_screen(self, screen):
if self.screenMgr.current != screen.name:
if not self.screenMgr.has_screen(screen.name):
self.add_screen(screen)
self.screenMgr.current = screen.name
def remove_screen(self, screen):
if screen.name in self.screenMgr.screen_names:
self.screenMgr.remove_widget(screen)
self.prev_screen()
def get_current_screen(self):
return self.screenMgr.current_screen
class KivyQRApp(App):
txtReadData = StringProperty()
def build(self):
self.sm = ScreenManager(transition=SwapTransition())
self.menu = MenuScreen(name='menu')
self.generate = GenerateQR(name='generate')
self.read = ReadQR(name='read')
self.dataread = DataScreen(name='datascreen')
self.sm.add_widget(self.menu)
self.sm.add_widget(self.generate)
self.sm.add_widget(self.read)
self.sm.add_widget(self.dataread)
return self.sm
def btnClose(self):
sys.exit()
def reloadFiles(self):
self.sm.remove_widget(self.read)
self.read = ReadQR(name='read')
self.sm.add_widget(self.read)
class Mark2MarketApp(MDApp):
processing = BooleanProperty(defaultValue=False)
analytics = BooleanProperty(defaultValue=True)
stock_fetch = BooleanProperty(defaultValue=True)
color = (0, 0, 0, 1)
def __init__(self, **kwargs):
super().__init__(**kwargs)
start = time.time()
self.updated = False
self.processing = True
self.screen_manager = ScreenManager()
self.current = "Main"
self.manager_open = False
self.filePath = ""
self.symbol = []
self.qty = []
self.cost = []
self.side = []
Window.bind(on_keyboard=self.events)
self.file_manager = MDFileManager(
exit_manager=self.exit_manager,
select_path=self.select_path,
)
self.file_manager.ext = ['.csv', '.CSV', '.xlsx', '.XLSX']
self.popup = self.get_popup()
self.no_data_popup = self.no_data_popup()
end = time.time()
print('elapsed time for startup is %d seconds ' % (end - start))
self.processing = False
def on_processing(self, instance, value):
pass
def on_analytics(self, instance, value):
pass
def on_stock_fetch(self, instance, value):
pass
def help(self):
HelpScreen().open()
def exit(self):
Window.close()
def on_state(self, instance, value):
pass
def get_popup(self):
pop = Popup(title='Transaction status', auto_dismiss=False)
lbl = Label()
lbl.text = 'Update successful'
btn = MDIconButton()
lbl.pos_hint = {'center_x': .5, 'center_y': .5}
btn.icon = 'home'
btn.bind(on_press=self.go_home)
btn.md_bg_color = (1, 1, 1, 1)
btn.pos_hint = {'center_x': .5, 'center_y': 0.1}
from kivy.uix.floatlayout import FloatLayout
layout = FloatLayout()
layout.add_widget(lbl)
layout.add_widget(btn)
pop.content = layout
pop.size_hint = .6, .6
return pop
def no_data_popup(self):
pop = Popup(title='Data status', auto_dismiss=False)
lbl = Label()
lbl.text = 'No Data!. Add some transactions'
btn = MDIconButton()
lbl.pos_hint = {'center_x': .5, 'center_y': .5}
btn.icon = 'home'
btn.bind(on_press=self.go_home)
btn.md_bg_color = (1, 1, 1, 1)
btn.pos_hint = {'center_x': .5, 'center_y': 0.1}
layout = FloatLayout()
layout.add_widget(lbl)
layout.add_widget(btn)
pop.content = layout
pop.size_hint = .8, .6
return pop
def go_nav(self):
if not os.path.exists('csv/pandb.csv'):
self.no_data_popup.open()
return
self.processing = True
Clock.schedule_once(self.nav_delegate, 1)
def add_nav_widget(self):
pnl = PnLScreen(self.screen_manager, name='NAV', updated=self.updated)
self.updated = False
self.screen_manager.add_widget(pnl)
def nav_delegate(self, dt):
try:
pnl = self.screen_manager.get_screen('NAV')
if self.updated or len(tryout.product_dict) == 0:
self.screen_manager.remove_widget(pnl)
self.add_nav_widget()
except ScreenManagerException:
self.add_nav_widget()
print('prod dict length = ', len(tryout.product_dict))
if len(tryout.product_dict) == 0:
self.no_data_popup.open()
else:
self.screen_manager.current = "NAV"
self.processing = False
def upload_screen(self):
self.screen_manager.current = 'Upload'
def entry_screen(self):
self.screen_manager.current = 'Entry'
def trading_screen(self):
self.screen_manager.current = 'Trade'
def gain_loss(self):
if not os.path.exists('csv/pandb.csv'):
self.no_data_popup.open()
return
self.processing = True
Clock.schedule_once(self.gain_loss_delegate, 1)
def gain_loss_delegate(self, dt):
self.processing = True
try:
self.screen_manager.get_screen('GainLoss')
except ScreenManagerException:
gl = GainLossScreen(self.screen_manager,
name='GainLoss',
updated=self.updated)
self.screen_manager.add_widget(gl)
if len(tryout.product_dict) == 0:
self.no_data_popup.open()
else:
self.screen_manager.current = 'GainLoss'
self.processing = False
def charts(self):
if not os.path.exists('csv/pandb.csv'):
self.no_data_popup.open()
return
self.processing = True
Clock.schedule_once(self.chart_delegate, 3)
def chart_delegate(self, dt):
try:
analysis = self.screen_manager.get_screen('Charts')
except ScreenManagerException:
analysis = Analysis(self.screen_manager,
name='Charts',
updated=self.updated)
# analysis.add_widgets()
self.screen_manager.add_widget(analysis)
if len(tryout.product_dict) > 0:
self.screen_manager.current = 'Charts'
else:
self.no_data_popup.open()
self.processing = False
def on_text(self):
symbol = self.root.get_screen("Entry").ids.symbol.text
self.symbol.append(symbol)
qty = self.root.get_screen("Entry").ids.quantity.text
self.qty.append(qty)
cost = self.root.get_screen("Entry").ids.cost.text
self.cost.append(cost)
side = self.root.get_screen("Entry").ids.side.text
self.side.append(side)
def open_url(self, instance):
tryout.open_url(instance.text)
def on_submit(self):
self.processing = True
Clock.schedule_once(self.submit_delegate, 1)
def submit_delegate(self, dt):
symbol = self.symbol.pop().upper()
qty = float(self.qty.pop().upper())
cost = float(self.cost.pop().upper())
side = self.side.pop().upper()
print(symbol, qty, cost, side)
success = tryout.update_portfolio(symbol, qty, cost, side)
if success:
self.screen_manager.get_screen('Entry').ids.symbol.text = ''
self.screen_manager.get_screen('Entry').ids.quantity.text = ''
self.screen_manager.get_screen('Entry').ids.cost.text = ''
self.screen_manager.get_screen('Entry').ids.side.text = ''
self.updated = True
self.processing = False
self.popup.open()
def home(self):
self.screen_manager.current = 'Main'
def go_home(self, instance):
self.screen_manager.current = 'Main'
self.popup.dismiss()
self.no_data_popup.dismiss()
def file_manager_open(self):
self.file_manager.show('/') # output manager to the screen
self.manager_open = True
def process_file(self, instance):
self.processing = True
Clock.schedule_once(self.process_file_delegate, 1)
def process_file_delegate(self, dt):
if len(self.filePath) == 0:
toast('You must select a transaction file')
return
csvFile = self.filePath
extn = self.filePath[-4:].upper()
if extn.__contains__('XLS'):
csvFile = convert_to_csv(self.filePath)
tryout.init()
tryout.make_product_dict_from_csv(csv_file=csvFile)
self.go_nav()
tryout.nav_name = 'NAV'
self.processing = False
self.root.get_screen(
self.root.current
).ids.file_chooser.text = 'Choose a transaction file'
def select_path(self, path):
"""It will be called when you click on the file name
or the catalog selection button.
:type path: str;
:param path: path to the selected directory or file;
"""
self.exit_manager()
self.root.get_screen(self.root.current).ids.file_chooser.text = path
self.filePath = path
# self.process_file()
def set_error_message(self, instance_textfield):
name = self.screen_manager.current
screen = self.root.get_screen(name)
screen.ids.input = True
def back(self):
self.screen_manager.current = 'Main'
def exit_manager(self, *args):
"""Called when the user reaches the root of the directory tree."""
self.manager_open = False
self.file_manager.close()
def events(self, instance, keyboard, keycode, text, modifiers):
"""Called when buttons are pressed on the mobile device."""
if keyboard in (1001, 27):
if self.manager_open:
self.file_manager.back()
elif self.screen_manager.current == 'Main':
self.exit()
else:
self.screen_manager.current = 'Main'
return True
def build(self):
Builder.load_file('RootWidget.kv')
addMainScreen(self.screen_manager, self)
self.screen_manager.current = "Main"
return self.screen_manager
class ShooterApp(App):
def build(self): #builds the main game
self.initFactory()
self.game = ScreenManager(transition=FadeTransition())
self.initAbilities(self.game)
self.initButtons()
self.initTimerEvents()
mainGame = self.game.mainScreen.mainGame
mainGame.hero.initStats()
self.game.upgradeScreen.hero = mainGame.hero
return self.game #sets the screenManager as the root
def initButtons(self):
#binds all buttons to their respective functions
self.game.gameOverScreen.restart.bind(on_press=self.restart)
self.game.menuScreen.menu.quitButton.bind(on_press=self.stop)
self.game.menuScreen.menu.startButton.bind(on_press=self.startGame)
self.game.menuScreen.menu.helpButton.bind(on_press=self.loadHelp)
self.game.pauseScreen.continueButton.bind(on_press=self.unpause)
self.game.pauseScreen.restartButton.bind(on_press=self.restart)
self.game.mainScreen.mainGame.pauseButton.bind(on_press=self.pause)
def pause(self, button):
#pauses the game and goes to to the pause screen
self.game.mainScreen.mainGame.isPaused = True
self.game.current = "Pause"
def unpause(self, button=None, dt=0):
#unpauses the game
self.game.current = "MainGame"
#schedules the actual unpause so that the transition ends before
#enemies begin to move again
Clock.schedule_once(self.notPaused, 1.0)
def notPaused(self, dt=0): #sets the pause variable to False
self.game.mainScreen.mainGame.isPaused = False
def startGame(self, button):
#called by the start game button
self.game.current = "MainGame"
self.game.mainScreen.mainGame.isPaused = False
def loadHelp(self, button):
#loads the help screen
self.game.current = "Help"
def initAbilities(self, game):
#initializes the ability buttons and sets active ability
mainGame = game.mainScreen.mainGame
abilityHandler = mainGame.hero.abilityHandler
abilityHandler.abilities = [MissileAbility(), SlashAbility()]
buttons = [
abilityHandler.abilityButton0, abilityHandler.abilityButton1
]
abilityHandler.setActiveAbility(abilityHandler.abilities[0])
#the above lists can be changed if new abilities are added
for i in xrange(2):
abilityHandler.setAbilityButton(buttons[i],
abilityHandler.abilities[i])
def initTimerEvents(self):
#schedules all timer fired events
mainGame = self.game.mainScreen.mainGame
Clock.schedule_interval(mainGame.update, 1.0 / 60)
Clock.schedule_interval(mainGame.enemyScheduler, .3)
def reinit(self):
#reiitializes the game after a restart
Clock.unschedule(self.game.mainScreen.mainGame.update)
Clock.unschedule(self.game.mainScreen.mainGame.enemyScheduler)
self.game.remove_widget(self.game.mainScreen)
self.game.remove_widget(self.game.upgradeScreen)
#clears both the gameover screen and the maingame screen
newScreen = MainGameScreen(name="MainGame")
newUpgradeScreen = UpgradeScreen(name="Upgrade")
#adds new screens to the game
self.game.add_widget(newScreen)
self.game.add_widget(newUpgradeScreen)
self.game.mainScreen.clear_widgets()
self.game.mainScreen = newScreen
self.game.upgradeScreen = newUpgradeScreen
def restart(self, button):
#called by the restart button to reset the game
self.reinit()
#changes the screen back to the main menu
self.game.current = "Menu"
self.game.mainScreen.mainGame.hero.initStats()
self.game.mainScreen.mainGame.isPaused = True
self.game.mainScreen.mainGame.pauseButton.bind(on_press=self.pause)
self.initAbilities(self.game)
self.initTimerEvents()
def initFactory(self): #creates factory definitions of classes
#to be used in .kv file
Factory.register("Hero", Hero)
Factory.register("ShooterGame", ShooterGame)
Factory.register("KeyPressed", KeyPressed)
Factory.register("EnemyHandler", EnemyHandler)
Factory.register("GameOver", GameOver)
Factory.register("AbilityHandler", AbilityHandler)
Factory.register("GameOverScreen", GameOverScreen)
Factory.register("MainGameScreen", MainGameScreen)
Factory.register("UpgradeScreen", UpgradeScreen)
Factory.register("UpgradePage", UpgradePage)
Factory.register("HeroUpgradePage", HeroUpgradePage)
Factory.register("AbilityUpgradePage", AbilityUpgradePage)
Factory.register("MenuScreen", MenuScreen)
Factory.register("MenuLayout", MenuLayout)
Factory.register("HelpScreen", HelpScreen)
Factory.register("PauseScreen", PauseScreen)
Factory.register("Pause", Pause)
class ShooterApp(App):
def build(self): #builds the main game
self.initFactory()
self.game = ScreenManager(transition= FadeTransition())
self.initAbilities(self.game)
self.initButtons()
self.initTimerEvents()
mainGame = self.game.mainScreen.mainGame
mainGame.hero.initStats()
self.game.upgradeScreen.hero = mainGame.hero
return self.game #sets the screenManager as the root
def initButtons(self):
#binds all buttons to their respective functions
self.game.gameOverScreen.restart.bind(on_press = self.restart)
self.game.menuScreen.menu.quitButton.bind(on_press = self.stop)
self.game.menuScreen.menu.startButton.bind(on_press = self.startGame)
self.game.menuScreen.menu.helpButton.bind(on_press = self.loadHelp)
self.game.pauseScreen.continueButton.bind(on_press = self.unpause)
self.game.pauseScreen.restartButton.bind(on_press = self.restart)
self.game.mainScreen.mainGame.pauseButton.bind(on_press = self.pause)
def pause(self,button):
#pauses the game and goes to to the pause screen
self.game.mainScreen.mainGame.isPaused = True
self.game.current = "Pause"
def unpause(self, button=None ,dt=0):
#unpauses the game
self.game.current="MainGame"
#schedules the actual unpause so that the transition ends before
#enemies begin to move again
Clock.schedule_once(self.notPaused, 1.0)
def notPaused(self, dt=0): #sets the pause variable to False
self.game.mainScreen.mainGame.isPaused = False
def startGame(self, button):
#called by the start game button
self.game.current = "MainGame"
self.game.mainScreen.mainGame.isPaused = False
def loadHelp(self, button):
#loads the help screen
self.game.current = "Help"
def initAbilities(self,game):
#initializes the ability buttons and sets active ability
mainGame = game.mainScreen.mainGame
abilityHandler = mainGame.hero.abilityHandler
abilityHandler.abilities = [MissileAbility(),SlashAbility()]
buttons = [abilityHandler.abilityButton0,
abilityHandler.abilityButton1]
abilityHandler.setActiveAbility(abilityHandler.abilities[0])
#the above lists can be changed if new abilities are added
for i in xrange(2):
abilityHandler.setAbilityButton(buttons[i],
abilityHandler.abilities[i])
def initTimerEvents(self):
#schedules all timer fired events
mainGame = self.game.mainScreen.mainGame
Clock.schedule_interval(mainGame.update, 1.0/60)
Clock.schedule_interval(mainGame.enemyScheduler, .3)
def reinit(self):
#reiitializes the game after a restart
Clock.unschedule(self.game.mainScreen.mainGame.update)
Clock.unschedule(self.game.mainScreen.mainGame.enemyScheduler)
self.game.remove_widget(self.game.mainScreen)
self.game.remove_widget(self.game.upgradeScreen)
#clears both the gameover screen and the maingame screen
newScreen = MainGameScreen(name="MainGame")
newUpgradeScreen = UpgradeScreen(name="Upgrade")
#adds new screens to the game
self.game.add_widget(newScreen)
self.game.add_widget(newUpgradeScreen)
self.game.mainScreen.clear_widgets()
self.game.mainScreen = newScreen
self.game.upgradeScreen = newUpgradeScreen
def restart(self,button):
#called by the restart button to reset the game
self.reinit()
#changes the screen back to the main menu
self.game.current = "Menu"
self.game.mainScreen.mainGame.hero.initStats()
self.game.mainScreen.mainGame.isPaused = True
self.game.mainScreen.mainGame.pauseButton.bind(on_press = self.pause)
self.initAbilities(self.game)
self.initTimerEvents()
def initFactory(self): #creates factory definitions of classes
#to be used in .kv file
Factory.register("Hero", Hero)
Factory.register("ShooterGame", ShooterGame)
Factory.register("KeyPressed", KeyPressed)
Factory.register("EnemyHandler", EnemyHandler)
Factory.register("GameOver", GameOver)
Factory.register("AbilityHandler", AbilityHandler)
Factory.register("GameOverScreen", GameOverScreen)
Factory.register("MainGameScreen", MainGameScreen)
Factory.register("UpgradeScreen", UpgradeScreen)
Factory.register("UpgradePage", UpgradePage)
Factory.register("HeroUpgradePage", HeroUpgradePage)
Factory.register("AbilityUpgradePage", AbilityUpgradePage)
Factory.register("MenuScreen", MenuScreen)
Factory.register("MenuLayout", MenuLayout)
Factory.register("HelpScreen", HelpScreen)
Factory.register("PauseScreen", PauseScreen)
Factory.register("Pause", Pause)
class BigFamaly(App):
BACK_STACK = []
USER_ID = None
def build(self):
EventLoop.window.bind(on_keyboard=self.back)
self.globalStyle = ScreenManager(transition=NoTransition())
appMain = Screen(name="app")
self.main = ScreenManager(transition=NoTransition(),
size_hint_y=None,
height=Window.height - 100,
pos_hint={
"x": 0,
"center_y": .5
})
style = FloatLayout()
# up = FloatLayout(size_hint_y = None, height = 50)
# up.add_widget(Button(size_hint_y = None, height = 50,background_color = COLOR[THEME]["MAIN_COLOR"], color = COLOR[THEME]["BACKGROUND"],background_normal = "",background_down = "",border = [0,0,0,0]))
# up.add_widget(Shadow(pos_hint = {"x":0,"center_y":0}))
self.toolBar = ToolBar(change=self.changeActivity)
self.up = Up(pos_hint={"x": 0, "top": 1})
style.add_widget(self.up, 0)
style.add_widget(self.main, 1)
style.add_widget(self.toolBar, 0)
appMain.add_widget(style)
self.loginActivity = LoginActivity(name="login",
auth=self.auth,
openLogUp=self.openLogUp)
self.logUpActivity = NotWork(
name="logUp"
) #LogUpActivity(name = "logUp", openImages = self.openImages)
self.globalStyle.add_widget(self.loginActivity)
self.globalStyle.add_widget(self.logUpActivity)
self.globalStyle.add_widget(appMain)
self.globalStyle.add_widget(
ChangeType(name="type", add_type=self.chooseType))
cursor.execute("SELECT id,avatar FROM user")
self.data = cursor.fetchone()
if self.data == [] or self.data == None:
self.globalStyle.current = "login"
else:
self.USER_ID = self.data[0]
self.loadsActivity()
return self.globalStyle
def changeActivity(self, istance):
if self.up.changeTitle(istance.text):
self.main.current = istance.text
self.BACK_STACK.append(["app", istance.text])
else:
istance.state = "down"
def auth(self, istance):
try:
request = {
"login": self.loginActivity.login.text,
"password": self.loginActivity.password.text,
"test": 1
}
resp = req.post("http://timmcool.pythonanywhere.com/auth",
json=request)
rJson = resp.json()
if rJson["Message"] == "222":
cursor.execute(
"INSERT INTO user(id,login, reputation, num,avatar) VALUES(?,?,?,?,?)",
(rJson["Id"], rJson["Login"], rJson["Reputation"],
rJson["NumHelp"], rJson["Avatar"]))
con.commit()
self.USER_ID = rJson["Id"]
self.loadsActivity()
except Exception:
#makeToast("Проверьте поджлючение к интернету")
print("NO INTERNET MAZAFAKA")
def getData(self):
cursor.execute("SELECT * FROM user")
data = cursor.fetchone()
result = {
"id": data[0],
"login": data[1],
"reputation": data[2],
"helpNum": data[3],
"avatar": data[4]
}
return result
def chooseType(self, type):
self.addActivity.type = type.text
self.addActivity.checkCategory.text = type.text
self.globalStyle.current = "app"
self.sectorActivity = True
def openChooseType(self, istance):
self.globalStyle.current = "type"
self.BACK_STACK.append(["globalStyle", "type"])
def moreInformation(self, i):
self.globalStyle.remove_widget(self.moreInfoActivity)
self.moreInfoActivity = DopActivity(name="moreInformation",
title=i.title,
content=i.description,
type=i.type,
avatar=i.avatar,
login=i.login,
reputation=i.reputation,
deadline=i.deadline,
userId=i.userId,
selfUserID=self.USER_ID,
blockId=i.blockId,
openDialog=self.openDialog)
self.globalStyle.add_widget(self.moreInfoActivity)
self.globalStyle.current = "moreInformation"
self.BACK_STACK.append(["globalStyle", "moreInformation"])
def loadsActivity(self):
self.globalStyle.current = "app"
Window.clearcolor = [.96, .96, .96, 1]
data = self.getData()
self.mainActivity = MainActivity(name="mainActivity",
moreInformation=self.moreInformation)
# mainActivity.addBlock(BlockHelp(type = "Tra",deadline = "23",description = "Help Help Help Help Help Help Help Help Help Help Help BEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH",title = "HEEEEEELP", avatar = "http://timmcool.pythonanywhere.com/SIS.jpg"
self.dialogScreen = DialogScreen(idTo=0,
idFrom=0,
helpName="",
userName="",
idBlock=0,
avatar="")
self.moreInfoActivity = DopActivity(title="",
content="",
type="",
avatar="",
login="",
reputation="",
deadline="",
userId="",
selfUserID="",
blockId="",
openDialog=self.openDialog)
profileActivity = ProfileActivity(name="profileActivity", getData=data)
self.addActivity = AddActivity(name="addActivity",
userId=self.USER_ID,
openChooseType=self.openChooseType,
endsPost=self.endsAddPost)
self.dialogActivity = DialogActivity(name="dialogActivity",
openDialog=self.openDialog,
userId=self.USER_ID)
settingActivity = SettingActivity(name="settingActivity",
userId=self.USER_ID,
exit=self.exit)
self.BACK_STACK.append(["app", "mainActivity"])
self.main.add_widget(self.mainActivity)
self.main.add_widget(profileActivity)
self.main.add_widget(self.addActivity)
self.main.add_widget(self.dialogActivity)
self.main.add_widget(settingActivity)
def back(self, window, key, *largs):
if key == 27:
self.BACK_STACK = self.BACK_STACK[:-1]
if self.BACK_STACK != []:
inverseBack = self.BACK_STACK[-1:]
if inverseBack[0][0] == "app":
self.globalStyle.current = "app"
self.main.current = inverseBack[0][1]
self.up.changeTitle(inverseBack[0][1])
for w in self.toolBar.children:
try:
if w.text == inverseBack[0][1]:
w.state = "down"
else:
w.state = "normal"
except Exception:
continue
elif inverseBack[0][0] == "globalStyle":
self.globalStyle.current = inverseBack[0][1]
return True
else:
return False
def openDialog(self, i):
self.globalStyle.remove_widget(self.dialogScreen)
self.dialogScreen.setParametrs(i.idTo, i.idFrom, i.blockName,
i.userName, i.blockId, i.avatar,
i.stateD, i.realId, self.returnDialog)
self.globalStyle.add_widget(self.dialogScreen)
if i.text == "Отозваться":
self.dialogActivity.getDialogs(self.USER_ID)
self.BACK_STACK = self.BACK_STACK[:-1]
self.BACK_STACK.append(["app", "dialogActivity"])
self.globalStyle.current = "dialog"
self.BACK_STACK.append(["globalStyle", "dialog"])
def returnDialog(self):
self.BACK_STACK = self.BACK_STACK[:-1]
self.globalStyle.current = "app"
self.dialogActivity.getDialogs(self.USER_ID)
def openLogUp(self, istance):
self.globalStyle.current = "logUp"
if ["globalStyle", "login"] not in self.BACK_STACK:
self.BACK_STACK.append(["globalStyle", "login"])
self.BACK_STACK.append(["globalStyle", "logUp"])
def openImages(self, istance):
self.globalStyle.add_widget(
ChooseImage(name="choser", chooseAvatar=self.chooseImage))
self.globalStyle.current = "choser"
def chooseImage(self, istance):
print(self.globalStyle.children)
print()
try:
self.globalStyle.remove_widget(avaMaker)
except Exception:
print("LooooL")
print(self.globalStyle.children)
avaMaker = AvaMaker(name="avaMaker", source=istance.text)
self.globalStyle.add_widget(avaMaker)
self.globalStyle.current = "avaMaker"
def exit(self, istance):
cursor.execute("DROP TABLE user")
con.commit()
Window.clearcolor = COLOR["LIGHT"]["MAIN_COLOR"]
self.globalStyle.current = "login"
def endsAddPost(self):
self.mainActivity.updateBlocks()
self.main.current = "mainActivity"
self.BACK_STACK.append(["app", "mainActivity"])
class Car(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.title = "Infernus"
self.theme_cls.primary_palette = "DeepOrange"
self.theme_cls.theme_style = "Light"
self.sm = ScreenManager()
self.has_animated_card = False
self.has_animated_background = False
def login(self, usr, passwd):
if (usr.text == "salman97" and passwd.text == "salman"):
#Snackbar(text="Welcome " + usr.text + "!").show()
toast("Welcome " + usr.text + "!")
self.manage_screens("home_screen", "add")
self.change_screen("home_screen")
else:
toast("Incorrect username and/or password!")
#Snackbar(text="Incorrect username and/or password!").show()
def animate_background(self, widget):
if self.has_animated_background == False:
anim = Animation(size_hint_y=1) + Animation(size_hint_y=0.5)
anim.start(widget.ids.bx)
def animate_card(self, widget):
# {"center_x": 0.5, "center_y": 0.6}
if self.has_animated_card == False:
anim = Animation(pos_hint={
"center_x": 0.5,
"center_y": 0.6
},
duration=0.5)
anim.start(widget)
self.has_animated_card = True
def change_screen(self, screen_name):
if self.sm.has_screen(screen_name):
self.sm.current = screen_name
def manage_screens(self, screen_name, action):
scns = {
"login_screen": Factory.LoginScreen,
"home_screen": Factory.HomeScreen,
"explore_screen": Factory.ExploreScreen
}
try:
if action == "remove":
if self.sm.has_screen(screen_name):
self.sm.remove_widget(self.sm.get_screen(screen_name))
#print("Screen ["+screen_name+"] removed")
elif action == "add":
if self.sm.has_screen(screen_name):
pass
#print("Screen [" + screen_name + "] already exists")
else:
self.sm.add_widget(scns[screen_name](name=screen_name))
#print(screen_name + " added")
#print("Screen ["+screen_name+"] added")
except:
print(traceback.format_exc())
print("Traceback ^.^")
def on_pause(self):
return True
def on_resume(self):
pass
def build(self):
print('hello')
self.bind(on_start=self.post_build_init)
self.sm.add_widget(Factory.LoginScreen())
self.sm.add_widget(Factory.HomeScreen())
self.sm.current = "login_screen"
return self.sm
def post_build_init(self, ev):
win = self._app_window
win.bind(on_keyboard=self._key_handler)
def _key_handler(self, *args):
key = args[1]
# 1000 is "back" on Android
# 27 is "escape" on computers
if key in (1000, 27):
try:
self.sm.current = "login_screen"
except Exception as e:
print(e)
return True
elif key == 1001:
try:
self.sm.current = "login_screen"
except Exception as e:
print(e)
return True
class Logotouch(App):
connected = BooleanProperty(False)
def build_config(self, config):
config.setdefaults('server', {
'host': 'logotouch.erasme.org',
'db': '0' })
def build(self):
from kivy.core.window import Window
Window.bind(on_keyboard=self._on_window_keyboard)
self.user_email = '*****@*****.**'
self.user_name = 'Mathieu Virbel'
self.rpc = None
self.game_screen = None
self.sm = ScreenManager(transition=SlideTransition())
self.screen_welcome = WelcomeScreen(name='welcome')
self.sm.add_widget(self.screen_welcome)
self.connect()
#self.create_session_with_corpus(0)
return self.sm
def create_session(self):
if not hasattr(self, 'screen_create_session'):
self.screen_create_session = CreateSessionScreen(name='create')
self.sm.add_widget(self.screen_create_session)
self.sm.current = 'create'
def join_session(self):
if not hasattr(self, 'screen_join_session'):
self.screen_join_session = JoinSessionScreen(name='join')
self.sm.add_widget(self.screen_join_session)
self.sm.current = 'join'
def create_session_with_corpus(self, corpus_id):
if not hasattr(self, 'screen_download_corpus'):
self.screen_download_corpus = DownloadScreen(name='download',
title=_('Game is starting'),
action=_('Creating session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus)
self.sm.current = 'download'
self.g_corpus_id = corpus_id
self.rpc.new_session(self.user_email, corpus_id,
callback=self._on_create_session)
def create_session_new_corpus(self):
if not hasattr(self, 'screen_download_corpus'):
self.screen_download_corpus = DownloadScreen(name='download',
title=_('Game is starting'),
action=_('Creating session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus)
self.sm.current = 'download'
from time import time
self.rpc.new_corpus(
'Corpus {}'.format(time()),
self.user_name,
self.user_email,
callback=self._on_create_corpus)
def _on_create_corpus(self, result, error=None):
if error is not None:
return
self.create_session_with_corpus(result)
def join_session_from_enc(self, enc):
try:
sessid = basedec(enc)
if not hasattr(self, 'screen_download_corpus2'):
self.screen_download_corpus2 = \
DownloadScreen(name='download2',
title=_('Game is starting'),
action=_('Joining session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus2)
self.sm.current = 'download2'
self.rpc.join_session(self.user_email, sessid,
callback=self._on_join_session)
except:
self.screen_join_session.error = _('Invalid session code')
self.sm.current = 'join'
self.screen_join_session.disptach('on_enter')
def add_sentence(self, data):
self.rpc.add_sentence(self.g_sessid, data)
def get_sentences(self, callback):
self.rpc.get_sentences(self.g_sessid, callback=callback)
def _on_join_session(self, result, error=None):
if error is not None:
self.screen_join_session.error = _('Error while joining the session: {}').format(error)
self.sm.current = 'join'
return
if result is None:
self.screen_join_session.error = _('Unknow session code')
self.sm.current = 'join'
return
self.g_sessid = result['sessid']
self.g_corpus_id = result['corpusid']
self.g_sentences_count = result['sentences_count']
self.rpc.bind_session(self.g_sessid)
self.sm.current_screen.action = _('Downloading Corpus')
self.sm.current_screen.progression = 66
self.rpc.get_corpus(self.g_corpus_id, callback=self._on_corpus)
def _on_create_session(self, result, error=None):
if error is not None:
return
self.g_sessid = result
self.g_sentences_count = 0
self.rpc.bind_session(self.g_sessid)
self.sm.current_screen.action = _('Downloading Corpus')
self.sm.current_screen.progression = 66
self.rpc.get_corpus(self.g_corpus_id, callback=self._on_corpus)
def _on_corpus(self, result, error=None):
if error is not None:
# TODO
return
self.g_corpus = result
self.sm.current_screen.progression = 100
Clock.schedule_once(self._start_game, 0.1)
def _start_game(self, *args):
self.game_screen = GameScreen(name='game',
sessid=self.g_sessid, corpus=self.g_corpus,
sentences_count=self.g_sentences_count)
if self.sm.has_screen('game'):
self.sm.remove_widget(self.sm.get_screen('game'))
self.sm.add_widget(self.game_screen)
self.sm.current = 'game'
def connect(self):
self.rpc = ThreadedRpcClient(
host=self.config.get('server', 'host'),
on_session_broadcast=self._on_session_broadcast)
def disconnect(self):
pass
def help_gesture(self):
popup = HelpGesturePopup()
popup.open()
def _on_window_keyboard(self, window, *largs):
key = largs[0]
if key != 27:
return
self.do_back()
def do_back(self):
# if there is a modal view in the window, avoid to check it
from kivy.core.window import Window
if any([isinstance(x, ModalView) for x in Window.children]):
return
if self.sm.current != 'welcome':
self.sm.current = 'welcome'
return True
def _on_session_broadcast(self, sessid, message):
if str(self.g_sessid) != str(sessid):
print 'Dropped message, invalid sessid {} (we accept {})'.format(
sessid, self.g_sessid)
return
if self.game_screen:
self.game_screen.on_broadcast(message)
class MyApp(App):
def build(self):
self.title = 'Watson Bank Client'
self.screenManager = ScreenManager()
self.loginScreen = LoginScreen(self)
screenLogin = Screen(name=LOGIN_SCREEN)
screenLogin.add_widget(self.loginScreen)
self.menuScreen = MenuScreen(self)
screenMenu = Screen(name=MENU_SCREEN)
screenMenu.add_widget(self.menuScreen)
if not readToken() == None:
self.screenManager.add_widget(screenMenu)
self.screenManager.add_widget(screenLogin)
else:
self.screenManager.add_widget(screenLogin)
self.screenManager.add_widget(screenMenu)
self.signupScreen = SignUpScreen(self)
screen = Screen(name=SIGNUP_SCREEN)
screen.add_widget(self.signupScreen)
self.screenManager.add_widget(screen)
self.createAccountScreen = CreateAccountScreen(self)
screen = Screen(name=CREATE_ACCOUNT_SCREEN)
screen.add_widget(self.createAccountScreen)
self.screenManager.add_widget(screen)
self.addAccountScreen = AddAccountScreen(self)
screen = Screen(name=ADD_ACCOUNT_SCREEN)
screen.add_widget(self.addAccountScreen)
self.screenManager.add_widget(screen)
self.changeAccountStatus = ChangeStatusScreen(self)
screen = Screen(name=CHANGE_ACCOUNT_STATUS)
screen.add_widget(self.changeAccountStatus)
self.screenManager.add_widget(screen)
self.allTransactionsScreen = None
self.allTransactionsScreenChild = None
self.allAccountsScreen = None
self.allAccountsScreenChild = None
self.transactionScreen = None
self.transactionScreenChild = None
return self.screenManager
def allAccountsScreenCallback(self):
if not self.allAccountsScreen == None:
self.screenManager.remove_widget(self.allAccountsScreen)
self.allAccountsScreenChild = AccountsListScreen(self)
self.allAccountsScreen = Screen(name=ALL_ACCOUNTS_SCREEN)
self.allAccountsScreen.add_widget(self.allAccountsScreenChild)
self.screenManager.add_widget(self.allAccountsScreen)
def allTransactionsScreenCallback(self):
if not self.allTransactionsScreen == None:
self.screenManager.remove_widget(self.allTransactionsScreen)
self.allTransactionsScreenChild = TransactionsListScreen(self)
self.allTransactionsScreen = Screen(name=ALL_TRANSACTIONS_SCREEN)
self.allTransactionsScreen.add_widget(self.allTransactionsScreenChild)
self.screenManager.add_widget(self.allTransactionsScreen)
def createTransactionScreenCallback(self):
if not self.transactionScreen == None:
self.screenManager.remove_widget(self.transactionScreen)
self.transactionScreenChild = CreateTransactionScreen(self)
self.transactionScreen = Screen(name=CREATE_TRANSACTION_SCREEN)
self.transactionScreen.add_widget(self.transactionScreenChild)
self.screenManager.add_widget(self.transactionScreen)
class Test(MDApp):
def build(self):
self.theme_cls.primary_palette = "Purple"
self.theme_cls.primary_hue = "700"
return self.sm
def __init__(self, **kwargs):
self.exit = False
super().__init__(**kwargs)
self.item = []
self.cust = dict()
self.sm = ScreenManager()
self.temp_first = First(name='first')
self.sm.add_widget(self.temp_first)
self.temp_sec = Second(name='second')
self.bello = Table()
self.temp_sec.add_widget(self.bello)
self.sm.add_widget(self.temp_sec)
self.person = dict()
def fetchData(self, tab):
tab.clear_widgets()
cur.execute("SELECT id,name,due,amount FROM RECORDS")
rows = cur.fetchall()
rows.insert(0, ["Inv No", "Name", "Due Date", "Amount"])
temp = ScrollView()
root1 = StackLayout(size_hint_y=None, spacing=0, orientation="lr-tb")
root1.bind(minimum_height=root1.setter('height'))
i = 0
for row in rows:
for col in row:
if i == 0:
root1.add_widget(
MDLabel(text=str(col),
height=30,
size_hint_x=1 / 4,
size_hint_y=None,
halign="center",
font_style="Body1"))
else:
root1.add_widget(
MDLabel(text=str(col),
height=30,
size_hint_x=1 / 4,
size_hint_y=None,
halign="center",
font_style="Body2"))
if i == 0:
root1.add_widget(MDSeparator())
i = i + 1
temp.add_widget(root1)
tab.add_widget(temp)
def changeExit(self):
self.exit = False
def firstToSecond(self):
self.person["shipping"] = dict()
self.person["shipping"]["name"] = self.cust["name"]
self.person["shipping"]["address"] = self.cust["address"]
self.person["shipping"]["city"] = self.cust["city"]
self.person["shipping"]["pin"] = self.cust["pincode"]
self.sm.current = "second"
self.sm.remove_widget(self.temp_first)
self.temp_first = First(name="first")
self.sm.add_widget(self.temp_first)
def callback(self):
if self.exit == False:
toast("Press back again to exit")
self.exit = True
timer = threading.Timer(2.0, self.changeExit)
timer.start()
else:
Window.close()
sys.exit()
def process(self, val, cat):
if cat == "name":
self.cust['name'] = val
elif cat == "address":
self.cust['address'] = val
elif cat == "city":
self.cust['city'] = val
elif cat == "pin":
self.cust['pincode'] = val
elif cat == "phone":
self.cust['phone'] = val
elif cat == "mail":
self.cust['emid'] = val
def gotohome(self):
self.sm.current = "first"
self.sm.remove_widget(self.temp_sec)
self.temp_sec = Second(name="second")
self.temp_sec.clear_widgets()
self.temp_sec.add_widget(Table())
self.sm.add_widget(self.temp_sec)
def print(self):
self.person["items"] = self.bello.table_content
t = str(datetime.datetime.now())
t = (((t[2:].replace('-', '')).replace(' ',
'')).replace(':',
'')).split('.')[0]
self.person["invoice_nr"] = t
self.person["cmail"] = self.cust["emid"]
tot = 0
i = 0
for sin in self.person["items"]:
sin_cost = float(sin["Price"]) * float(sin["Quan"])
sin_tax = sin_cost * float(float(sin["Tax"]) / 100)
tot = tot + sin_cost + sin_tax
self.person["items"][i]["taxamnt"] = str(sin_tax)
self.person["items"][i]["line"] = str(sin_tax + sin_cost)
i = i + 1
self.person["due"] = str(tot)
js = jso.dumps(self.person)
r = requests.get('https://invoice-3po.herokuapp.com/postdata',
json={"data": js},
allow_redirects=True)
print(r)
toast('Invoice Generated and Mail sent!')
open('invoice.pdf', 'wb').write(r.content)
query = 'insert into records values("' + t + '","' + self.person[
"shipping"]["name"] + '","' + str(
datetime.datetime.now() +
datetime.timedelta(days=10))[0:10] + '","' + str(tot) + '")'
print(query)
cur.execute(query)
c.commit()
timer = threading.Timer(2.0, self.gotohome)
timer.start()
class SwitchContainer(MDBoxLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
#管理器
self.screen_manager = ScreenManager()
self.add_widget(self.screen_manager)
self.page_list = []
#事件循环
self.event = Clock.schedule_interval(self.Start, 5)
def AddPage(self, page_name, page):
'''
说明: 添加一个页面来显示
args{
page_name: 屏幕的名字
page:要显示的内容(控件,非Screen)
}
return:
'''
screen = Screen(name=page_name)
screen.add_widget(page)
self.page_list.append(page_name)
self.screen_manager.add_widget(screen)
self.screen_manager.current = page_name
def DeletePage(self, page_name):
'''
说明:
args{
page_name: 要移除的屏幕的名字
}
return:
'''
if self.screen_manager.has_screen(page_name):
page = self.screen_manager.get_screen(page_name)
self.screen_manager.remove_widget(page)
self.page_list.remove(page_name)
def DeleteAll(self):
'''
说明: 移除全部屏幕
args{
}
return:
'''
while len(self.page_list):
self.DeletePage(self.page_list[0])
def Start(self, *args):
'''
说明: 循环事件
args{
}
return:
'''
if len(self.page_list) > 1:
index = (self.page_list.index(self.screen_manager.current) +
1) % len(self.page_list)
self.screen_manager.current = self.page_list[index]
class DWMBarberShop(App):
selected_attrs = []
def viewing(self, bx):
count = 0
for entry in data:
if count > 10:
return
s = ", ".join(entry)
s = s + "\n"
bx.add_widget(Label(text=s))
count += 1
def them_buttons(self, ref, ref2):
self.ref2 = ref2
a = [
"Hair Style Name",
"Normal Price (N$)",
"Barber",
"Weather",
"Environment Noise Level",
"Head Shape",
"Customer Reaction",
"Discount Percent",
"Age Group",
"Pre Hair Length",
"Physical Height (m)",
"Body Mass (kg)", # in age group +/- 5
"Date (DDMMYYYY)",
"Client Skin Tone",
"Styling Time (minutes)", # in style +/- 10
]
for n in a:
ref.add_widget(Button(text=n, on_release=self.btn_action))
def btn_action(self, bt):
self.selected_attrs.append(bt.text)
self.ref2.add_widget(Label(text=bt.text))
def show_patterns(self):
s = ""
for n in self.selected_attrs:
s += f'"{n}" '
import os
a = os.path.join(os.getcwd(), "correlation_.py")
f = a + " " + s
print(f)
subprocess.Popen(f, close_fds=True, shell=True)
def open_visualisation(self, p):
subprocess.Popen("python " + p, close_fds=True)
def build(self):
self.sm = ScreenManager()
self.sm.add_widget(MainScreen(name="main"))
return self.sm
def manage_screens(self, screen_name, action):
scns = {
"main": MainScreen,
"correlation_attributes": Factory.CorrelationAttributes,
"view_data": Factory.ViewData,
}
if action == "remove":
if self.sm.has_screen(screen_name):
self.sm.remove_widget(self.sm.get_screen(screen_name))
# print("Screen ["+screen_name+"] removed")
elif action == "add":
if self.sm.has_screen(screen_name):
print("Screen [" + screen_name + "] already exists")
else:
self.sm.add_widget(scns[screen_name](name=screen_name))
print(screen_name + " added")
# print("Screen ["+screen_name+"] added")
def change_screen(self, screen_name):
if self.sm.has_screen(screen_name):
self.sm.current = screen_name
else:
print("Screen [" + screen_name + "] does not exist.")
class Emp(MDApp):
job_list = ListProperty() # contains data needed to display job list cards
category_list = ListProperty(
) # contains data needed to display job list cards
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.title = "Namibia Job Hunt"
self.theme_cls.primary_palette = "DeepPurple"
self.theme_cls.theme_style = "Light"
self.sm = ScreenManager()
self.has_animated_card = False
self.has_animated_background = False
def account_action(self, email, passwd, username=None, action=None):
print(email, passwd, username, action)
if action == "register":
pass
# register the user
elif action == "login":
# login the user
pass
self.manage_screens("home_screen", "add")
self.change_screen("home_screen")
def animate_background(self, widget):
if self.has_animated_background == False:
anim = Animation(size_hint_y=1) + Animation(size_hint_y=0.5)
anim.start(widget.ids.bx)
print("background animated")
else:
print("background already animated")
def animate_card(self, widget):
# {"center_x": 0.5, "center_y": 0.6}
if self.has_animated_card == False:
anim = Animation(pos_hint={
"center_x": 0.5,
"center_y": 0.6
},
duration=2)
anim.start(widget)
self.has_animated_card = True
print("card animated")
else:
print("card already animated")
def change_screen(self, screen_name):
if self.sm.has_screen(screen_name):
self.sm.current = screen_name
else:
print("Screen [" + screen_name + "] does not exist.")
def manage_screens(self, screen_name, action):
scns = {
"login_screen": Factory.LoginScreen,
"registration_screen": Factory.RegistrationScreen,
"home_screen": Factory.HomeScreen,
"job_list_screen": Factory.JobListScreen
}
try:
if action == "remove":
if self.sm.has_screen(screen_name):
self.sm.remove_widget(self.sm.get_screen(screen_name))
print("Screen [" + screen_name + "] removed")
elif action == "add":
if self.sm.has_screen(screen_name):
print("Screen [" + screen_name + "] already exists")
else:
self.sm.add_widget(scns[screen_name](name=screen_name))
print(screen_name + " added")
print("Screen [" + screen_name + "] added")
except:
print(traceback.format_exc())
print("Traceback ^.^")
def on_pause(self):
return True
def on_resume(self):
pass
def build(self):
self.bind(on_start=self.post_build_init)
self.sm.add_widget(Factory.LoginScreen())
# self.sm.add_widget(HomeScreen(name="home_screen"))
# self.sm.current = "login_screen"
return self.sm
def post_build_init(self, ev):
win = self._app_window
win.bind(on_keyboard=self._key_handler)
def _key_handler(self, *args):
key = args[1]
# 1000 is "back" on Android
# 27 is "escape" on computers
if key in (1000, 27):
try:
self.sm.current_screen.dispatch("on_back_pressed")
except Exception as e:
print(e)
return True
elif key == 1001:
try:
self.sm.current_screen.dispatch("on_menu_pressed")
except Exception as e:
print(e)
return True
class Prejudice(App):
icon = 'data/icon.png'
def build(self):
global app
app = self
self.sounds = {}
self.load_stats()
self.current_step = None
self.bind_keyboards()
self.sm = ScreenManager(transition=SlideTransition(
direction='left', duration=.4))
self.sm.add_widget(LoadingScreen(name='loading'))
self.sm.add_widget(Home(name='home'))
self.sm.current = 'home'
app.play('ACCUEIL')
return self.sm
def bind_keyboards(self):
from kivy.base import EventLoop
EventLoop.ensure_window()
def on_key_down(window, keycode, *args):
if keycode == 27:
if self.sm.current != 'home':
self.sm.current = 'home'
return True
EventLoop.window.bind(on_key_down=on_key_down)
def show_stats(self):
if not hasattr(self, '_statsscr'):
self._statsscr = StatsScreen(name='stats')
self.sm.add_widget(self._statsscr)
self.sm.transition.direction = 'left'
self.sm.current = 'stats'
def stop_quizz(self):
if self.current_step:
self.current_step.abort()
self.sm.remove_widget(self.current_step)
self.current_step = None
self.sm.transition.direction = 'right'
self.sm.current = 'home'
def list_quizz(self):
if not hasattr(self, '_listquizz'):
self._listquizz = ListQuizz(name='list-quizz')
self.sm.add_widget(self._listquizz)
self._listquizz.update()
self.sm.transition.direction = 'left'
self.sm.current = 'list-quizz'
def start_quizz(self, quizz):
self.current_quizz_fn = quizz
self.current_quizz = data = self.load_quizz(quizz)
if not self.current_quizz:
return
self.load_choices()
# create steps
self.steps = []
kwargs = dict(
title=data['title'],
description=data['description'],
answers=data['answers'])
index_max = len(data['steps']) - 1
for index, indices in enumerate(data['steps']):
if not indices:
continue
cls = Step if index != index_max else EndStep
step = partial(cls,
baseimg=data['main_image'],
indices=indices,
**kwargs)
self.steps.append(step)
self.count = 0
self.stepindex = -1
self.do_next_step()
def add_quizz(self):
self.sm.add_widget(AddQuizz(name='add-quizz'))
self.sm.transition.direction = 'left'
self.sm.current = 'add-quizz'
def do_next_step(self):
self.count += 1
self.stepindex += 1
name = 's{}'.format(self.count)
step = self.steps[self.stepindex](name=name)
self.current_step = step
self.sm.add_widget(step)
self.sm.current = name
#
# Quizz management
#
@property
def quizz_dir(self):
return self.user_data_dir
def save_quizz(self, quizz):
index = 0
while True:
quizz_dir = join(self.quizz_dir, 'quizz-{}'.format(index))
if not exists(quizz_dir):
break
index += 1
# create the quizz directory
os.makedirs(quizz_dir)
# save all the images
self._copy_quizz_image(quizz_dir, quizz, 'main_image')
for indices in quizz['steps']:
for indice in indices:
if indice['source']:
self._copy_quizz_image(quizz_dir, indice, 'source')
for answer in quizz['answers']:
if answer['source']:
self._copy_quizz_image(quizz_dir, answer, 'source')
# save our index
quizz_fn = join(quizz_dir, 'index.json')
with open(quizz_fn, 'wb') as fd:
json.dump(quizz, fd)
self.stop_quizz()
self.message('Le quizz à été enregistré !')
def iterate_quizz(self):
for quizz_dir in os.listdir(self.quizz_dir):
index = join(self.quizz_dir, quizz_dir, 'index.json')
if not exists(index):
continue
yield index
def load_quizz(self, fn):
try:
with open(fn) as fd:
data = json.load(fd)
basedir = dirname(realpath(fn))
data['main_image'] = join(basedir, data['main_image'])
for step in data['steps']:
for choice in step:
if not choice['source']:
continue
choice['source'] = join(basedir, choice['source'])
for answer in data['answers']:
if not answer['source']:
continue
answer['source'] = join(basedir, answer['source'])
return data
except:
pass
def _copy_quizz_image(self, quizz_dir, data, key):
index = 0
while True:
dest_fn = join(quizz_dir, 'img-{}-{}'.format(index,
basename(data[key])))
if not exists(dest_fn):
break
index += 1
shutil.copyfile(data[key], dest_fn)
data[key] = basename(dest_fn)
#
# Utils
#
def on_pause(self):
return True
def message(self, msg):
AppPopup(message=msg).open()
def play(self, name):
if name not in self.sounds:
fn = join('data', 'sounds', '{}.wav'.format(name))
self.sounds[name] = SoundLoader.load(fn)
sound = self.sounds[name]
if sound.state == 'play':
sound.stop()
sound.play()
def stop(self, name):
if name not in self.sounds:
return
sound = self.sounds[name]
if sound.state == 'play':
sound.stop()
#
# Statistics management
#
@property
def stats_fn(self):
return join(self.user_data_dir, 'stats.json')
def load_stats(self):
self.stats = { 'good': [0, 0], 'bad': [0, 0] }
try:
if exists(self.stats_fn):
with open(self.stats_fn) as fd:
self.stats = json.load(fd)
except:
pass
def save_stats(self):
with open(self.stats_fn, 'wb') as fd:
json.dump(self.stats, fd)
def add_stat(self, good, influence):
key = 'good' if good else 'bad'
index = 1 if influence else 0
self.stats[key][index] += 1
self.save_stats()
#
# Events
#
@property
def choice_fn(self):
return join(dirname(self.current_quizz_fn), 'choices.json')
def load_choices(self):
self.choices = {}
try:
if exists(self.choice_fn):
with open(self.choice_fn) as fd:
self.choices = json.load(fd)
except:
pass
print self.choices
def update_choices(self, index):
index = str(index)
if index not in self.choices:
self.choices[index] = 0
self.choices[index] += 1
def save_choices(self):
with open(self.choice_fn, 'wb') as fd:
json.dump(self.choices, fd)
def get_choices(self):
count = sum(self.choices.values()) / 5.
if count <= 1:
return (0, 0, 0, 0)
return (
int(ceil(self.choices.get('1', 0) / float(count))),
int(ceil(self.choices.get('2', 0) / float(count))),
int(ceil(self.choices.get('3', 0) / float(count))),
int(ceil(self.choices.get('4', 0) / float(count))))
class Program(App):
def __init__(self, **kvargs):
super(Program, self).__init__(**kvargs)
#self.start_menu = StartMenu
#self.preparefield = PrepareField
def build(self):
self.screen_manager = ScreenManager()
self.start_menu = StartMenu(events_callback=self.events_program)
self.type_menu = GameTypeMenu(events_callback=self.events_program)
self.screen_manager.add_widget(self.start_menu)
self.screen_manager.add_widget(self.type_menu)
self.init_game()
#game type variables
self.isTwoPlayers = False
self.isFirstArranged = False
self.message_data = None
return self.screen_manager
def end_game(self):
self.screen_manager.remove_widget(self.prepare_screen)
self.screen_manager.remove_widget(self.game_screen)
def init_game(self):
self.prepare_screen = PrepareScreen(
events_callback=self.events_program)
self.game_screen = GameFieldScreen(events_callback=self.events_program)
self.screen_manager.add_widget(self.prepare_screen)
self.screen_manager.add_widget(self.game_screen)
def send_data_to_server(self):
try:
msg = self.message_data
self.data_socket = socket.socket()
self.data_socket.connect(('localhost', Core.client.port))
self.data_socket.send(bytes(msg, encoding='utf-8'))
self.message_data = None
except ConnectionRefusedError:
print("Connectio Error")
def recive_data_from_server(self):
data = self.data_socket.recv(80) # 2 * cell_count - all = ship cells
self.data_socket.close()
return data
def events_program(self, *args):
if len(args) == 2:
screen, event = args
else:
screen, event, data = args
for s in data:
print(str(ord(s)), end=" ")
#data - string of ships coordinates
if screen == Core.StartMenu:
if event == Core.start_menu.play:
self.screen_manager.current = "type_menu"
self.message_data = "s"
self.send_data_to_server() #start prepare_stage
elif event == Core.start_menu.tools:
pass
else:
self.message_data = "e"
self.send_data_to_server()
sys.exit(0)
elif screen == Core.TypeMenu:
if event == Core.type_menu.PvsP:
self.message_data = Core.game_type.PvsP
self.isTwoPlayers = True
self.screen_manager.current = "prepare_screen"
self.game_screen.left_player = "h"
self.game_screen.right_player = "h"
elif event == Core.type_menu.PvsObot:
self.message_data = Core.game_type.PvsObot
self.screen_manager.current = "prepare_screen"
self.game_screen.left_player = "h"
self.game_screen.right_player = "b"
elif event == Core.type_menu.PvsRbot:
self.screen_manager.current = "prepare_screen"
self.message_data = Core.game_type.PvsRbot
self.game_screen.left_player = "h"
self.game_screen.right_player = "b"
elif event == Core.type_menu.ObotvsRbot:
self.message_data = Core.game_type.ObotvsRbot
self.events_program(Core.PScreen, Core.p_field.botarrange)
self.game_screen.left_player = "b"
self.game_screen.right_player = "b"
elif event == Core.type_menu.Back:
self.isTwoPlayers = False
self.screen_manager.current = "start_menu"
elif screen == Core.PScreen:
if event == Core.p_field.arrange:
if self.isTwoPlayers:
if not self.isFirstArranged:
self.isFirstArranged = True
self.message_data += data
self.prepare_screen.clean()
else:
self.message_data += data
self.send_data_to_server()
#recive data
#game_screen.define
field_states = self.recive_data_from_server()
self.game_screen.define_fields(field_states)
self.screen_manager.current = "game_screen"
self.game_screen.field_events("start")
else:
self.message_data += data
self.send_data_to_server()
field_states = self.recive_data_from_server()
for s in field_states:
print(s)
self.game_screen.define_fields(field_states)
#recive data
#game_screen.define
self.screen_manager.current = "game_screen"
self.game_screen.field_events("start")
elif event == Core.p_field.botarrange:
pass
elif event == Core.p_field.back:
if self.isTwoPlayers:
if self.isFirstArranged:
pass
else:
self.screen_manager.current = "gametype"
self.prepare_screen.cleen()
else:
self.screen_manager.current = "gametype"
self.prepare_screen.cleen()
elif screen == Core.GameField:
if event == Core.game_field.end_battle:
#show winner(screen)
self.screen_manager.current = "start_menu"
self.end_game()
self.init_game()
class GUI(Screen):
def __init__(self):
self.sm = ScreenManager()
self.sm.add_widget(self.menu())
def render(self):
return self.sm
def menu(self):
screen = Screen(name='Home')
menu_background = Image(source=ROOT + 'main_background.jpg',
allow_stretch=True,
keep_ratio=False)
layout = FloatLayout(size=(500, 500))
layout.add_widget(menu_background)
btn_play = Button(text='Play',
size_hint=(.15, .08),
pos_hint={
'x': .025,
'y': .875
})
btn_play.bind(on_press=self.play)
btn_quit = Button(text='Quit',
size_hint=(.15, .08),
pos_hint={
'x': .825,
'y': .025
})
btn_quit.bind(on_press=self.quit)
layout.add_widget(btn_play)
layout.add_widget(btn_quit)
screen.add_widget(layout)
return screen
def play(self, source):
self.settingsview = self.settings()
self.sm.add_widget(self.settingsview)
self.sm.current = 'Settings'
self.random_generation_setting = False
def quit(self, source):
sys.exit(0)
def settings(self):
screen = Screen(name=ROOT + 'Settings')
settings_background = Image(source='settings_background.jpg',
allow_stretch=True,
keep_ratio=False)
layout = FloatLayout(size=(500, 500))
layout.add_widget(settings_background)
btn_singleplayer = Button(text='Single Player',
size_hint=(.15, .08),
pos_hint={
'x': .65,
'y': .45
})
btn_singleplayer.bind(on_press=self.singleplayer)
btn_multiplayer = Button(text='Multiplayer',
size_hint=(.15, .08),
pos_hint={
'x': .825,
'y': .45
})
btn_multiplayer.bind(on_press=self.multiplayer)
label_switch = Label(text='Random Map Generator',
size_hint=(.15, .08),
pos_hint={
'x': .5,
'y': .1
})
switch = Switch(active=False,
size_hint=(.15, .08),
pos_hint={
'x': .7,
'y': .1
})
switch.bind(active=self.map_setting)
layout.add_widget(btn_multiplayer)
layout.add_widget(btn_singleplayer)
layout.add_widget(label_switch)
layout.add_widget(switch)
screen.add_widget(layout)
return screen
def map_setting(self, source, isActive):
if isActive:
self.random_generation_setting = True
else:
self.random_generation_setting = False
def singleplayer(self, source):
self.multiplayer_status = False
self.widget = []
self.game = Game(mode=self.random_generation_setting)
self.gridview = self.grid(name='Game')
self.sm.add_widget(self.gridview)
self.sm.current = 'Game'
def multiplayer(self, source):
self.multiplayer_status = True
self.widget = []
self.game_1 = Game(mode=self.random_generation_setting)
self.game_2 = Game(mode=self.random_generation_setting)
self.gridview_1 = self.grid(name='Player_1')
self.gridview_2 = self.grid(name='Player_2')
self.sm.add_widget(self.gridview_1)
self.sm.add_widget(self.gridview_2)
self.sm.current = 'Player_1'
self.turn = 1
def grid(self, name):
screen = Screen(name=name)
main_layout = GridLayout(cols=2)
layout = GridLayout(cols=11, rows=11, width=700, size_hint=(None, 1))
border = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
for y in range(11):
for x in range(11):
if (x == 0 and y == 0):
layout.add_widget(Label(text=''))
elif (y == 0 and x != 0):
layout.add_widget(Label(text=str(x)))
elif (x == 0 and y != 0):
layout.add_widget(Label(text=border[y - 1]))
else:
btn = Button(id=str((x, y)))
btn.bind(on_press=self.game_call)
layout.add_widget(btn)
main_layout.add_widget(layout)
self.game_label = Label(text='Start playing by clicking on the grid')
if self.multiplayer_status == True:
self.widget.append(self.game_label)
print(self.widget)
main_layout.add_widget(self.game_label)
screen.add_widget(main_layout)
return screen
def current_game(self):
if self.turn == 2:
game = self.game_2
else:
game = self.game_1
return game
def game_call(self, btn):
a = literal_eval(btn.id)
if self.multiplayer_status == True: #multiplayer
btn.background_disabled_normal = ''
_, status, btn.background_color, message = self.current_game(
).update_map(a)
if status == 0:
self.sm.current = 'Home'
self.score_popup()
self.sm.remove_widget(self.gridview_1)
self.sm.remove_widget(self.gridview_2)
else:
if self.turn == 2:
self.widget[1].text = message
self.turn = 1
self.sm.transition.direction = 'right'
else:
self.widget[0].text = message
self.turn = 2
self.sm.transition.direction = 'left'
self.sm.current = 'Player_' + str(self.turn)
self.turn_popup()
else: #singleplayer
btn.background_disabled_normal = ''
_, status, btn.background_color, self.game_label.text = self.game.update_map(
a)
if status == 0:
self.sm.current = 'Home'
self.score_popup()
self.sm.remove_widget(self.gridview)
btn.disabled = True
def score_popup(self):
if self.multiplayer_status == True:
score_label = Label(text="You scored a ratio of " +
str(self.current_game().show_score()) + " %")
self.player_name_input = TextInput(text="Enter your name")
popup_title = "Player " + str(self.turn)
else:
score_label = Label(text="You scored a ratio of " +
str(self.game.show_score()) + " %")
self.player_name_input = TextInput(text="Enter your name")
popup_title = "Game Over"
print("after if statement")
score_layout = GridLayout(rows=2)
score_layout.add_widget(score_label)
save_layout = GridLayout(cols=2)
save_layout.add_widget(self.player_name_input)
save_btn = Button(text="Save")
save_btn.bind(on_press=self.save)
save_layout.add_widget(save_btn)
score_layout.add_widget(save_layout)
self.popup = Popup(title=popup_title,
content=score_layout,
size_hint=(None, None),
size=(400, 400),
auto_dismiss=False)
self.popup.open()
def save(self, src):
if self.multiplayer_status == True:
self.current_game().save(self.player_name_input.text)
self.popup.dismiss()
else:
self.game.save(self.player_name_input.text)
self.popup.dismiss()
def turn_popup(self):
popup = Popup(title='Player ' + str(self.turn) + ' turn',
size_hint=(None, None),
size=(120, 80),
auto_dismiss=True)
popup.open()
Clock.schedule_once(popup.dismiss, 0.5)
class ChengYu(MDApp):
def build(self):
self.width = Window.size[0]
self.spacing = Window.size[0] * 0.02
self.last_time = 0
Window.bind(on_keyboard=self.BackEvent)#绑定按下返回键的事件
# 更改字体设置----------------------------------------
font = (Window.size[1] ** 2 + Window.size[0] ** 2) ** 0.45 / (
Window.size[0]
) # 动态求字体大小
self.theme_cls.font_styles["SiYuan"] = [
"SiYuan",
16,
False,
0.15,
]
for key in self.theme_cls.font_styles:
if key != "Icon":
self.theme_cls.font_styles[key][0] = "SiYuan"
#self.theme_cls.font_styles[key][1] *= font
config.font = self.theme_cls.font_styles
print(config.font)
config.theme_cls = self.theme_cls
# --------------------------------------------------------------------------------
# 配置主题颜色----------------------------------------
# ['Red', 'Pink', 'Purple', 'DeepPurple', 'Indigo', 'Blue', 'LightBlue', 'Cyan', 'Teal', 'Green', 'LightGreen', 'Lime', 'Yellow', 'Amber', 'Orange', 'DeepOrange', 'Brown', 'Gray', 'BlueGray']
self.theme_cls.primary_palette = config.config["theme_cls_primary_palette"]
self.theme_cls.accent_palette = config.config["theme_cls_accent_palette"]
# --------------------------------------------------------------------------------
# 界面管理----------------------------------------
self.screen_manager = ScreenManager()
self.screen_list = []
self.main_page = None # 界面切换界面
self.record_page = None # 记录界面
self.user_page = None # 用户界面
self.home_page = None # 主界面
self.study_page = None # 学习界面
self.detail_page = None # 详情界面
self.finishpage = None #学习结束页面
self.challengepage = None #挑战界面
self.firstpage = None #第一次使用时输入用户名界面
self.loading_page = Loading(name="loading") # 加载页面
self.screen_manager.add_widget(self.loading_page)
self.snackbar = Snackbar(duration=1.5) # 提示窗
# --------------------------------------------------------------------------------
# 加载初始页面
KV_MainPage = open("main.kv", "r", encoding="utf-8").read()
self.main_page = Builder.load_string(KV_MainPage)
for i in self.main_page.ids.buttom.ids.tab_manager.screens:
# i.size_hint = (1, 1)
i.pos = (0, self.main_page.ids.buttom.ids.tab_bar.height)
self.Home()
self.main_page.ids.buttom.switch_tab("home")
self.screen_manager.add_widget(self.main_page)
self.screen_list.append(self.main_page)
self.screen_manager.current = "Main"
if not config_dict["ID"]:
print(config_dict)
self.FirstInit()
return self.screen_manager
def Home(self):
# 构造Home界面
if not self.home_page:
self.home_page = Home()
self.main_page.ids.home.add_widget(self.home_page)
self.home_page.Refresh()
def User(self):
# 构造User界面
if not self.user_page:
self.user_page = User()
self.user_page.username = config_dict["username"]
self.main_page.ids.user.add_widget(self.user_page)
print(self.user_page.username)
def Record(self):
if not self.record_page:
self.record_page = Record()
self.main_page.ids.record.add_widget(self.record_page)
def StartStudy(self):
if not self.study_page:
if self.home_page.now_choose != "未选择学习类别":
self.screen_manager.current = self.loading_page.name
#def __start():
self.study_page = StudyPage(self.home_page.now_choose, name = "studypage")
self.screen_list.append(self.study_page)
self.screen_manager.add_widget(self.study_page)
self.screen_manager.current = "studypage"
#threading.Thread(target=__start).start()
else:
self.snackbar.text = "当前未选择学习类别"
self.snackbar.show()
def FinishStudy(self):
'''
说明: 重StudyPage切回主界面
args{
}
return:
'''
if self.study_page:
self.screen_list.remove(self.study_page)
if self.study_page.has_answer:
self.ShowFinishPage(self.study_page.contents)
else:
self.screen_manager.current = self.main_page.name
self.screen_manager.remove_widget(self.study_page)
del self.study_page
self.study_page = None
self.home_page.Refresh()
def StartChallenge(self):
if not self.challengepage:
self.screen_manager.current = self.loading_page.name
#def __start():
self.challengepage = Challenge(name = "challengepage")
self.screen_list.append(self.challengepage)
self.screen_manager.add_widget(self.challengepage)
self.screen_manager.current = "challengepage"
#threading.Thread(target= __start).start()
def BackChallenge(self):
if self.challengepage:
self.screen_list.remove(self.challengepage)
self.screen_manager.current = self.main_page.name
self.screen_manager.remove_widget(self.challengepage)
del self.challengepage
self.challengepage = None
def FinishChallenge(self):
'''
说明: 从ChallengePage切回主界面
args{
}
return:
'''
if self.challengepage:
self.screen_list.remove(self.challengepage)
self.ShowFinishPage(self.challengepage.contents)
self.screen_manager.remove_widget(self.challengepage)
del self.challengepage
self.challengepage = None
def ShowFinishPage(self, contents):
if not self.finishpage:
self.screen_manager.current = self.loading_page.name
#def __start():
self.finishpage = FinishPage(contents, name = "finish")
self.screen_list.append(self.finishpage)
self.screen_manager.add_widget(self.finishpage)
self.screen_manager.current = "finish"
#threading.Thread(target=__start).start()
def ColseFinishPage(self):
if self.finishpage:
self.screen_list.remove(self.finishpage)
self.home_page.Refresh()
self.screen_manager.current = self.main_page.name
self.screen_manager.remove_widget(self.finishpage)
del self.finishpage
self.finishpage = None
def ShowDetail(self, content):
if content and not self.detail_page:
self.screen_manager.current = self.loading_page.name
self.detail_page = Detail(content, name="detail")
self.screen_manager.add_widget(self.detail_page)
self.screen_list.append(self.detail_page)
self.screen_manager.current = "detail"
def CloseDetail(self):
if self.detail_page:
self.screen_list.remove(self.detail_page)
self.screen_manager.current = self.screen_list[-1].name
self.screen_manager.remove_widget(self.detail_page)
del self.detail_page
self.detail_page = None
def FirstInit(self, text = "输入用户名后开始学习"):
if not self.firstpage:
self.firstpage = FirstInit(name = "First",hint_text=text, back_event=self.ChangeUsername)
self.screen_manager.add_widget(self.firstpage)
self.screen_list.append(self.firstpage)
self.screen_manager.current = "First"
def ChangeUsername(self, name):
if not config_dict["ID"]:
def s(req, result):
json_data = result
data = json.loads(json_data)
if data["id"]:
config_dict["ID"] = data["id"]
config_dict["username"] = name
config.SaveConfig()
self.CloseFirstPage()
UrlRequest(server_url + "/register/?username={}".format(name), s)
else:
def s(req, result):
json_data = result
config_dict["username"] = name
data = json.loads(json_data)
print(data)
config.SaveConfig()
self.CloseFirstPage()
UrlRequest(server_url + "/update/?id={}&username={}".format(config_dict["ID"], name), s)
def CloseFirstPage(self):
if self.firstpage:
self.screen_list.remove(self.firstpage)
self.screen_manager.current = self.main_page.name
self.screen_manager.remove_widget(self.firstpage)
del self.firstpage
self.firstpage = None
def BackEvent(self, window, key, *args):
# 按下返回键事件
t = time()
if key == 27:
print(t, "-", self.last_time, "-", t - self.last_time)
if t - self.last_time < 2:
self.stop()
else:
self.last_time = t
self.snackbar.text = "按两次返回键退出"
self.snackbar.show()
return True
