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':
