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'
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
def build(self): register('jeV1sPLXL6cq8EsWAK0Zyoac8b97duQWyXYK7sfE','fl6hQ9dv94IbtA0I7kPzSrawL165HqupSjCFdo3D') # Create the screen manager sm = ScreenManager(transition=FadeTransition()) sm.add_widget(LoginScreen(name='login')) return sm
def build(self): # Create the screen manager sm = ScreenManager() self.current_battle = DeepSpace(name='DeepSpace') sm.add_widget(self.current_battle) 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 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 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): # --- 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
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
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"
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): """ 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): root = ScreenManager() for x in range(1): root.add_widget(CustomScreen(name='%s'%x)) if x ==0: root.add_widget(Screen1()) return root
def build(self): client = game_play.GameClient(host="127.0.0.1", port="5000") root = ScreenManager() root.transition = WipeTransition() root.add_widget(StartScreen(client, name="start")) root.add_widget(GameScreen(client, name="game")) return root
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): 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
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
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): manager = ScreenManager() manager.add_widget(Login(name='login')) manager.add_widget(Connected(name='connected')) return manager
def build(self): root = ScreenManager() #Pantallas principales # #Pantallas sub-Principales root.add_widget(Facultades(name='facultades')) return root
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): my_screenmanager = ScreenManager() screen1 = SelectingDataSet(name='screen1') screen2 = RunPCA(name='screen2') my_screenmanager.add_widget(screen1) my_screenmanager.add_widget(screen2) return my_screenmanager
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
def build(self): Window.size = (320, 480) sm = ScreenManager() sm.add_widget(SplashScreen(name='SplashScreen', sm=sm, switchTo='_2048Game')) sm.add_widget(_2048Game(name='_2048Game')) sm.current = 'SplashScreen' #sm.current = '_2048Game' return sm
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
# icon : 'android' # OneLineAvatarListItem: # text: 'item2' # ImageLeftWidget: # source : 'fb.png' ''' 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 on_start(self): for i in range(20): item = OneLineIconListItem(text=f'item {i} ')
#and set the time_option based on it def set_time_option(self): global time_option for tggle in ToggleButtonBehavior.get_widgets('1'): if tggle.state == "down": if tggle.text == "6-10": time_option = True else: time_option = False #the base class that runs the app class TestApp(App): def build(self): return sm # Create the screen manager and adding the screens sm = ScreenManager() menu = MenuScreen(name='menu') sm.add_widget(menu) soldiers = SoldiersScreen(name='soldiers') sm.add_widget(soldiers) stands = StandsScreen(name='stands') sm.add_widget(stands) table = TableScreen(name='table') sm.add_widget(table) #running the app if __name__ == '__main__': TestApp().run()
def build(self): sh = SessionHeader() sm = ScreenManager() # CREATE SCREENS start_screen = StartScreen(sh, name='start') settings_screen = GeneralSettings(sh, name='GeneralSettings') bci_screen = BCIMenu(sh, name='BCIMenu') acquisition_settings_screen = AcquisitionSettings( sh, name='AcquisitionSettings') cal_screen = CalMenu(sh, name='CalMenu') cal_settings_screen = CalSettings(sh, name='CalSettings') cal_start_screen = CalStart(sh, name='CalStart') ml_screen = MlMenu(sh, name='MlMenu') game_screen = GameMenu(sh, name='GameMenu') game_settings_screen = GameSettings(sh, name='GameSettings') bars_start_screen = BarsStart(sh, name='BarsStart') target_start_screen = TargetStart(sh, name='TargetStart') ardrone_menu_screen = DroneMenu(sh, name='DroneMenu') ardrone_settings_screen = DroneSettings(sh, name='DroneSettings') ardrone_start_screen = DroneStart(sh, name='DroneStart') # ADD SCREENS TO SCREEN MANAGER sm.add_widget(start_screen) sm.add_widget(settings_screen) sm.add_widget(bci_screen) sm.add_widget(acquisition_settings_screen) sm.add_widget(cal_screen) sm.add_widget(cal_settings_screen) sm.add_widget(cal_start_screen) sm.add_widget(ml_screen) sm.add_widget(game_screen) sm.add_widget(game_settings_screen) sm.add_widget(bars_start_screen) sm.add_widget(target_start_screen) sm.add_widget(ardrone_menu_screen) sm.add_widget(ardrone_settings_screen) sm.add_widget(ardrone_start_screen) sm.current = 'start' return sm
def build(self): self.title = '{} v.{}'.format(APP_NAME, APP_VERSION) manager = ScreenManager() manager.add_widget(Login(name='login')) manager.add_widget(Connected(name='connected')) return manager
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()
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()
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
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()
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
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"])
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.'
from screens.registration_screen import RegistrationScreen from screens.settings_screen import SettingsScreen from screens.web_images_menu import WebImagesMenu from screens.images_menu import ImagesMenu from screens.main_menu import MainMenuScreen from kivymd.theming import ThemeManager sm = ScreenManager() login = LoginScreen('Login', 'Main menu', 'registration') registration = RegistrationScreen('registration', 'Login') main_menu_screen = MainMenuScreen('Main menu', 'Images', '', 'Main menu') images_screen = ImagesMenu('Images', 'ApiScreen', 'Main menu', 'Main menu') api_screen = WebImagesMenu('ApiScreen', 'Settings', 'Images', 'Main menu') settings_screen = SettingsScreen('Settings', '', 'ApiScreen', 'Main menu') sm.add_widget(login) sm.add_widget(registration) sm.add_widget(main_menu_screen) sm.add_widget(images_screen) sm.add_widget(api_screen) sm.add_widget(settings_screen) class MainApp(App): def build(self): self.theme_cls = ThemeManager() self.theme_cls.theme_style = 'Dark' return sm
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
class ELiDEApp(App): """Extensible LiSE Development Environment. """ title = 'ELiDE' icon = 'icon.png' engine = ObjectProperty() branch = StringProperty('trunk') tick = NumericProperty(0) character = ObjectProperty() selection = ObjectProperty(None, allownone=True) selected_remote = ObjectProperty() 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 (self.branch, self.tick) = self.engine.time pull_time = trigger(_pull_time) @trigger def _push_time(self, *args): if self.engine.time != (self.branch, self.tick): self.engine.time_travel(self.branch, self.tick, chars=[self.character.name], cb=self.mainscreen._update_from_chardiff) def set_tick(self, t): """Set my tick to the given value, cast to an integer.""" self.tick = int(t) def set_time(self, b, t=None): if t is None: (b, t) = b t = int(t) (self.branch, self.tick) = (b, 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', 'code': 'LiSEcode.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. """ config = self.config Logger.debug( "ELiDEApp: starting with world {}, code {}, path {}".format( config['LiSE']['world'], config['LiSE']['code'], 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 _start_subprocess(self, *args): config = self.config self.procman = EngineProcessManager() enkw = {'logger': Logger} 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'], config['LiSE']['code'], **enkw) self.pull_time() @self.engine.time.connect def pull_time(inst, **kwargs): self.branch = inst.branch self.tick = inst.tick @self.engine.string.language.connect def pull_lang(inst, **kwargs): self.strings.language = kwargs['language'] @self.engine.character.connect def pull_chars(*args): self.chars.names = list(self.engine.character) self.bind(branch=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'), branch=self.branch, tick=self.tick, engine=self.engine) self.bind(selected_remote=self.statcfg.setter('remote'), branch=self.statcfg.setter('branch'), tick=self.statcfg.setter('tick')) self.mainscreen = ELiDE.screen.MainScreen( use_kv=config['ELiDE']['user_kv'] == 'yes', play_speed=int(config['ELiDE']['play_speed']), 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.reremote, character=self.reremote) self.selected_remote = self._get_selected_remote() 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_remote(self): if self.selection is None: return self.character.stat elif hasattr(self.selection, 'remote'): return self.selection.remote 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 reremote(self, *args): self.selected_remote = self._get_selected_remote() 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): self.selection = None def on_pause(self): """Sync the database with the current state of the game.""" self.engine.commit() self.config.write() def on_stop(self, *largs): """Sync the database, wrap up the game, and halt.""" self.procman.shutdown() self.config.write() def on_selection(self, *args): Logger.debug("ELiDEApp: selection {}".format(self.selection)) 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.remote.delete() else: assert isinstance(selection, Pawn) self.selection = None self.mainscreen.boardview.board.rm_pawn(selection.name) selection.remote.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): sm = ScreenManager() sm.add_widget(ConfigScreen()) return sm
# Label: # text: 'Your Tasks:' # color: 0, 0, 0, 1 # size_hint_x: None # width: 200 # font_size: 24 """) '''build the UI''' class EcosystemsUI(App): numRowsColsInJungleGrid = 6 numTreesInJungle = numRowsColsInJungleGrid * numRowsColsInJungleGrid def build(self): return sm ecosystemsPathToSong = 'Music/ecosystems.mp3' sm.add_widget(EcosystemSelectionScene( name='ecosystem_selection')) # adds MainScene to screenmanager sm.add_widget(AmazonScene(name='amazon')) sm.add_widget( DeforestationScene(name='deforestation', pathToSong=ecosystemsPathToSong, fileName='ecosystems')) if __name__ == '__main__': EcosystemsUI().run()
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
def callback(self,adapter,*args): if len(self.adapter.selection) == 0: print("No selected item") else: print(self.adapter.selection[0].text) class LoadDialog(FloatLayout): load = ObjectProperty(None) cancel = ObjectProperty(None) def __init__(self, **kwargs): super(LoadDialog, self).__init__(**kwargs) sc = ScreenManager() sc.add_widget(Watermark(name='Watermark')) class WatermarkApp(App): def build(self): return sc def on_pause(self): return True if __name__ == "__main__": WatermarkApp().run()
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 on_pre_enter(self): recvThread() def recvMsg(self): cont=self.ids.container global data print(data) c=cont.add_widget(OneLineListItem(text=str(data))) sm=ScreenManager() sm.add_widget(LoginPage(name='login')) sm.add_widget(MsgPlatform(name="msgplatform")) class MainApp(MDApp): def build(self): script=Builder.load_string(kv) return script if __name__=='__main__': MainApp().run()
+ str(uid) + '\n' + 'Token: ' + utoken self.ids.welcome_text.text = 'Welcome ' + uname def update_text_login(self): uname = GlobalData._user_model.get_username() uid = GlobalData._user_model.get_id() self.ids.welcome_text.text = 'Welcome ' + uname self.ids.user_info.text = 'Username: '******'\n' + 'ID: '\ + str(uid) def logout(self): GlobalData._user_model = {} scmanager.current = 'login' scmanager = ScreenManager() scmanager.add_widget(LoginScreen(name='login')) scmanager.add_widget(RegisterScreen(name='register')) scmanager.add_widget(MainScreen(name='mainsc')) scmanager.current = 'login' class socialApp(App): def build(self): return scmanager if __name__ == '__main__': socialApp().run()
def build(self): sm=ScreenManager() ms=GuiKivy(name='menu') sm.add_widget(ms) sm.current='menu' return sm
class cTheScreen(EventDispatcher): """ The Main screen class """ def __init__(self, *args, **kwargs): super(cTheScreen, self).__init__(*args, **kwargs) self.bIntransition = False self.iRotateCount = 0 self.oScreenPages = {} self.dPopups = {} self.oCurrentPage = None self.oFonts = cFonts() self.dGestures = {} self.oPopupPage = None self.oRootSM = ScreenManager() self.oScreenPages = cScreenPages() self.oSkin = cSkin() self.oSplashBackground = Screen(name="SPLASH") self.oSplashLogger = None self.oSplashLogger2 = None self.uCurrentEffect = u'' self.uCurrentEffectDirection =u'' self.uCurrentPageName = None self.uLastTouchType = u'' self.uFirstPageName = u'' self.oRootSM.add_widget(self.oSplashBackground) self.InitVars() def InitVars(self): """ (re) Initialisises all vars (also after a definition change) """ InitSystemVars() Globals.oDefinitions.InitVars() # Name of the Current page # List for settings dialog self.aActionTime = None self.bIntransition = False self.dGestures.clear() self.dPopups.clear() self.iLastWidgetPage = 0 Globals.oActions.InitVars() self.oCurrentPage = None self.oFonts.DeInit() self.oGdb = GestureDatabase() self.oPopup = None self.oScreenPages.DeInit() self.uCurrentEffect = u'' self.uCurrentEffectDirection =u'' self.uCurrentPageName = u'' self.uDefaultTransmitterPictureName = u'' self.uDefaultWaitPictureName = u'' self.uDefName = u'' self.uFirstPageName = u'' self.uInterFaceToConfig = u'' self.uScriptToConfig = u'' self.uConfigToConfig = u'' self.uSplashText = u'' if Globals.oTheScreen: Globals.oTheScreen.oSkin.dSkinRedirects.clear() gc.collect() def DeInit(self,**kwargs): """ Deinitialisises the screen """ Globals.oEvents.DeInit() def ShowPage(self,uPageName,*largs): """ Shows a specific page (waiting in case a transition is still in progress) """ if not self.bIntransition: self._ShowPage(uPageName=uPageName) return -2 else: Logger.debug ('Waiting to finish transition') Clock.schedule_once(partial(self.ShowPage,uPageName),0) return -2 def ShowPageGetPageStartActions(self,uPageName='Page_None'): """ Returns the pagestartactions for a specific page """ aActions=Globals.oActions.GetPageStartActionList(uActionName=uPageName, bNoCopy=False) oPage=self.oScreenPages.get(uPageName) if oPage: oPage.Create() return aActions def ShowPageGetPageStopActions(self, uPageName=u''): """ Returns the pagestopactions for a specific page """ if uPageName==u'': if self.oCurrentPage: uPageName=self.oCurrentPage.uPageName return Globals.oActions.GetPageStopActionList(uActionName = uPageName, bNoCopy = False) def _ShowPage(self,uPageName='Page_None'): try: if self.uCurrentPageName==uPageName: return True oPage=self.oScreenPages.get(uPageName) if oPage is None: Logger.error(u'ShowPage: Wrong Pagename given:'+uPageName) self.DumpPages() uPageName = 'Page_None' oPage=self.oScreenPages.get(uPageName) self.oCurrentPage=oPage else: self.oCurrentPage=oPage self.oScreenPages.CreatePage(u'') Var_Increase(uVarName = "PAGESTARTCOUNT_"+oPage.uPageName) if self.oPopupPage: if self.oPopupPage.oScreen in self.oRootSM.current_screen.children: self.oRootSM.current_screen.remove_widget(self.oPopupPage.oScreen) Logger.debug("TheScreen: Showing page: %s, called from %s" % (uPageName,self.uCurrentPageName)) oPage.iESCPressCount = 0 if not oPage.bIsPopUp: self.oRootSM.current = uPageName else: self.oPopupPage=oPage #self.oRoot.add_widget(oPage.oScreen) self.oRootSM.current_screen.add_widget(oPage.oScreen) oPage.uCallingPageName = self.uCurrentPageName self.uCurrentPageName = uPageName if self.uFirstPageName==u'': self.uFirstPageName=uPageName self.oScreenPages.AppendToPageQueue(oPage) oPage.SetTransmitterPicture(self.uDefaultTransmitterPictureName) oPage.SetWaitPicture(uWaitPictureName=self.uDefaultWaitPictureName) return True except Exception as e: uMsg = traceback.format_exc() Logger.debug (uMsg) Logger.debug("Rootsm:"+str(self.oRootSM)) if self.oRootSM is not None: Logger.debug("current_screen:"+str(self.oRootSM.current_screen)) uMsg=LogError(u'TheScreen: ShowPage: Page could not be activated:'+uPageName,e) ShowErrorPopUp(uMessage=uMsg) return False def IsPopup(self,uPageName=None): """ Detects/returns, if a page is a popup page """ uPageNameOrg=uPageName if uPageName is None or uPageName=='': oPage=self.oCurrentPage if oPage is None: return False else: uPageName=ReplaceVars(uPageName) oPage=self.oScreenPages.get(uPageName) if oPage is None: Logger.debug(u'IsPopup: Wrong Pagename given: [%s/%s]' % (uPageName,uPageNameOrg)) return False else: return oPage.bIsPopUp def On_Transition_Complete(self,oTransition): """ Called by the framework, when the transition has been finished, sets the flag, to stop waiting """ self.bIntransition = False def On_Transition_Started(self,oTransition,Percentage): """ Called by the framework, when the transition has been started """ #print 'in Transition',oTransition.is_active,Percentage if Percentage==0: self.bIntransition = True def SetPageEffectDirection(self,uDirection='fade'): """ Sets the Page effect direction (in case , the effect has an direction) """ self.uCurrentEffectDirection=uDirection try: if ToUnicode(type(self.oRootSM.transition)).endswith(u'SlideTransition\'>'): if uDirection!=u'': self.oRootSM.transition.direction=uDirection return True except Exception as e: uMsg=LogError(u'TheScreen: Can not set page effect direction:' + uDirection ,e) ShowErrorPopUp(uMessage=uMsg) return False def SetPageEffect(self,uEffect): """ Sets the page effect for showing a page """ self.uCurrentEffect=uEffect try: if uEffect==u'': return True uType=ToUnicode(type(self.oRootSM.transition)) if uEffect==u'no': self.oRootSM.transition = NoTransition() if uEffect==u'fade': if uType.endswith(u'FadeTransition\'>'): return True self.oRootSM.transition = FadeTransition() elif uEffect==u'slide': if uType.endswith(u'SlideTransition\'>'): return True self.oRootSM.transition = SlideTransition() elif uEffect==u'wipe': if uType.endswith(u'WipeTransition\'>'): return True self.oRootSM.transition = WipeTransition() elif uEffect==u'swap': if uType.endswith(u'SwapTransition\'>'): return True self.oRootSM.transition = SwapTransition() elif uEffect==u'fallout': if uType.endswith(u'FallOutTransition\'>'): return True self.oRootSM.transition = FallOutTransition() elif uEffect==u'risein': if uType.endswith(u'RiseInTransition\'>'): return True self.oRootSM.transition = RiseInTransition() self.oRootSM.transition.bind(on_complete=self.On_Transition_Complete) self.oRootSM.transition.bind(on_progress=self.On_Transition_Started) return True except Exception as e: uMsg=LogError(u'TheScreen: Can not set page effect:' + uEffect,e) ShowErrorPopUp(uMessage=uMsg) return False def AddActionShowPageToQueue(self,uPageName): """ Convinient function to show a page by the scheduler """ self.AddActionToQueue([{'string':'showpage','pagename':uPageName}]) def AddActionToQueue(self,aActions, bNewQueue=False): """ Adds Actions to the scheduler """ aTmpActions=Globals.oEvents.CreateSimpleActionList(aActions) if bNewQueue: Globals.oEvents.ExecuteActionsNewQueue(aActions=aTmpActions,oParentWidget=None) else: Globals.oEvents.ExecuteActions(aActions=aTmpActions,oParentWidget=None) def UpdateSetupWidgets(self): """ Updates all setup / settings widgets """ for uPageName in self.oScreenPages: self.oScreenPages[uPageName].UpdateSetupWidgets() def FindWidgets(self,uPageName,uWidgetName,bIgnoreError=False): """ Find a set widgets with a given name """ aRet=[] if "@" in uWidgetName: uWidgetName,uPageName=uWidgetName.split(u"@") uWidgetNameRep=ReplaceVars(uWidgetName) uPageNameRep=ReplaceVars(uPageName) if uPageNameRep=="": if self.oCurrentPage is not None: uPageNameRep=self.oCurrentPage.uPageName oPages=[] if uPageNameRep!="*": oPages.append(uPageNameRep) else: for uPageNameRep in self.oScreenPages: oPages.append(uPageNameRep) for uPageName in oPages: oPage=self.oScreenPages.get(uPageName) if oPage is None: if not bIgnoreError: uMsg=u'The Screen: Page [%s] for Widget [%s] not found:' % (uPageName,uWidgetNameRep) Logger.error (uMsg) else: if uWidgetNameRep != "*": oWidget = oPage.dWidgets.get(uWidgetNameRep) if oWidget is not None: aRet.append(oWidget) else: if uPageNameRep!="*": if not bIgnoreError: Logger.warning ("Can't find widget [%s] on page [%s]" % (uWidgetNameRep,uPageName)) else: for oWidget in oPage.aWidgets: aRet.append(oWidget) if len(aRet)==0: if not bIgnoreError: uMsg=u'The Screen: Widget not found:'+uWidgetNameRep Logger.error (uMsg) return aRet def FindWidget(self,oScreenPage,uWidgetName,bDoNotCreatePage=False): """ Finds a widget with a given name """ uWidgetNameRep=ReplaceVars(uWidgetName) if oScreenPage is None: oScreenPage=self.oCurrentPage if oScreenPage is None: uMsg=u'The Screen: Page for Widget not found:'+uWidgetNameRep Logger.error (uMsg) return None oWidget = oScreenPage.dWidgets.get(uWidgetNameRep) if not oWidget is None: if not oScreenPage.bIsInit and not bDoNotCreatePage: oScreenPage.Create() return oWidget Logger.warning ("Can't find widget [%s] on current page [%s], looking on all pages" % (uWidgetName,oScreenPage.uPageName)) for oPageName in self.oScreenPages: oPage=self.oScreenPages[oPageName] oWidget = oPage.dWidgets.get(uWidgetNameRep) if not oWidget is None: if not oPage.bIsInit and not bDoNotCreatePage: oPage.Create() return oWidget uMsg=u'The Screen: Widget not found:'+uWidgetNameRep Logger.error (uMsg) return None def on_motion(self, window,etype, motionevent): """ To detect, if we still have a down touch if we missed the touch_up message so we do not want endless repeat """ self.uLastTouchType = etype def DumpPages(self, uFilter=''): """ Dumps the names of all pages to the log file""" Logger.error(u'Available Pages:') for uKey in sorted(self.oScreenPages): if uFilter=="": Logger.error(uKey) else: if uFilter in uKey: Logger.error(uKey)
class MyApp(App): """Aplicación, con el ScreenManager para la administración de todas las pantallas. Atributos: zbarcam: una instancia de ZBarCam que corresponde al widget que muestra la cámara y lee los códigos QR. """ zbarcam = ZBarCam(pos_hint={ "right": 1, "top": 0.9 }, size_hint=(1, 0.5), code_types='qrcode') def build(self): """Función que construye las pantallas de la aplicación. Esta función es llamda al iniciar la aplicación. Crea un ScreenManager y le agrega todas las pantallas, y llama el archivo .kv con el módulo Builder para complementar los atributos de las pantalla definidos en dicho archivo. """ self.title = 'Notas de Laboratorio' Builder.load_file('main.kv') self.sm = ScreenManager() self.sm.add_widget(InitScreen(name="InitScreen")) self.sm.add_widget(LoginProfe(name="LoginProfe")) self.sm.add_widget(IngresaProfe(name="IngresaProfe")) self.sm.add_widget(NuevoProfe(name="NuevoProfe")) self.sm.add_widget(DisplayProfe(name="DisplayProfe")) self.sm.add_widget(VerNotasProfe(name="VerNotasProfe")) self.sm.add_widget(DisplayNotasProfe(name="DisplayNotasProfe")) self.sm.add_widget(VerNotasEstudiante(name="VerNotasEstudiante")) self.sm.add_widget( DisplayNotasEstudiante(name="DisplayNotasEstudiante")) self.sm.add_widget(InputEstudiante(name="InputEstudiante")) self.sm.add_widget(Rubros(name="Rubros")) self.sm.add_widget(CalificarA(name="CalificarA")) self.sm.add_widget(CalificarP(name="CalificarP")) self.sm.add_widget(CalificarQ(name="CalificarQ")) self.sm.add_widget(CalificarC(name="CalificarC")) self.sm.add_widget(CalificarR(name="CalificarR")) self.sm.add_widget(AgregaEstudiante(name="AgregaEstudiante")) return self.sm def refresh(self): """Función encargada de actualizar los datos mostrados en el RecycleView. Utiliza variables y triggers asignados con el módulo Clock para definir intérvalos de actualización por tiempos definidos, llamados por los botones de la aplicación cuando se realiza un cambio en el display. """ refreshP = Clock.schedule_interval( self.sm.get_screen('DisplayNotasProfe').update, 0.1) refreshE = Clock.schedule_interval( self.sm.get_screen('DisplayNotasEstudiante').update, 0.1) trigP = Clock.create_trigger( self.sm.get_screen('DisplayNotasProfe').update, 0.2) trigE = Clock.create_trigger( self.sm.get_screen('DisplayNotasEstudiante').update, 0.2) trigP() trigE() refreshP.cancel() refreshE.cancel() def addCam(self, pantalla): """Función que agrega el widget zbarcam de MyApp a una pantalla. """ self.sm.get_screen(pantalla).add_widget(self.zbarcam) def rmCam(self, pantalla): """Función que elimina el widget zbarcam de MyApp de una pantalla. """ self.sm.get_screen(pantalla).remove_widget(self.zbarcam)
# Wachtwoord en gebruikernaams veld leeg maken als wachtwoord fout is. self.ids["gebruikersnaam"].text = "" self.ids["wachtwoord"].text = "" class MenuScreen(Screen): pass class BovenScreen(Screen): pass class BenedenScreen(Screen): pass class BuitenScreen(Screen): pass sm = ScreenManager() sm.add_widget(LoginScreen(name='Login')) sm.add_widget(MenuScreen(name='Menu')) sm.add_widget(BovenScreen(name='Boven')) sm.add_widget(BenedenScreen(name='Beneden')) sm.add_widget(BuitenScreen(name='Buiten')) EindwerkApp().run()
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
''' 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.' SwitchingScreenApp().run() # Runs SwitchingScreenApp
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') TestApp().run()
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): if dir == 'None':