class MindsetAssessmentApp(App): def build(self): # initialize logger KL.start([DataMode.file, DataMode.communication, DataMode.ros], self.user_data_dir) KL.log.insert(action=LogAction.data, obj='app', comment='mindset_assessment_app') # KL.start([DataMode.file], "/sdcard/curiosity/")#self.user_data_dir) # TTS.start() self.sm = ScreenManager() self.zero_screen = ZeroScreen(name='zero_screen') self.sm.add_widget(self.zero_screen) self.question_screen = QuestionScreen(name='question_screen',the_app=self) self.sm.add_widget(self.question_screen) self.sm.current = 'zero_screen' return self.sm def start_assessment(self, pre_post_flag): self.sm.current = 'question_screen' self.question_screen.pre_post_flag = pre_post_flag # 1 for pre, 2 for post print ('condition', self.question_screen.pre_post_flag) self.question_screen.init_sounds() self.question_screen.introduction1()
class FreeExplorationApp(App): game_screen = None def build(self): self.init_communication() TTS.start() self.sm = ScreenManager() screen = ZeroScreen() screen.ids['subject_id'].bind(text=screen.ids['subject_id'].on_text_change) self.sm.add_widget(screen) self.game_screen = GameScreen(name='the_game') self.game_screen.start(self) self.game_screen.add_widget(self.game_screen.curiosity_game.the_widget) self.sm.add_widget(self.game_screen) self.sm.current = 'zero_screen' return self.sm def init_communication(self): KC.start(the_ip='192.168.1.254', the_parents=[self]) # 127.0.0.1 KL.start(mode=[DataMode.file, DataMode.communication, DataMode.ros], pathname=self.user_data_dir, the_ip='192.168.1.254') def on_connection(self): KL.log.insert(action=LogAction.data, obj='FreeExplorationApp', comment='start') def press_start(self, pre_post): self.game_screen.curiosity_game.filename = 'items_' + pre_post + '.json' self.sm.current = 'the_game'
def build(self): sm = ScreenManager(transition=WipeTransition()) sm.add_widget(MainWindow(name='mainwindow')) sm.add_widget(StandardWidgets(name='inputstation')) Window.bind(on_keyboard=self.hook_keyboard) self.content = content = BoxLayout() sc = Trainccs() #~ spinner = Spinner( #~ text='About', #~ values=('About',), #~ size_hint=(None, None), #~ size=(100, 44), #~ #~ ) #~ pos_hint={'center_x': 0.5, 'center_y': 0.5}) #~ sc.add_widget(spinner) sc.content.add_widget(sm) return sc
def build(self): register('jeV1sPLXL6cq8EsWAK0Zyoac8b97duQWyXYK7sfE','fl6hQ9dv94IbtA0I7kPzSrawL165HqupSjCFdo3D') # Create the screen manager sm = ScreenManager(transition=FadeTransition()) sm.add_widget(LoginScreen(name='login')) return sm
class MyGameApp(App): def build(self): for path in [ "design/debug.kv", "design/menu/main.kv", "design/menu/settings.kv", "design/main/board.kv", "design/main/panels.kv", "design/main/ingame.kv", ]: Builder.load_file(path) self.sm = ScreenManager() self.screens = {} for screen_cls in [MainIngameScreen, MainMenuScreen, SettingsMenuScreen]: screen = screen_cls(name=screen_cls._name) self.screens[screen_cls._name] = screen self.sm.add_widget(screen) return self.sm def switch_screen(self, screen_name, direction="left"): self.sm.transition.direction = direction self.sm.current = screen_name
def build(self): root = ScreenManager(transition=FadeTransition()) root.add_widget(FruitMainScreen()) root.add_widget(FruitListScreen()) root.add_widget(FruitDetailScreen()) return root
def build(self): root = ScreenManager() #Pantallas principales # #Pantallas sub-Principales root.add_widget(Facultades(name='facultades')) return root
class CuriosityApp(App): sm = None cg = None qf = None float_layout = None def build(self): # initialize logger KL.start([DataMode.file, DataMode.encrypted], self.user_data_dir) self.cg = CuriosityGame(self) self.qf = QuestionsForm() self.sm = ScreenManager() screen = Screen(name='thegame') screen.add_widget(self.cg.the_widget) self.sm.add_widget(screen) screen = Screen(name="question") screen.add_widget(self.qf) self.sm.add_widget(screen) return self.sm def on_pause(self): return True
def build(self): sm = ScreenManager() sm.add_widget(InfoPage(name='InfoPage')) sm.add_widget(ChatPage(name='ChatPage')) apptools = App #self.connect_to_server() return sm
def get_screen_manager(): global _screen_manager if _screen_manager is None: _screen_manager = ScreenManager() _screen_manager.add_widget(LoginScreen()) _screen_manager.add_widget(MusicListScreen()) return _screen_manager
class LSystemsApp(App): def build(self,*args,**kwargs): self.root=ScreenManager() self.view = LSystemsView() self.edit = LSystemsEdit() self.view.bind(on_edit=self.run_editor) self.root.add_widget(self.view) self.root.add_widget(self.edit) self.bind(on_start = self.post_build_init) return self.root def post_build_init(self,ev): if ANDROID: android.map_key(android.KEYCODE_BACK, 1001) win = self._app_window win.bind(on_keyboard=self.key_handler) def run_editor(self,instance,fractal): self.view.image.set_iterations(1) # no rendering on background self.root.current="edit" self.edit.load_lsystem(fractal) def key_handler(self,keyboard,keycode, *args, **kwargs): if keycode==(1001 if ANDROID else 32): self.edit.image.set_iterations(1) self.root.current="view"
class GameApp(App): def __init__(self, **kwargs): """ :param kwargs: :return: """ super(GameApp, self).__init__(**kwargs) self.textures = textures self.screen_manager = ScreenManager() self.menu_widget = Menu() self.menu_screen = Screen(name="Menu") self.menu_screen.add_widget(self.menu_widget) self.screen_manager.add_widget(self.menu_screen) self.game_widget = Level('../resources/test.png', self.textures) self.game_screen = Screen(name="Game") self.game_screen.add_widget(self.game_widget) self.screen_manager.add_widget(self.game_screen) def build(self): """ :return: """ self.screen_manager.current = 'Game' return self.screen_manager
def build(self): """ build """ self.use_kivy_settings = False screen = ScreenManager() screen.add_widget(MenuScreen(name='menu')) screen.add_widget(GameScreen(name='game')) return screen
class UZTrainScheduleApp(App): def build(self): self.bind(on_start=self.post_build_init) self.manager = ScreenManager() self.manager.add_widget(MainWindow(name='main_window')) self.manager.add_widget(SelectStationWindow(name='select_departure_station_window')) self.manager.add_widget(SelectStationWindow(name='select_arrival_station_window')) self.manager.add_widget(ListAllResultsWindow(name='list_all_results_window')) self.manager.add_widget(ResultDetailsWindow(name='result_details_window')) return self.manager def post_build_init(self, *args): if platform() == 'android': import android android.map_key(android.KEYCODE_BACK, 1001) window = EventLoop.window window.bind(on_keyboard=self.on_keyboard) def on_keyboard(self, window, keycode, keycode2, text, modifiers): if keycode in [27, 1001]: if self.manager.current in ['select_departure_station_window', 'select_arrival_station_window', 'list_all_results_window']: self.manager.current = 'main_window' return True elif self.manager.current == 'result_details_window': self.manager.current = 'list_all_results_window' return True else: self.stop() return False def on_pause(self): return True
def build(self): manager = ScreenManager() manager.add_widget(Login(name='login')) manager.add_widget(Connected(name='connected')) return manager
def __init__(self, **kv): ScreenManager.__init__(self, **kv) self.app = kv['piikki_app'] from kivy.utils import platform if platform == 'android': path = self.app.user_data_dir else: path = os.getcwd() self.current_customer = None self.customer_handler = CustomerHandler(path) self.item_handler = ItemHandler(path) self.add_widget(MenuScreen(name="menu", main_app = self)) self.add_widget(TestScreen(name="test", main_app=self)) self.add_widget(LoginScreen(name="login", main_app = self)) self.add_widget(AccountScreen(name="account", main_app = self)) self.add_widget(CustomerScreen(name="customer", main_app = self)) self.add_widget(BuyScreen(name="osto", main_app = self)) self.add_widget(AdminScreen(name="admin", main_app = self)) self.add_widget(AccManageScreen(name='acc_manage', main_app = self)) self.add_widget(ItemManageScreen(name='item_manage', main_app = self)) self.add_widget(FileScreen(name="select", main_app = self))
def build(self): self.settings_cls = SettingsWithNoMenu screen_manager = ScreenManager() main_screen = MainScreen() screen_manager.add_widget(main_screen) return screen_manager
def build(self): # Create the screen manager sm = ScreenManager() self.current_battle = DeepSpace(name='DeepSpace') sm.add_widget(self.current_battle) return sm
def build(self): sm = ScreenManager() self.playing = PlayingScreen(sm, name="main") self.playing.init_display() sm.add_widget(self.playing) sm.current = "main" return sm
def build(self): sm = ScreenManager() self.data = DataScreen(name='datascreen') self.edit = EditScreen(name='editscreen') sm.add_widget(self.data) sm.add_widget(self.edit) return sm
def build(self): self.create_protocol() sm = ScreenManager(transition=SlideTransition()) sm.add_widget(MainScreen(name='controller', protocol=self.protocol, screen_manager=sm)) sm.add_widget(NodesScreen(name='nodes', screen_manager=sm)) print self.get_application_config() return sm
def build(self): # --- build sm of subsystem for when this file is called directly sm = ScreenManager(transition=NoTransition()) sm.add_widget(SystemScreen(name="sys-top")) sm.add_widget(shutdown_screen.ShutdownScreen(name="sys-shutdown")) # --- return sm
class MultiplicationGameApp(App): NUMBER_OF_GAMES = 2 OPERAND_MAX = 12 OPERAND_MIN = 1 FONT_NAME = 'fonts/Scratch.ttf' finished_screens = [] def randomize_operand(self): return randint(self.OPERAND_MIN, self.OPERAND_MAX) def next_game(self): if not self.screens.current_screen.input_is_correct: raise RuntimeError("Tried to start a new game with an incorrect answer") else: if len(self.screens.screens) > 1: self.save_result() self.go_to_next_screen() elif isinstance(self.screens.current_screen, GameBoard): self.save_result() self.add_results_screen() self.go_to_next_screen() else: raise Exception("Tried to save the results of the last game. Expected a 'GameBoard', but got a '%s'." % (type(self.screens.current_screen))) def save_result(self): self.finished_screens.append(self.screens.current_screen) def go_to_next_screen(self): self.screens.remove_widget(self.screens.current_screen) def add_results_screen(self): game_results = [] for game_board_screen in self.finished_screens: game_result = GameResult( game_board_screen, orientation='horizontal', size_hint=(1, None), height=50 ) game_results.append(game_result) content = StackLayout(orientation='lr-tb', size_hint=(1, 1)) label = Label(text='RESULTS', size_hint=(1, None), height=100) content.add_widget(label) for game_result in game_results: content.add_widget(game_result) scroller = ScrollView(size_hint=(1, 1)) scroller.add_widget(content) results_screen = ResultsScreen(scroller, name='Results') self.screens.add_widget(results_screen) @property def default_font_name(self): return self.FONT_NAME def build(self): self.screens = ScreenManager() for i in range(0, self.NUMBER_OF_GAMES): self.screens.add_widget(GameBoard(name='Game %d' % i)) return self.screens
def build(self): my_screenmanager = ScreenManager() screen1 = SelectingDataSet(name='screen1') screen2 = RunPCA(name='screen2') my_screenmanager.add_widget(screen1) my_screenmanager.add_widget(screen2) return my_screenmanager
def build(self): root = ScreenManager() for x in range(1): root.add_widget(CustomScreen(name='%s'%x)) if x ==0: root.add_widget(Screen1()) return root
class BackendManager(): subs = ['userData', 'budget', 'spending', 'savingsGoals'] store = JsonStore('key.json') def __init__(self): self.ddp = DDPClient(self, "localhost", 3000) self.sm = ScreenManager(transition=NoTransition()) self.login = LoginScreen(name="Login") self.login.set_ddp_manager(self) self.main_screen = MainScreen(name="Main") self.main_screen.set_ddp_manager(self) self.sm.add_widget(self.login) self.sm.add_widget(self.main_screen) self.subs_ready = 0 self.dispatcher = {"login": self.notify_login} def start(self): self.ddp.connect() if "token" in self.store: self.token = self.store.get("token")['token'] print "token:!!", self.token self.ddp.token_login(self.token) else: self.token = None def notify(self, method): if method in self.dispatcher: self.dispatcher[method]() def notify_login(self): #change screen to app, etc. self.store.put("token", token=self.token) print "logged in" self.setup_subs() def notify_ready(self): self.subs_ready += 1 if self.subs_ready == len(self.subs): #all substriptions have been enabled total = 0 for exp in self.ddp.collections['expenses'][0]['spending']: total += float(exp['amount']) budj = self.ddp.collections['budgets'][0] total = float(budj['total']) - total - float(budj['save']) self.main_screen.total.text += str(total) self.sm.current = "Main" def login_user(self, u, pwd): #change screen to loading self.ddp.login(u, pwd) def setup_subs(self): if(self.ddp.logged_in): for sub in self.subs: self.ddp.subscribe(sub)
def build(self): sm = ScreenManager() ms = MenuScreen(name='menu') st = SettingsScreen(name='settings') sm.add_widget(ms) sm.add_widget(st) sm.current = 'menu' return sm
def build(self): self.notes = Notes(name='notes') self.load_notes() self.transition = SlideTransition(duration=.35) root = ScreenManager(transition=self.transition) root.add_widget(self.notes) return root
class PyThess(App): def build(self): self.my_screenmanager = ScreenManager(transition=FadeTransition()) screen1 = ScreenOne(name='screen1') screen2 = ScreenTwo(name='screen2') self.my_screenmanager.add_widget(screen1) self.my_screenmanager.add_widget(screen2) return self.my_screenmanager
def build(self): sm = ScreenManager() self.a = Monitoring(self,name='Monitor') sm.add_widget(self.a) sm.current = 'Monitor' self.sm = sm reactor.listenTCP(8080, EchoFactory(self)) return sm
def build(self): sm = ScreenManager() sm.add_widget(setup_welcome_screen(sm)) sm.add_widget(setup_menuscreen(sm)) sm.add_widget(setup_computer_board_screen(sm)) sm.add_widget(setup_player_screen(sm)) sm.add_widget(setup_explanation_screen(sm)) return sm
Callback function for handling the selection response from Activity. ''' loadload.toad (self, selection) def on_selection2(self, *a, **k): ''' Update TextInput.text after FileChoose.selection is changed via FileChoose.handle_selection. ''' App.get_running_app().root.ids.result.text = str(self.selection) ############################################################### sm = ScreenManager(transition=NoTransition()) # Creates an instance (copy) of ScreenManager as variable sm. ScreenManager switches between Screen Objects. sm.add_widget(mainscreen.WelcomeScreen(name='welcome_screen')) # Adds WelcomeScreen widget to ScreenManager. ScreenManager id's screen as welcome_screen. sm.add_widget(PoleRemoval(name='poleremove')) sm.add_widget(PoleInstall(name='poleinstall')) class SwitchingScreenApp(App): # Creates the instance (copy) of the Kivy App class named SwitchingScreenApp def build(self): # build is a method of Kivy's App class used to place widgets onto the GUI. sm = ScreenManager(transition=NoTransition()) # Creates an instance (copy) of ScreenManager as variable sm. ScreenManager switches between Screen Objects. sm.add_widget(mainscreen.WelcomeScreen(name='welcome_screen')) # Adds WelcomeScreen widget to ScreenManager. ScreenManager id's screen as welcome_screen. sm.add_widget(PoleRemoval(name='poleremove')) sm.add_widget(PoleInstall(name='poleinstall')) return sm # return calls the build method which in turn builds the GUI.'
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"])
import Menu from kivy.app import App from kivy.uix.screenmanager import ScreenManager, Screen #from kivy.properties import ObjectProperty, NumericProperty class MyApp(App): TITLE = "Log Laws" def build(self): global sm sm.add_widget(Menu.Menu(name="Menu")) Menu.sm = sm return sm if __name__ == '__main__': sm = ScreenManager() MyApp().run()
StaffID = "" StaffName = "" CLASS = "" SUBJECT = "" DATE = "" TIME = "" class_obj = None subject_obj = None date_obj = None time_obj = None StudentRollNo = "" StudentName = "" sm = ScreenManager() def logout(): global StaffID global StaffName StaffID = "" StaffName = "" class RegisterScreen(Screen): def on_enter(self, *args): logout() class StaffScreen(Screen):
def build(self): sm = ScreenManager(transition=FadeTransition()) sm.add_widget(StartScreen(name='start_screen')) sm.add_widget(GameScreen(name='game_screen')) return sm
text: 'My settings button' Button: text: 'Back to menu' on_press: root.manager.current = 'menu' <FunScreen>: on_touch_up: root.manager.current = 'menu' """) # Declare both screens class MenuScreen(Screen): pass class SettingsScreen(Screen): pass class FunScreen(Screen): pass # Create the screen manager sm = ScreenManager() sm.add_widget(MenuScreen(name='menu')) sm.add_widget(SettingsScreen(name='settings')) sm.add_widget(FunScreen(name='fun')) class TestApp(App): def build(self): return sm if __name__ == '__main__': TestApp().run()
class FileChooser(FileChooserController): '''Implementation of :class:`FileChooserController` which supports switching between multiple, synced layout views. .. versionadded:: 1.9.0 ''' manager = ObjectProperty() ''' Reference to the :class:`~kivy.uix.screenmanager.ScreenManager` instance. :class:`~kivy.properties.ObjectProperty` ''' _view_list = ListProperty() def get_view_list(self): return self._view_list view_list = AliasProperty(get_view_list, bind=('_view_list', )) ''' List of views added to this FileChooser. :class:`~kivy.properties.AliasProperty` of type :class:`list`. ''' _view_mode = StringProperty() def get_view_mode(self): return self._view_mode def set_view_mode(self, mode): if mode not in self._view_list: raise ValueError('unknown view mode %r' % mode) self._view_mode = mode view_mode = AliasProperty(get_view_mode, set_view_mode, bind=('_view_mode', )) ''' Current layout view mode. :class:`~kivy.properties.AliasProperty` of type :class:`str`. ''' @property def _views(self): return [screen.children[0] for screen in self.manager.screens] def __init__(self, **kwargs): super(FileChooser, self).__init__(**kwargs) self.manager = ScreenManager() super(FileChooser, self).add_widget(self.manager) self.trigger_update_view = Clock.create_trigger(self.update_view) self.bind(view_mode=self.trigger_update_view) def add_widget(self, widget, **kwargs): if widget is self._progress: super(FileChooser, self).add_widget(widget, **kwargs) elif hasattr(widget, 'VIEWNAME'): name = widget.VIEWNAME + 'view' screen = Screen(name=name) widget.controller = self screen.add_widget(widget) self.manager.add_widget(screen) self.trigger_update_view() else: raise ValueError('widget must be a FileChooserLayout, not %s' % type(widget).__name__) def rebuild_views(self): views = [view.VIEWNAME for view in self._views] if views != self._view_list: self._view_list = views if self._view_mode not in self._view_list: self._view_mode = self._view_list[0] self._trigger_update() def update_view(self, *args): self.rebuild_views() sm = self.manager viewlist = self._view_list view = self.view_mode current = sm.current[:-4] viewindex = viewlist.index(view) if view in viewlist else 0 currentindex = viewlist.index(current) if current in viewlist else 0 direction = 'left' if currentindex < viewindex else 'right' sm.transition.direction = direction sm.current = view + 'view' def _create_entry_widget(self, ctx): return [ Builder.template(view._ENTRY_TEMPLATE, **ctx) for view in self._views ] def _get_file_paths(self, items): if self._views: return [file[0].path for file in items] return [] def _update_item_selection(self, *args): for viewitem in self._items: selected = viewitem[0].path in self.selection for item in viewitem: item.selected = selected def on_entry_added(self, node, parent=None): for index, view in enumerate(self._views): view.dispatch('on_entry_added', node[index], parent[index] if parent else None) def on_entries_cleared(self): for view in self._views: view.dispatch('on_entries_cleared') def on_subentry_to_entry(self, subentry, entry): for index, view in enumerate(self._views): view.dispatch('on_subentry_to_entry', subentry[index], entry) def on_remove_subentry(self, subentry, entry): for index, view in enumerate(self._views): view.dispatch('on_remove_subentry', subentry[index], entry) def on_submit(self, selected, touch=None): view_mode = self.view_mode for view in self._views: if view_mode == view.VIEWNAME: view.dispatch('on_submit', selected, touch) return
def build(self): sm = ScreenManager() sm.add_widget(ConfigScreen()) return sm
def create(self, year, month, day): self.build() country = driver().getCity()['countryCode'] iso = datetime(int(year), int(month), int(day)) key = getstrftime('%A, %B {S}, %Y', iso) islamic_date = getDict()[key].split(',')[1].strip() hijri = convert.Gregorian(year, month, day).to_hijri().datetuple() hijri_iso = f"{hijri[2]}-{hijri[1]}" islamic = [] self.label = MDLabel() self.label.size_hint_y = .05 self.label.font_size = "35px" self.label.halign = "center" self.label.text = islamic_date tabs = Tabs() tabs.on_tab_switch = self.on_tab_switch events = Screen(name='events') namaz = Screen(name='namaz') personal_events = getPersonal(str(iso).split()[0]) layout = MDBoxLayout(orientation='vertical') eventslayout = MDBoxLayout(orientation='vertical') self.sm = ScreenManager() events.add_widget(eventslayout) self.sm.add_widget(events) self.sm.add_widget(namaz) tabs.add_widget(Tab(text="Events")) tabs.add_widget(Tab(text="Namaz Times")) personalscreen = PersonalEvents() world = WorldEvents() scroll = ScrollView() self.nrv = MDList() self.wrv = world.ids.wrv self.prv = personalscreen.ids.prv self.holidays = json.loads( requests.get( f'https://calendarific.com/api/v2/holidays?&api_key={APIKEY}&country={country}&year={year}' ).text) self.holidays['year'] = year with open('./lib/data/islamic.json', 'r', encoding="utf-8") as file: data = json.loads(str(file.read())) for key in data.keys(): if key == hijri_iso: islamic.append(data[key]["event"]) holidays = (Holidays().getHoliday(day, month, year, self.holidays)) self.wrv.add_widget(OneLineListItem(text="No Events")) self.prv.add_widget(OneLineListItem(text="No Events")) if holidays or islamic: self.wrv.clear_widgets() for i in holidays + islamic: text = str(i) description = None if type(i) == dict: text = str(i['name']) description = str(i['description']) item = EventItem(text=str(text), description=str(description)) self.wrv.add_widget(item) if personal_events: self.prv.clear_widgets() for x in personal_events: item = OneLineListItem(text=str(x)) self.prv.add_widget(item) self.namaz_times = driver().getSalaatTimesForDate(iso) for item in self.namaz_times.keys(): self.nrv.add_widget( TwoLineListItem(text=str(item), secondary_text=str(self.namaz_times[item]), height=dp(50))) scroll.add_widget(self.nrv) layout.add_widget(self.label) layout.add_widget(tabs) layout.add_widget(self.sm) eventslayout.add_widget(world) eventslayout.add_widget(personalscreen) namaz.add_widget(scroll) self.sm.current = "events" self.add_widget(layout) return self
markup: True font_name: 'fonts/Gilroy-light.otf' font_size: '18dp' pos_hint: {'x': .15, 'center_y' : .4} ''' class MainUI(Screen): pass sm = ScreenManager() sm.add_widget(MainUI(name = 'MainUI')) class Weatherapp(MDApp): def build(self): self.screen = Screen() main = Builder.load_string(kv) self.screen.add_widget(main) return self.screen
if not q3 == '': # Forward pass to get output/logits outputs = vqa_model(img_vecs, [q3]) # Get predictions from the maximum value _, predicted = torch.max(outputs.data, 1) predicted_label = predicted.cpu().numpy()[0] answer = answer_dict.keys()[answer_dict.values().index( predicted_label)] self.ans_right_ip.text = answer else: self.ans_right_ip.text = '' # The ScreenManager controls moving between screens screen_manager = ScreenManager() # Add the screens to the manager and then supply a name # that is used to switch screens screen_manager.add_widget(ScreenOne(name="screen_one")) screen_manager.add_widget(ScreenTwo(name="screen_two")) class RadiologyJr(App): def build(self): return screen_manager sample_app = RadiologyJr() sample_app.run()
def build(self): self.sm = ScreenManager() self.sm.add_widget(MainMenuScreen(name='mainmenu')) self.sm.add_widget(GameScreen(name='game')) self.sm.current = 'mainmenu' return self.sm
<Hello>: name: 'hello' MDRaisedButton: text: 'TOAST UP' pos_hint: {'center_x':0.5,'center_y':0.5} user_font_size: '80sp' on_press: app.toast_up() ''' class Hello(Screen): pass sm = ScreenManager() sm.add_widget(Hello(name='hello')) class DemoApp(MDApp): def build(self): screen = Screen() self.help_str = Builder.load_string(helper_string) screen.add_widget(self.help_str) return screen def toast_up(self): toast("Hi!! Toast")
self.fileScreen = Filesx(name='s2') self.fileScreen.ids.filechooser.path = self.defaultPath pass def selected(self): print("halla ctm") #text = Filesx.selected(self) text = super(controller, self).selected() + "45" print(text) pass pass control = controller() sm = ScreenManager() #sm.add_widget(Player(name = 's1')) #sm.add_widget(Filesx(name='s2')) sm.add_widget(control.mainScreen) #control.mainScreen.ids.Player.source = Saver.fullpath.get() sm.add_widget(control.fileScreen) class TestApp(App): saver = Saver() def build(self): return sm #Player() #return Button(text= 'reconchatumadre')
def build(self): Window.fullscreen = "auto" self.title = 'SuperAdminister' return ScreenManager()
menu_label.pos_hint = {'x': 0.01, 'y': 0.4} Window.add_widget(menu_label) cal_label = Label(text='Calculate Saree No', font_size=30, opacity=0) cal_label.pos_hint = {'x': 0.01, 'y': 0.4} Window.add_widget(cal_label) scroll_label = Label(text='Available List', font_size=30, opacity=0) scroll_label.pos_hint = {'x': 0.01, 'y': 0.4} Window.add_widget(scroll_label) create_label = Label(text='Create List', font_size=30, opacity=0) create_label.pos_hint = {'x': 0.01, 'y': 0.4} Window.add_widget(create_label) sm = ScreenManager(transition=SlideTransition()) s7 = None s6 = None s5 = None s4 = None s3 = None s2 = None database = None database2 = None gst = 0 factor = 0 flag = 4 class Bill: def __init__(self, **kwargs):
class ELiDEApp(App): """Extensible LiSE Development Environment. """ title = 'ELiDE' engine = ObjectProperty() branch = StringProperty('trunk') turn = NumericProperty(0) tick = NumericProperty(0) character = ObjectProperty() selection = ObjectProperty(None, allownone=True) selected_proxy = ObjectProperty() def on_selection(self, *args): Logger.debug("App: {} selected".format(self.selection)) def _get_character_name(self, *args): if self.character is None: return return self.character.name def _set_character_name(self, name): if self.character.name != name: self.character = self.engine.character[name] character_name = AliasProperty(_get_character_name, _set_character_name, bind=('character', )) def _pull_time(self, *args): if not self.engine: Clock.schedule_once(self._pull_time, 0) return branch, turn, tick = self.engine.btt() self.branch = branch self.turn = turn self.tick = tick pull_time = trigger(_pull_time) @trigger def _push_time(self, *args): branch, turn, tick = self.engine.btt() if (self.branch, self.turn, self.tick) != (branch, turn, tick): self.engine.time_travel( self.branch, self.turn, self.tick if self.tick != tick else None, chars=[self.character.name], cb=self.mainscreen._update_from_time_travel) def set_tick(self, t): """Set my tick to the given value, cast to an integer.""" self.tick = int(t) def set_turn(self, t): self.turn = int(t) def select_character(self, char): """Change my ``character`` to the selected character object if they aren't the same. """ if char == self.character: return self.character = char def build_config(self, config): """Set config defaults""" for sec in 'LiSE', 'ELiDE': config.adddefaultsection(sec) config.setdefaults( 'LiSE', { 'world': 'sqlite:///LiSEworld.db', 'language': 'eng', 'logfile': '', 'loglevel': 'info' }) config.setdefaults( 'ELiDE', { 'boardchar': 'physical', 'debugger': 'no', 'inspector': 'no', 'user_kv': 'yes', 'play_speed': '1', 'thing_graphics': json.dumps( [("Marsh Davies' Island", 'marsh_davies_island_fg.atlas'), ('RLTiles: Body', 'base.atlas'), ('RLTiles: Basic clothes', 'body.atlas'), ('RLTiles: Armwear', 'arm.atlas'), ('RLTiles: Legwear', 'leg.atlas'), ('RLTiles: Right hand', 'hand1.atlas'), ('RLTiles: Left hand', 'hand2.atlas'), ('RLTiles: Boots', 'boot.atlas'), ('RLTiles: Hair', 'hair.atlas'), ('RLTiles: Beard', 'beard.atlas'), ('RLTiles: Headwear', 'head.atlas')]), 'place_graphics': json.dumps( [("Marsh Davies' Island", 'marsh_davies_island_bg.atlas'), ("Marsh Davies' Crypt", 'marsh_davies_crypt.atlas'), ('RLTiles: Dungeon', 'dungeon.atlas')]) }) config.write() def build(self): """Make sure I can use the database, create the tables as needed, and return the root widget. """ self.icon = 'icon_24px.png' config = self.config Logger.debug("ELiDEApp: starting with world {}, path {}".format( config['LiSE']['world'], LiSE.__path__[-1])) if config['ELiDE']['debugger'] == 'yes': import pdb pdb.set_trace() self.manager = ScreenManager() if config['ELiDE']['inspector'] == 'yes': from kivy.core.window import Window from kivy.modules import inspector inspector.create_inspector(Window, self.manager) Clock.schedule_once(self._start_subprocess, 0.1) Clock.schedule_once(self._add_screens, 0.2) return self.manager def _pull_lang(self, *args, **kwargs): self.strings.language = kwargs['language'] def _pull_chars(self, *args, **kwargs): self.chars.names = list(self.engine.character) def _pull_time_from_signal(self, *args, branch, turn, tick): self.branch, self.turn, self.tick = branch, turn, tick def _start_subprocess(self, *args): config = self.config self.procman = EngineProcessManager() enkw = {'logger': Logger, 'validate': True} if config['LiSE'].get('logfile'): enkw['logfile'] = config['LiSE']['logfile'] if config['LiSE'].get('loglevel'): enkw['loglevel'] = config['LiSE']['loglevel'] self.engine = self.procman.start(config['LiSE']['world'], **enkw) self.pull_time() self.engine.time.connect(self._pull_time_from_signal, weak=False) self.engine.string.language.connect(self._pull_lang, weak=False) self.engine.character.connect(self._pull_chars, weak=False) self.bind(branch=self._push_time, turn=self._push_time, tick=self._push_time) char = config['ELiDE']['boardchar'] if char not in self.engine.character: self.engine.add_character(char) def _add_screens(self, *args): def toggler(screenname): def tog(*args): if self.manager.current == screenname: self.manager.current = 'main' else: self.manager.current = screenname return tog config = self.config self.pawncfg = ELiDE.spritebuilder.PawnConfigScreen( toggle=toggler('pawncfg'), data=json.loads(config['ELiDE']['thing_graphics'])) self.spotcfg = ELiDE.spritebuilder.SpotConfigScreen( toggle=toggler('spotcfg'), data=json.loads(config['ELiDE']['place_graphics'])) self.rules = ELiDE.rulesview.RulesScreen(engine=self.engine, toggle=toggler('rules')) self.chars = ELiDE.charsview.CharactersScreen( engine=self.engine, toggle=toggler('chars'), names=list(self.engine.character), new_board=self.new_board) self.bind(character_name=self.chars.setter('character_name')) def chars_push_character_name(*args): self.unbind(character_name=self.chars.setter('character_name')) self.character_name = self.chars.character_name self.bind(character_name=self.chars.setter('character_name')) self.chars.push_character_name = chars_push_character_name self.strings = ELiDE.stores.StringsEdScreen( language=self.engine.string.language, language_setter=self._set_language, toggle=toggler('strings')) self.funcs = ELiDE.stores.FuncsEdScreen(name='funcs', toggle=toggler('funcs')) self.select_character( self.engine.character[config['ELiDE']['boardchar']]) self.statcfg = ELiDE.statcfg.StatScreen(toggle=toggler('statcfg'), engine=self.engine) self.bind(selected_proxy=self.statcfg.setter('proxy')) dialog_todo = self.engine.universal.get('last_result', []) if dialog_todo: idx = int(self.engine.universal['last_result_idx']) if idx >= len(dialog_todo): dialog_todo = [] else: dialog_todo = dialog_todo[idx:] self.mainscreen = ELiDE.screen.MainScreen( use_kv=config['ELiDE']['user_kv'] == 'yes', play_speed=int(config['ELiDE']['play_speed']), dialog_todo=dialog_todo, boards={ name: Board(character=char) for name, char in self.engine.character.items() }) if self.mainscreen.statlist: self.statcfg.statlist = self.mainscreen.statlist self.mainscreen.bind(statlist=self.statcfg.setter('statlist')) self.bind(selection=self.refresh_selected_proxy, character=self.refresh_selected_proxy) self.selected_proxy = self._get_selected_proxy() for wid in (self.mainscreen, self.pawncfg, self.spotcfg, self.statcfg, self.rules, self.chars, self.strings, self.funcs): self.manager.add_widget(wid) def _set_language(self, lang): self.engine.string.language = lang def _get_selected_proxy(self): if self.selection is None: return self.character.stat elif hasattr(self.selection, 'proxy'): return self.selection.proxy elif (hasattr(self.selection, 'portal') and self.selection.portal is not None): return self.selection.portal else: raise ValueError("Invalid selection: {}".format(self.selection)) def refresh_selected_proxy(self, *args): self.selected_proxy = self._get_selected_proxy() def on_character_name(self, *args): if self.config['ELiDE']['boardchar'] != self.character_name: self.config['ELiDE']['boardchar'] = self.character_name def on_character(self, *args): if not hasattr(self, 'mainscreen'): Clock.schedule_once(self.on_character, 0) return if hasattr(self, '_oldchar'): self.mainscreen.boards[self._oldchar.name].unbind( selection=self.setter('selection')) self.selection = None self.mainscreen.boards[self.character.name].bind( selection=self.setter('selection')) def on_pause(self): """Sync the database with the current state of the game.""" self.engine.commit() self.strings.save() self.funcs.save() self.config.write() def on_stop(self, *largs): """Sync the database, wrap up the game, and halt.""" self.strings.save() self.funcs.save() self.engine.commit() self.procman.shutdown() self.config.write() def delete_selection(self): """Delete both the selected widget and whatever it represents.""" selection = self.selection if selection is None: return if isinstance(selection, ArrowWidget): self.selection = None self.mainscreen.boardview.board.rm_arrow( selection.origin.name, selection.destination.name) selection.portal.delete() elif isinstance(selection, Spot): self.selection = None self.mainscreen.boardview.board.rm_spot(selection.name) selection.proxy.delete() else: assert isinstance(selection, Pawn) self.selection = None self.mainscreen.boardview.board.rm_pawn(selection.name) selection.proxy.delete() def new_board(self, name): """Make a board for a character name, and switch to it.""" char = self.engine.character[name] board = Board(character=char) self.mainscreen.boards[name] = board self.character = char
def build(self): # build is a method of Kivy's App class used to place widgets onto the GUI. sm = ScreenManager(transition=NoTransition()) # Creates an instance (copy) of ScreenManager as variable sm. ScreenManager switches between Screen Objects. sm.add_widget(mainscreen.WelcomeScreen(name='welcome_screen')) # Adds WelcomeScreen widget to ScreenManager. ScreenManager id's screen as welcome_screen. sm.add_widget(PoleRemoval(name='poleremove')) sm.add_widget(PoleInstall(name='poleinstall')) return sm # return calls the build method which in turn builds the GUI.'
self.manager.transition.direction = 'left' self.manager.current = 'screen_two' else: info_label.text = "Wrong Credentials" class ScreenTwo(Screen): pass class MenuTabs(TabbedPanel): pass # The ScreenManager controls moving between screens screen_manager = ScreenManager() # Add the screens to the manager and then supply a name # that is used to switch screens screen_manager.add_widget(ScreenLogin(name="screen_login")) screen_manager.add_widget(ScreenTwo(name="screen_two")) class MyProviApp(App): def build(self): return screen_manager sample_app = MyProviApp() sample_app.run()
def build(self): manager = ScreenManager() print("building") Window.size = (500, 500) manager.add_widget(Login(name='login')) manager.add_widget(Connected(name='connected')) manager.add_widget(Options(name='options')) manager.add_widget(Screen1(name='screen1')) manager.add_widget(Screen2(name='screen2')) manager.add_widget(Screen3(name='screen3')) manager.add_widget(SendMail(name='sendmail')) manager.add_widget(Search(name='search')) manager.add_widget(Latest(name='latest')) #manager.add_widget(Done(name='done')) return manager
def build(self): root = ScreenManager() root.add_widget(HomeScreen(name='Home')) root.add_widget(MenuScreen(name='Menu')) root.add_widget(ProductionScreen(name='Production')) root.add_widget(PadScreen(name='Pad')) root.add_widget(Tracks(name='Tracks')) root.add_widget(ChooseInstruOne(name='InstruOne')) root.add_widget(ChooseInstruTwo(name='InstruTwo')) root.add_widget(RecordingOne(name='RecordOne')) root.add_widget(RecordingTwo(name='RecordTwo')) return root
popupWin.open() class LevelCompletePopUp(FloatLayout): #show num of stars completed with (based on lost exp) global lvlChosen def getStarsImg(self): return gdb.getStarsImg(userID)[lvlChosen-1] buttonObj = ObjectProperty(None) def getButtonObj(self): return self.buttonObj def show_LevelCompletePopUp(): show = LevelCompletePopUp() popupWin = Popup(title='Level Completed', content=show, size_hint=(None,None), size=(400,250)) show.getButtonObj().bind(on_press=popupWin.dismiss) popupWin.open() screen_manager = ScreenManager() screen_manager.add_widget(LoginPage()) screen_manager.add_widget(SignUpPage()) screen_manager.add_widget(MainPage()) # display hero (lvl, exp) + pet (lvl, exp), user stats (lvl, exp, current villain) [left top], user guide [left bottom], log out [right top], play [right bottom] screen_manager.add_widget(MazePage()) screen_manager.add_widget(FightingPage()) class GameApp(App): def build(self): return screen_manager if __name__ == '__main__': GameApp().run()
pass class Games(Screen): def on_pre_enter(self): self.ids.btnstack.clear_widgets() for game in SoundBoard: btn = GameButton() btn.name = game[0] btn.source = 'data\\' + game[0] + '.png' self.ids.btnstack.add_widget(btn) cat = Builder.load_file('cat.kv') sm = ScreenManager() sm.add_widget(MainMenu(name='MainMenu')) sm.add_widget(Games(name='Games')) sm.add_widget(Sounds(name='Sounds')) sm.add_widget(AdvSounds(name='AdvSounds')) cat.add_widget(sm) class CATApp(App): oldname = None def build(self): return cat def go_screen(self, screen, dir):
class MuhasibApp(App): '''Muhasib app object''' use_kivy_settings = False icon = join("data", "logo.png") settings = DictProperty() def __init__(self, **kwargs): super().__init__(**kwargs) # Load the setting configuration setting its prayer time parameters self.prayer_times = PrayerTimes() self.load_settings() # Initialize the database self.database = Database() self.create_database_day() # Initializing all the screens and the screen manager self.screen_manager = ScreenManager() self.navigationdrawer = NavigationDrawer() self.location_popup = LocationPopup() # Add all the screens onto the screen manager self.screen_manager.add_widget(Dashboard()) self.screen_manager.add_widget(PrayerTimesScreen()) self.screen_manager.add_widget(PrayerRecordsScreen()) self.screen_manager.add_widget(PrayerGraphsScreen()) self.screen_manager.add_widget(CalendarScreen()) self.screen_manager.add_widget(QiblaScreen()) self.screen_manager.add_widget(SettingsScreen()) # Set up the navigation drawer self.navigationdrawer.anim_type = "slide_above_anim" self.navigationdrawer.opening_transition = "out_sine" self.navigationdrawer.opening_transition = "out_sine" self.navigationdrawer.set_side_panel(NavigationWidget()) self.navigationdrawer.set_main_panel(self.screen_manager) # Create interval events Clock.schedule_once(lambda _: self.location_check()) Clock.schedule_interval(lambda _: self.day_pass_check(), 3600) def get_current_time(self): '''Get the UTC time of the timezone currently set in settings''' return datetime.now(tz=timezone(self.settings["timezone"])) def get_formatted_time(self, time): '''Take a time and return it in the string format of the configuration''' if self.settings["time_format"] == "24h": return time.strftime("%H:%M") else: return time.strftime("%I:%M %p") def set_prayer_times_settings(self): '''Change the prayer times calculation settings according to app's settings''' self.prayer_times.imsak_time = self.settings["imsak_time"] self.prayer_times.settings["high_lats"] = self.settings["high_lats"] self.prayer_times.settings["dhuhr"] = self.settings["dhuhr_offset"] self.prayer_times.settings["imsak"] = self.settings["imsak_offset"] self.prayer_times.settings["jummah"] = self.settings["jummah_offset"] self.prayer_times.offset["fajr"] = self.settings["fajr_adjustment"] self.prayer_times.offset["dhuhr"] = self.settings["dhuhr_adjustment"] self.prayer_times.offset["asr"] = self.settings["asr_adjustment"] self.prayer_times.offset["maghrib"] = self.settings[ "maghrib_adjustment"] self.prayer_times.offset["isha"] = self.settings["isha_adjustment"] self.prayer_times.time_format = self.settings["time_format"] self.prayer_times.asr_param = self.settings["asr_factor"] self.prayer_times.set_method(self.settings["calc_method"]) def set_prayer_time_location(self): '''Change the prayer time location variables according to the settings''' self.prayer_times.lat = self.settings["latitude"] self.prayer_times.lng = self.settings["longitude"] self.prayer_times.alt = self.settings["altitude"] self.prayer_times.timezone = utcoffset(self.settings["timezone"]) def change_location(self, location, lat, lng, alt, tz): '''Change all the location data and modify prayer times appropriately''' self.settings["location"] = location self.settings["latitude"] = lat self.settings["longitude"] = lng self.settings["altitude"] = alt self.settings["timezone"] = tz self.set_prayer_time_location() # Refresh the screen currently opened if required if hasattr(self.screen_manager.current_screen, "refresh"): self.screen_manager.current_screen.refresh() def location_check(self): '''Check if location is present, if not open the form to get location''' if self.location_data_present(): self.set_prayer_time_location() elif platform == "android": self.location_popup.request_gps_permission() else: self.location_popup.open() def location_data_present(self): '''Check if the location data is in the configuration''' if self.settings["location"] and self.settings[ "latitude"] and self.settings["longitude"] and self.settings[ "timezone"]: return True else: return False def load_settings(self): '''Load the setttings configuration from the file and make the file if it doesn't exist''' try: with open("settings.json", "r") as json_file: self.settings = json.load(json_file) except FileNotFoundError: self.settings = { "latitude": 0, "longitude": 0, "altitude": 0, "location": "", "calc_method": "Muslim World League", "asr_factor": "Standard", "time_format": "24h", "imsak_time": "Show", "high_lats": "Night Middle", "dhuhr_offset": "0 min", "imsak_offset": "10 min", "jummah_offset": "15 min", "fajr_adjustment": "0 min", "dhuhr_adjustment": "0 min", "asr_adjustment": "0 min", "maghrib_adjustment": "0 min", "isha_adjustment": "0 min", "fasting_record": "Show in Ramazan", "quran_record": "Don't Show", "hadees_record": "Don't Show", "hijri_adjustment": "0" } self.save_settings() def display_settings(self, *args): '''Overriding the kivy app settings display function to not display that ugly monstrosity''' return False def save_settings(self): '''Save the settings in a json file''' with open(join("data", "settings.json"), "w") as json_file: json.dump(self.settings, json_file) def on_pause(self): '''Pause the app''' return True def on_settings(self, instance, value): '''When config changes then upgrade prayer time configuration and save the settings''' self.set_prayer_times_settings() self.save_settings() def day_pass_check(self): '''Check if a day has passed and upgrade the prayer times and records if it has''' if self.today != date.today(): self.prayer_times.timezone = utcoffset(self.settings["timezone"]) self.create_database_day() def create_database_day(self): '''Create a row in the database for the day''' self.today = date.today() self.database.create_record(self.today) def build(self): if platform == "android": hide_loading_screen() return self.navigationdrawer
class LearnItApp(App): def build(self): self.screen_manager = ScreenManager() # okienko powitalne self.entry_page = EntryPage() screen = Screen(name="EntryPage") screen.add_widget(self.entry_page) self.screen_manager.add_widget(screen) # wybranie trybu wpisywania nowych slowek self.add_choose_page = AddChoosePage() screen = Screen(name="AddChoosePage") screen.add_widget(self.add_choose_page) self.screen_manager.add_widget(screen) # dodaj slowko self.add_word = AddWord() screen = Screen(name="AddWord") screen.add_widget(self.add_word) self.screen_manager.add_widget(screen) # dodaj nowa liste self.create_new_list = CreateNewList() screen = Screen(name="CreateNewList") screen.add_widget(self.create_new_list) self.screen_manager.add_widget(screen) # wordpage self.word_page = WordPage() screen = Screen(name="WordPage") screen.add_widget(self.word_page) self.screen_manager.add_widget(screen) # ustawienia self.settings = Settings() screen = Screen(name="Settings") screen.add_widget(self.settings) self.screen_manager.add_widget(screen) return self.screen_manager
def build(self): self.ScreenManager = ScreenManager() self.sc1 = Screen(name='firstscreen') self.sc2 = Screen(name='secscreen') self.file_dir = '' self.file_name = '' self.compile = Button(text='Скомпилировать', on_press=self.CompileCPP) self.run = Button(text='Запустить', on_press=self.StartEXE) self.dropdown = DropDown() self.btn1 = Button(text='Сохранить как', size_hint_y=None, height=30, on_press=self.SaveAsFile) self.btn2 = Button(text='Сохранить', size_hint_y=None, height=30, on_press=self.SaveAs) self.btn3 = Button(text='Открыть файл', size_hint_y=None, height=30, on_press=self.ReadFromFile) self.btn4 = Button(text='Подсказки', size_hint_y=None, height=30, on_press=self.secrets) self.btn1.bind() self.secscrbutt1 = Button(text='Назад', size_hint_y=None, pos_hint={'top': 1}, height=30, on_press=self.MainWindow) self.secscrBox = BoxLayout() self.secscrBox.add_widget(self.secscrbutt1) self.secscrAnch = AnchorLayout(anchor_y='top') self.secscrAnch.add_widget(self.secscrBox) self.secscrtext = CodeInput(text="", lexer=CLexer()) self.secscrBox2 = BoxLayout(size_hint=[.8, .953]) self.secscrBox2.add_widget(self.secscrtext) self.secscrAnch2 = AnchorLayout(anchor_y='bottom', anchor_x='right') self.secscrAnch2.add_widget(self.secscrBox2) self.pod1 = Button(text='Hello World!', on_press=self.Tips) self.pod2 = Button(text='Типы данных', on_press=self.Tips) self.pod3 = Button(text='Циклы', on_press=self.Tips) self.pod4 = Button(text='Массивы', on_press=self.Tips) self.pod5 = Button(text='Функции', on_press=self.Tips) self.pod6 = Button(text='Указатели', on_press=self.Tips) self.pod7 = Button(text='Классы', on_press=self.Tips) self.secscrBox3 = BoxLayout(orientation='vertical', size_hint=[.2, .953], spacing=1) self.secscrAnch3 = AnchorLayout(anchor_y='bottom', anchor_x='left') self.secscrBox3.add_widget(self.pod1) self.secscrBox3.add_widget(self.pod2) self.secscrBox3.add_widget(self.pod3) self.secscrBox3.add_widget(self.pod4) self.secscrBox3.add_widget(self.pod5) self.secscrBox3.add_widget(self.pod6) self.secscrBox3.add_widget(self.pod7) self.secscrAnch3.add_widget(self.secscrBox3) self.dropdown.add_widget(self.btn1) self.dropdown.add_widget(self.btn2) self.dropdown.add_widget(self.btn3) self.dropdown.add_widget(self.btn4) self.fileButton = Button(text='Меню') self.fileButton.bind(on_release=self.dropdown.open) self.dropdown.bind( on_select=lambda instance, x: setattr(self.fileButton, 'text', x)) self.MyText = CodeInput(text="", lexer=CLexer()) self.MyBox = BoxLayout(orientation='horizontal', size_hint=[1, .07]) self.MyBox.add_widget(self.fileButton) self.MyBox.add_widget(self.compile) self.MyBox.add_widget(self.run) self.MyBox2 = BoxLayout(size_hint=[1, .93]) self.MyBox2.add_widget(self.MyText) self.MyAnchor = AnchorLayout(anchor_y='top', anchor_x='left') self.MyAnchor2 = AnchorLayout(anchor_y='bottom') self.MyAnchor.add_widget(self.MyBox) self.MyAnchor2.add_widget(self.MyBox2) self.OAnchor = AnchorLayout() self.OAnchor.add_widget(self.MyAnchor) self.OAnchor.add_widget(self.MyAnchor2) self.sc1.add_widget(self.OAnchor) self.sc2.add_widget(self.secscrAnch) self.sc2.add_widget(self.secscrAnch2) self.sc2.add_widget(self.secscrAnch3) self.ScreenManager.add_widget(self.sc1) self.ScreenManager.add_widget(self.sc2) return self.ScreenManager
hash_password = sha256_crypt.hash(args[2]) data_to_be_inserted = (args[0], args[1], hash_password, args[3]) c.execute(query, data_to_be_inserted) args[0], args[1], args[2], args[3] = "" c.close() conn.commit() conn.close() except (Exception, TypeError) as e: print(e) else: pass sm = ScreenManager() sm.add_widget(LoginScreen(name="login")) sm.add_widget(HomeScreen(name="Homescreen")) sm.add_widget(CreateAccountScreen(name="create_account")) class AEApp(MDApp): #icons = list(md_icons.keys())[15:30] def build(self): self.theme_cls.primary_palette = "Green" self.builder = Builder.load_string(helper_string) return self.builder def on_tab_switch(self, instance_tabs, instance_tab, instance_tab_label, tab_text): instance_tab.ids.label.text = tab_text
class MyApp(App): def build(self): self.ScreenManager = ScreenManager() self.sc1 = Screen(name='firstscreen') self.sc2 = Screen(name='secscreen') self.file_dir = '' self.file_name = '' self.compile = Button(text='Скомпилировать', on_press=self.CompileCPP) self.run = Button(text='Запустить', on_press=self.StartEXE) self.dropdown = DropDown() self.btn1 = Button(text='Сохранить как', size_hint_y=None, height=30, on_press=self.SaveAsFile) self.btn2 = Button(text='Сохранить', size_hint_y=None, height=30, on_press=self.SaveAs) self.btn3 = Button(text='Открыть файл', size_hint_y=None, height=30, on_press=self.ReadFromFile) self.btn4 = Button(text='Подсказки', size_hint_y=None, height=30, on_press=self.secrets) self.btn1.bind() self.secscrbutt1 = Button(text='Назад', size_hint_y=None, pos_hint={'top': 1}, height=30, on_press=self.MainWindow) self.secscrBox = BoxLayout() self.secscrBox.add_widget(self.secscrbutt1) self.secscrAnch = AnchorLayout(anchor_y='top') self.secscrAnch.add_widget(self.secscrBox) self.secscrtext = CodeInput(text="", lexer=CLexer()) self.secscrBox2 = BoxLayout(size_hint=[.8, .953]) self.secscrBox2.add_widget(self.secscrtext) self.secscrAnch2 = AnchorLayout(anchor_y='bottom', anchor_x='right') self.secscrAnch2.add_widget(self.secscrBox2) self.pod1 = Button(text='Hello World!', on_press=self.Tips) self.pod2 = Button(text='Типы данных', on_press=self.Tips) self.pod3 = Button(text='Циклы', on_press=self.Tips) self.pod4 = Button(text='Массивы', on_press=self.Tips) self.pod5 = Button(text='Функции', on_press=self.Tips) self.pod6 = Button(text='Указатели', on_press=self.Tips) self.pod7 = Button(text='Классы', on_press=self.Tips) self.secscrBox3 = BoxLayout(orientation='vertical', size_hint=[.2, .953], spacing=1) self.secscrAnch3 = AnchorLayout(anchor_y='bottom', anchor_x='left') self.secscrBox3.add_widget(self.pod1) self.secscrBox3.add_widget(self.pod2) self.secscrBox3.add_widget(self.pod3) self.secscrBox3.add_widget(self.pod4) self.secscrBox3.add_widget(self.pod5) self.secscrBox3.add_widget(self.pod6) self.secscrBox3.add_widget(self.pod7) self.secscrAnch3.add_widget(self.secscrBox3) self.dropdown.add_widget(self.btn1) self.dropdown.add_widget(self.btn2) self.dropdown.add_widget(self.btn3) self.dropdown.add_widget(self.btn4) self.fileButton = Button(text='Меню') self.fileButton.bind(on_release=self.dropdown.open) self.dropdown.bind( on_select=lambda instance, x: setattr(self.fileButton, 'text', x)) self.MyText = CodeInput(text="", lexer=CLexer()) self.MyBox = BoxLayout(orientation='horizontal', size_hint=[1, .07]) self.MyBox.add_widget(self.fileButton) self.MyBox.add_widget(self.compile) self.MyBox.add_widget(self.run) self.MyBox2 = BoxLayout(size_hint=[1, .93]) self.MyBox2.add_widget(self.MyText) self.MyAnchor = AnchorLayout(anchor_y='top', anchor_x='left') self.MyAnchor2 = AnchorLayout(anchor_y='bottom') self.MyAnchor.add_widget(self.MyBox) self.MyAnchor2.add_widget(self.MyBox2) self.OAnchor = AnchorLayout() self.OAnchor.add_widget(self.MyAnchor) self.OAnchor.add_widget(self.MyAnchor2) self.sc1.add_widget(self.OAnchor) self.sc2.add_widget(self.secscrAnch) self.sc2.add_widget(self.secscrAnch2) self.sc2.add_widget(self.secscrAnch3) self.ScreenManager.add_widget(self.sc1) self.ScreenManager.add_widget(self.sc2) return self.ScreenManager def secrets(self, instance): self.ScreenManager.current = 'secscreen' def MainWindow(self, instance): self.ScreenManager.current = 'firstscreen' def ReadFromFile(self, instance): try: from tkinter import Tk from tkinter import filedialog as fd root = Tk() root.withdraw() self.file_dir = fd.askopenfilename() self.file_name = os.path.basename(self.file_dir) print(self.file_name) print(self.file_dir) f = open(self.file_dir) self.MyText.text = f.read() f.close() except: print('Файл не выбран') def SaveAsFile(self, instance): try: from tkinter import Tk from tkinter import filedialog as fd root = Tk() root.withdraw() self.file_dir = fd.asksaveasfilename(filetypes=(("CPP files", "*.cpp"), ("All files", "*.*"))) f = open(self.file_dir, 'w') f.write(self.MyText.text) f.close() for name in list: os.system('cp ' + sys.path[0] + name + ' ' + self.file_dir) except: print('Файл не сохранён') def SaveAs(self, instance): if self.file_dir != '': try: f = open(self.file_dir, 'w') f.write(self.MyText.text) f.close() print('Сохранено') except: print('Файл не был сохранён') if self.file_dir == '': self.SaveAsFile(instance) def CompileCPP(self, instance): self.SaveAs(instance) self.path = sys.path[0] print(self.path) os.chdir('/MinGW/bin') os.system('g++ ' + self.file_dir + ' -o ' + self.file_dir[:-4] + '.exe') print('На вывод: g++ ' + self.file_dir + ' -o ' + self.file_dir[:-4] + '.exe') print('Компиляция завершена!') def StartEXE(self, instance): self.CompileCPP(instance) print(self.file_dir[:-4] + '.exe') string = self.file_dir[:-4] + '.exe' os.startfile(string) def Tips(self, instance): print(instance.text) if instance.text == 'Hello World!': self.secscrtext.text = helloworld if instance.text == 'Циклы': self.secscrtext.text = cycles if instance.text == 'Массивы': self.secscrtext.text = array if instance.text == 'Типы данных': self.secscrtext.text = datatypes if instance.text == 'Функции': self.secscrtext.text = functionscpp if instance.text == 'Указатели': self.secscrtext.text = pointers if instance.text == 'Классы': self.secscrtext.text = classes
class MachineWerkz(App): default_atlas = Atlas('data/images/mw64.atlas') game_board, piece, game_engine = None, None, None fall_speed = .9 current_score = StringProperty('machine werkz') latest_msg = StringProperty('press play') level_name = '' level_bkg = StringProperty('') current_song = None music_state = True music_location = 'default' music_playlist = [] music_played = [] fx_bucket = [] __manager = None __knock = 0 def build(self, **kwargs): self.level_name = 'steampunk' self.level_bkg = path.join(getcwd(), 'data/images/steampunk-bkg.png') # default self.settings_cls = SettingsWithSpinner self.bind(on_start=self.init_device) self.music_playlist = [str(_) for _ in LOCAL_DEFAULTS['music']] self.__manager = ScreenManager() self.__manager.add_widget(MenuScreen(name='menu')) self.__manager.add_widget(GameScreen(name='game')) self.__manager.add_widget(SettingsScreen(name='settings')) self.__manager.add_widget(FileBrowserScreen(name='file_box')) self.__manager.add_widget(LevelScreen(name='levels')) shuffle(self.music_playlist) self.play_music() return self.__manager def build_config(self, config): config.setdefaults( 'machinewerkz', { 'fx_folder': path.join(getcwd(), 'data/audio/fx'), 'music_folder': path.join(getcwd(), 'data/audio/music'), 'cols': '10', 'rows': '18', 'square_unit': '50', 'fall_speed': '1.618' }) def build_settings(self, settings): settings.add_json_panel('machinewerkz', self.config, path.join(getcwd(), 'machinewerkz.json')) def on_config_change(self, config, section, key, value): if key == 'fall_speed': self.fall_speed = float(value) config.set(section, key, value) config.write() def init_device(self, *args): self.piece.pause() Window.bind(on_keyboard=self.on_kb) def on_kb(self, window, key1, key2, txt, modifiers): if key1 == 27 or key1 == 1001: self.__knock += 1 if self.__knock > 2: return self.stop() return self.change_screen('menu') def empty_fx_bucket(self): for _ in range(len(self.fx_bucket)): _ = self.fx_bucket.pop(0) _.stop() del _ def audio_callback(self, audio_type, audio_name, extra=None): if len(self.fx_bucket) > 10: self.empty_fx_bucket() if audio_type in ['fx', 'FX']: try: if self.level_name in soundfx.keys(): _ = load_audio(LOCAL_DEFAULTS['fx'][soundfx[ self.level_name][audio_name]]) else: _ = load_audio(LOCAL_DEFAULTS['fx'][audio_name]) _.play() self.fx_bucket.append(_) except KeyError: pass def toggle_music(self): self.music_state = not self.music_state self.play_music() def play_music(self): if not self.music_state: try: self.current_song.stop() except TypeError: pass except AttributeError as e: if 'NoneType' in e: pass raise e return "MUSIC OFF" # music for menus if self.__manager is not None and (self.__manager.current not in ['game']): try: self.current_song = load_audio(LOCAL_DEFAULTS['fx']['intro']) self.current_song.play() return except KeyError: return else: try: s = self.music_playlist.pop() except IndexError as e: self.music_playlist = [str(_) for _ in self.music_played] del self.music_played[:] s = self.music_playlist.pop() self.current_song = load_audio(s) self.music_played.append(str(s)) self.current_song.play() def refresh_display(self): if self.current_song is not None: if self.current_song.state == 'stop': self.play_music() self.piece.cb_draw(cb=self.game_engine.draw_method, acb=self.audio_callback) def modify_state(self, pos, *kwargs): if 11 > pos[0] > 6: self.piece.move(RIGHT) self.refresh_display() self.audio_callback(audio_type='fx', audio_name='move') elif -1 < pos[0] < 4: self.piece.move(LEFT) self.refresh_display() self.audio_callback(audio_type='fx', audio_name='move') elif 3 < pos[0] < 7: self.piece.rotate() self.refresh_display() self.audio_callback(audio_type='fx', audio_name='rotate') else: pass def change_screen(self, name, angle="right"): self.__manager.transition.direction = angle self.latest_msg = " | ".join(self.piece.text_score) last = str(self.__manager.current) try: self.__manager.current = name except Exception as e: self.__manager.current = last if last == 'settings': return True if last != name and name in ['menu', 'game']: self.piece.pause() if self.music_state: if self.current_song: self.current_song.stop() self.play_music() self.__knock = 0 return True def widget_reset(self): self.game_board.reset() self.current_score = 'machine werkz' self.piece.pause() def get_speed(self, s): try: i = ["1.618", "1.2", "0.9", "0.5"].index(self.config.get('machinewerkz', 'fall_speed')) except ValueError: i = 4 return [ 'Default', 'Intermediate', 'Advanced', 'Let me at em', "Custom" ][i] def level_packs(self): # levels = [_ for _ in self.default_atlas.textures.keys() if '2' not in _[-1]] # return tuple(levels) # NOTE: more backgrounds needed, STATIC UNTIL FINISHED. return tuple([u"steampunk", u"80s", u"space", u"metal"]) def get_level(self, t): res = t.text print(res) if len(res) > 0: return str(res) return "Style" def change_speed(self, t): a, b, c, d = (1.618, 1.2, 0.9, 0.5) try: res = { 'Default': ('play whilst otherwise occupied', a), 'Intermediate': ('not so slow', b), 'Advanced': ('just chilling', c), 'Let me atom': ('good luck', d) }[t] self.fall_speed = res[1] self.config.set('machinewerkz', 'fall_speed', res[1]) self.config.write() except KeyError: return "" return "{}".format(res[0]) def on_stop(self): self.empty_fx_bucket() if self.current_song: try: Logger.info('[MachineWerkz] stopping music') self.current_song.stop() except Exception as e: Logger.error('[MachineWerkz?] {}'.format(e)) super(MachineWerkz, self).on_stop() def file_select(self, selection, p): available = [] if len(selection) > 0: Logger.info("Selected : {}".format(selection)) for _ in selection: if _[-4:] in ['.mp3', '.ogg']: available.append(path.join(p, _)) else: for _ in listdir(p): if _[-4:] in ['.mp3', '.ogg']: available.append(path.join(p, _)) if len(available) > 0: try: Logger.info('[MachineWerkz] stopping music') self.current_song.stop() except TypeError as e: Logger.error('[MachineWerkz?] {}'.format(e)) self.music_state = False self.music_playlist = available self.music_played = [LOCAL_DEFAULTS['music']] try: self.toggle_music() except TypeError: pass return True return False def reset_music(self): try: Logger.info('[MachineWerkz] stopping music') self.current_song.stop() sleep(.1) except Exception as e: Logger.error('[MachineWerkz?] {}'.format(e)) self.music_playlist = [str(_) for _ in LOCAL_DEFAULTS['music']] self.music_state = True self.music_played = [] shuffle(self.music_playlist) if self.current_song.state == 'stop': self.toggle_music()