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