def build(self):
pixel_x = metrics.dp(600)
pixel_y = metrics.dp(680)
Window.size = (pixel_x, pixel_y)
root = ScreenManager()
root.add_widget(OpenDialog(name='open'))
root.add_widget(ModelScreen(name='model'))
root.add_widget(MaterialScreen(name='material'))
root.add_widget(ResultScreen(name='result'))
root.current = 'model'
open_screen = root.get_screen('open')
model_screen = root.get_screen('model')
material_screen = root.get_screen('material')
result_screen = root.get_screen('result')
black_board = model_screen.grid
element_size = black_board.element_size
black_board.yPos = int(round(black_board.height / element_size))
black_board.xPos = int(round(black_board.width / element_size))
black_board.rectangles = np.ones((black_board.xPos, black_board.yPos, 3))
black_board.refresh = Clock.schedule_interval(black_board.update_grid, 0.1)
return root
def build(self):
sm = ScreenManager(transition=NoTransition())
sm.add_widget(EditScreen(name="edit"))
sm.add_widget(ListScreen(name="list"))
sm.get_screen("edit").build()
return sm
def ekle(self):
print(secili_id)
if secili_id == "bos":
note = [self.ids.metin.text] #veritabanına yazacağım yazı
sorgula.execute(
"insert into notlar(note) values(?)",
(note
)) #Sql dilinde, veritabanındaki tabloya satır ekleme komutu
#self.notlari_al() # veritabanına eklenen satırı RecycleView e de eklemek için bu fonksiyonu tekrar çağırıyoruz.
baglanti.commit()
else:
sorgula.execute("update notlar set note = (?) where id = (?)",
[(self.ids.metin.text), (secili_id)])
baglanti.commit()
ScreenManager.get_screen(App.get_running_app().py,
"AnasayfaScreen").notlari_al()
class EMonopolyClientApp(App):
def __init__(self, **kwargs):
super(EMonopolyClientApp, self).__init__(**kwargs)
self.data = dict()
self.gameServerClient = GameServerClient('matdeb', 1234, self)
def on_stop(self):
self.gameServerClient.close()
def build(self):
self.joinServerScreen = JoinServerScreen(name='typeNickname')
self.gameRoomScreen = GameRoomScreen(name='gameRoom')
self.singleRoomScreen = SingleRoomScreen(name='singleRoomScreen')
self.screenManager = ScreenManager()
self.screenManager.add_widget(self.joinServerScreen)
self.screenManager.add_widget(self.gameRoomScreen)
self.screenManager.add_widget(self.singleRoomScreen)
self.screenManager.transition = NoTransition(duration=0)
self.gameServerClient.start()
return self.screenManager
def setData(self, key, value):
self.data[key] = value
def getData(self, key):
return self.data[key]
def changeScreen(self, screenName, args={}):
screen = self.screenManager.get_screen(screenName)
screen.load(args)
self.screenManager.current = screenName
def currentScreen(self):
return self.screenManager.current_screen
class IlanPanosuUyg(App):
def build(self):
self.py = ScreenManager()
Builder.load_file("duyuru.kv")
Builder.load_file("atasozu.kv")
Builder.load_file("resim.kv")
self.py.add_widget(duyuruPenceresi(name='ilan'))
self.py.add_widget(atasozuPenceresi(name='atasozu'))
self.py.add_widget(resimPenceresi(name='resim'))
Clock.schedule_interval(self.pencereDegistir, 2)
return self.py
def pencereDegistir(self, *args):
sonraki = self.py.next()
pcr = self.py.get_screen(sonraki)
if sonraki == 'duyuru':
pcr.ids[
'duyuru_etiketi'].text = ' *Önümüzdeki hafta sonu veli toplantısı yapılacaktır.\n *Yarın gezi kolu Pamukkale\'ye gidecektir.'
elif sonraki == 'atasozu':
pcr.ids['atasozu_etiketi'].text = random.choice(atasozleri)
elif sonraki == 'resim':
res = random.choice(resimler)
pcr.ids['resim'].source = res[0]
pcr.ids['resim_etiketi'].text = res[1]
self.py.current = sonraki
class IlanPanosuUyg(App):
def build(self):
self.py=ScreenManager()
Builder.load_file("duyuru.kv")
Builder.load_file("atasozu.kv")
Builder.load_file("resim.kv")
self.py.add_widget(duyuruPenceresi(name='ilan'))
self.py.add_widget(atasozuPenceresi(name='atasozu'))
self.py.add_widget(resimPenceresi(name='resim'))
Clock.schedule_interval(self.pencereDegistir, 2)
return self.py
def pencereDegistir(self, *args):
sonraki = self.py.next()
pcr = self.py.get_screen(sonraki)
if sonraki == 'duyuru':
pcr.ids['duyuru_etiketi'].text = ' *Önümüzdeki hafta sonu veli toplantısı yapılacaktır.\n *Yarın gezi kolu Pamukkale\'ye gidecektir.'
elif sonraki == 'atasozu':
pcr.ids['atasozu_etiketi'].text = random.choice(atasozleri)
elif sonraki == 'resim':
res = random.choice(resimler)
pcr.ids['resim'].source = res[0]
pcr.ids['resim_etiketi'].text = res[1]
self.py.current = sonraki
class MainApp(App):
show_add_bottle_popup = BooleanProperty(False)
scanned_upc = StringProperty("")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.bottle_adder = BottleAdder()
self.bind(scanned_upc=self.add_new_bottle)
def build(self):
self.sm = ScreenManager()
self.sm.add_widget(StartScreen())
self.sm.add_widget(LiquorScreen())
self.sm.add_widget(MixingScreen())
self.sm.add_widget(DrinkSelectScreen())
def set_canvas(inst, value):
with self.sm.canvas.before:
from kivy.graphics import Color, Rectangle
from scorpion.ui.textures import radial_gradient
Color(1, 1, 1)
Rectangle(texture=radial_gradient(), size=value)
self.sm.bind(size=set_canvas)
return self.sm
def set_screen(self, screen_name):
self.sm.current = screen_name
def get_screen(self, screen = None):
if screen is None:
return self.sm.current_screen
else:
return self.sm.get_screen(screen)
def add_new_bottle(self, inst, value):
if value == "" and inst != None: return
self.bottle_adder.open(value)
self.scanned_upc = ""
class FlickrUploaderApp(App):
main_layout = ObjectProperty()
screen_manager = ObjectProperty()
flickr = ObjectProperty()
flickr_user = StringProperty("")
button_height = NumericProperty(40)
def build(self):
#set flickr data
self.flickr = FlickrUploader(permit='write')
self.flickr_user = self.flickr.get_username()
#set main layout
self.main_layout = FloatLayout()
self.screen_manager = ScreenManager(transition=NoTransition())
self.main_layout.add_widget(self.screen_manager)
self.screen_manager.add_widget(MainScreen(name='mainScreen'))
self.screen_manager.current = 'mainScreen'
mainScreen = self.screen_manager.get_screen('mainScreen')
return self.main_layout
def get_data(self, path):
return self.flickr.get_all_photos_data(path)
def get_albums(self):
return self.flickr.get_flickr_album_titles()
def upload(self, data, album):
self.flickr.upload(data, album)
def on_press(self):
app = App.get_running_app()
ScreenManager.get_screen(App.get_running_app().py,
"NotesScreen").ids.metin.text = self.textLong
global secili_id
secili_id = self.id
print(self.text)
class DataBaseApp(App):
sm = ObjectProperty(None)
def build(self):
global DATABASE_LIST
DATABASE_LIST = load_db()
db_init()
self.title = 'Flash Card App'
self.sm = ScreenManager()
self.sm.current_screen
d = DataBaseScreen(DATABASE_LIST)
self.sm.add_widget(d)
self.sm.current = 'db screen'
a = StackListScreen()
b = WordListScreen()
c = GameScreen()
self.sm.add_widget(a)
self.sm.add_widget(b)
self.sm.add_widget(c)
return self.sm
def on_stop(self):
if(self.sm.current == 'game screen'):
screen_ = self.sm.get_screen('game screen')
screen_.save_changes()
global DATABASE_LIST
save_db(DATABASE_LIST)
delete_temp()
def on_start(self):
pass
class BottleAdder:
def __init__(self):
self.content = ScreenManager()
screens = [UPCGetScreen(),
BrandSelectionScreen(), TypeSelectionScreen(),
LiquorSelectionScreen(), BrandCreationScreen(),
TypeCreationScreen(), LiquorCreationScreen(),
LiquorSKUCreationScreen()]
for screen in screens:
self.content.add_widget(screen)
self.popup = None
global bottle_adder
bottle_adder = self
def open(self, upc = ""):
if self.popup is None:
self.popup = Popup(title="Add Bottle to Inventory!",
content = self.content,
auto_dismiss = False,
size_hint = (0.7, 0.9))
self.popup.open()
self.content.get_screen('upcgetscreen').scanned_upc = upc
def dismiss(self):
self.popup.dismiss()
self.content.parent = None
self.popup = None
def add_new_bottle(self,liquorSKU):
from scorpion.ui.ui_main import app
l_inv = db.add_to_inventory(liquorSKU)
app.get_screen('startscreen').liquor_list.append(l_inv)
self.dismiss()
def find_liquor_matches(self, brand, type_):
matches = db.get_liquors(brand, type_)
if len(matches) == 0:
lcs = self.content.get_screen('liquorcreationscreen')
lcs.back_link = self.content.current
self.content.current = 'liquorcreationscreen'
else:
self.content.get_screen('liquorselectionscreen').items = matches
self.content.current = 'liquorselectionscreen'
class AppConfigTest(GraphicUnitTest):
def set_app(self):
Cache.register('bike')
Cache.register('map')
Cache.remove('bike', 'rm')
Cache.append('bike', 'rm', RM)
self.sm = ScreenManager(transition=WipeTransition())
self.sm.add_widget(MenuScreen(name='menu'))
self.sm.add_widget(GameScreen(name='game'))
self.render(self.sm)
def test_bike_buy_success(self):
self.set_app()
_bike = get_bike_by_title('Default')
menu_screen = ValidObject.menu_screen(self.sm.get_screen('menu'))
self.assertEqual(
menu_screen.get_label_by_text('No bike').text, 'No bike')
self.assertEqual(_bike.title, 'Default')
self.assertTrue(Bike.buy(_bike))
self.assertEqual(_bike.title, Cache.get('bike', 'title'))
self.assertEqual(_bike.power, Cache.get('bike', 'power'))
self.assertEqual(_bike.speed, Cache.get('bike', 'speed'))
self.assertEqual(_bike.acceleration, Cache.get('bike', 'acceleration'))
self.assertEqual(_bike.agility, Cache.get('bike', 'agility'))
self.assertEqual(RM - int(_bike.price), Cache.get('bike', 'rm'))
def test_map_buy_success(self):
self.set_app()
_map = get_map_by_title('Default')
menu_screen = ValidObject.menu_screen(self.sm.get_screen('menu'))
self.assertEqual(
menu_screen.get_label_by_text('No map').text, 'No map')
self.assertEqual(_map.title, 'Default')
self.assertTrue(LevelOne.buy(_map))
self.assertEqual(_map.title, Cache.get('map', 'title'))
self.assertEqual(_map.level, Cache.get('map', 'level'))
self.assertEqual(_map.map, Cache.get('map', 'map'))
self.assertEqual(_map.total_way, Cache.get('map', 'total_way'))
self.assertEqual(RM - int(_map.price), Cache.get('bike', 'rm'))
def build(self):
Window.size = (600, 640)
root = ScreenManager()
root.add_widget(OpenDialog(name='open'))
root.add_widget(ModelScreen(name='model'))
root.current = 'model'
openScreen = root.get_screen('open')
modelScreen = root.get_screen('model')
black_board = modelScreen.grid
element_size = black_board.elementsize
black_board.yPos = int(round(black_board.height / element_size))
black_board.xPos = int(round(black_board.width / element_size))
black_board.rec = np.zeros((black_board.xPos, black_board.yPos))
# black_board.update_grid()
black_board.refresh = Clock.schedule_interval(black_board.update_grid, 0.1)
return root
class AtpokApp(App):
def build(self):
self.icon = "images/icon.png"
# Default window size
Window.size = (1100, 650)
# Minimum window size
Window.minimum_width = 500
Window.minimum_height = 270
# Create screen manager
self.sm = ScreenManager(transition=SlideTransition())
self.sm.add_widget(MenuScreen(name='menu'))
self.sm.add_widget(FavouritesScreen(name='favourites'))
self.sm.add_widget(SettingsScreen(name='settings'))
return self.sm
# Saves settings on app close
def on_stop(self):
self.sm.get_screen('settings').save_settings()
self.sm.get_screen('favourites').save_settings()
class SolarApp(App):
def build(self):
self.manager = ScreenManager() #Kivy Screen Manager object to handle screen transistion
self.manager.add_widget(IdleScreen(name='idle'))
self.manager.add_widget(LockerScreen(name='locker'))
self.manager.add_widget(LockerAccessScreen(name='lockerAccess'))
self.manager.add_widget(ConsumptionScreen(name='consumption'))
self.manager.add_widget(AboutScreen(name='about'))
#self.manager.current = 'lockerAccess'
self.manager.current = 'consumption'
layout = FloatLayout(size=(800,480)) #float layout to handle manager and navbar
layout.add_widget(self.manager)
layout.add_widget(NavBar(id='my_root',name='root'))
Clock.schedule_interval(self.displayTime, 1)
Clock.schedule_interval(self.lockerDurationCount, 60)
return layout
#---clock function---#
#show current time in format 24-hour:min:sec
def displayTime(self, dt):
AM_PM = ''
hour = strftime("%H", localtime())
if int(hour) < 12 or int(hour) == 24:
AM_PM = 'AM'
hour = str(int(hour)%12)
else:
AM_PM = 'PM'
if hour != '12': hour = str(int(hour)%12)
minute = strftime("%M", localtime())
TimeStr = hour + ":" + minute + " " + AM_PM
self.manager.get_screen('locker').ids.clockTime.text = TimeStr
self.manager.get_screen('lockerAccess').ids.clockTime.text = TimeStr
self.manager.get_screen('consumption').ids.clockTime.text = TimeStr
self.manager.get_screen('about').ids.clockTime.text = TimeStr
def lockerDurationCount(self, dt):
for element in lockerSys.lockerList:
if element.state == 1:
element.lockDuration += 60 #add in 60 second everytime this is called
lockerSys.writeData(lockerSys.dataFile)
if element.lockDuration >= 3*60*60: #3hours duration
print("too long")
class TractaApp(App):
def build(self):
self.screen_manager = ScreenManager(transition=FadeTransition())
self.screen_manager.add_widget(MainMenu(name='menu'))
self.screen_manager.add_widget(GameManager(name='game'))
self.screen_manager.add_widget(ScoresScreen(name='scores'))
self.screen_manager.add_widget(AboutScreen(name='about'))
self.screen_manager.add_widget(EndGame(name='endgame'))
self.icon = 'rsc/ship8.ico'
return self.screen_manager
def play_game(self):
self.screen_manager.current = 'game'
self.screen_manager.get_screen('game').start()
def show_about(self):
self.screen_manager.current = 'about'
def show_scores(self):
self.screen_manager.current = 'scores'
self.screen_manager.get_screen('scores').update()
def go_home(self):
self.screen_manager.current = 'menu'
def show_endgame(self, score):
self.screen_manager.current = 'endgame'
self.screen_manager.get_screen('endgame').update(score)
class RestartGameScreenTest(GraphicUnitTest):
def set_app(self):
BaseGameScreenGUITest.setdefaults_config()
Cache.register(CACHE_NAME, limit=1000)
self.manager = ScreenManager(transition=WipeTransition())
self.manager.add_widget(StartScreen(name='start'))
self.manager.add_widget(GameScreen(name='game'))
self.render(self.manager)
screen = ValidObject.screen(self.manager.get_screen('game'))
self.road = screen.ids['road']
self.bike = screen.ids['bike']
self.road.bike = self.bike
self.bike.speed = 0
def test_restart_game_screen(self):
self.set_app()
self.road.level = LevelOne(self.road, self.bike, TESTMAP)
self.road.level.map = TESTMAP
self.road.init_app_config()
self.bike.init_app_config()
# thirty position
self.road.distance_traveled = 4200
self.road.set_distance_traveled()
road_names = [r.__class__.__name__ for r in self.road.children[:]]
thirty_map_names = [t['name'] for t in TESTMAP[3:4]]
self.assertEqual(road_names[0], thirty_map_names[0])
screen = self.manager.get_screen('start')
screen.restart_game()
self.assertEqual(self.road.distance_traveled, 0)
# start first position
start_map_names = [t['name'] for t in TESTMAP[0:2]]
self.assertEqual(len(self.road.children), len(start_map_names))
class WikikircAndroidApp(App):
"""Construction de l'application. Execute par __main__"""
def build(self):
"""Execute en premier apres run()"""
# Création des écrans
self.sm = ScreenManager()
self.sm.add_widget(MainScreen(name="Main"))
return self.sm
def build_config(self, config):
"""Si le fichier *.ini n'existe pas,
il est créé avec ces valeurs par défaut.
Si il manque seulement des lignes, il ne fait rien !
"""
config.setdefaults(
'kivy', {
'log_level': 'debug',
'log_name': 'multipong_%y-%m-%d_%_.txt',
'log_dir': '/sdcard',
'log_enable': '1'
})
config.setdefaults('postproc', {
'double_tap_time': 250,
'double_tap_distance': 20
})
def go_mainscreen(self):
"""Retour au menu principal depuis les autres ecrans."""
#if touch.is_double_tap:
self.sm.current = ("Main")
def do_quit(self):
print("Je quitte proprement")
# Stop propre de Clock
menu = self.sm.get_screen("Main")
menu.event.cancel()
# Kivy
WikikircAndroidApp.get_running_app().stop()
# Extinction de tout
_exit(0)
def build(self):
sm = ScreenManager()
sm.transition = NoTransition()
sm.add_widget(GameScreen(name='game'))
sm.add_widget(MenuScreen(name='menu'))
sm.add_widget(SettingsScreen(name='settings'))
sm.current = 'game'
self.game = sm.current_screen.ids['brickanoid_game']
self.game.menu_screen = sm.get_screen('menu')
self.game.screen_manager = sm
self.game.start()
# sm.current = 'menu'
Clock.schedule_interval(self.game.update, 1.0/60.0)
return sm
def build(self):
self._cam = Camera(
(Config.getint('graphics',
'width'), Config.getint('graphics', 'height')))
self._control = ControlPanel()
sm = ScreenManager(transition=NoTransition())
sm.add_widget(DummyScreen(name='dummy'))
sm.add_widget(SplashScreen(name='splash'))
sm.add_widget(CalibrationScreen(self._cam, name='calibration'))
sm.add_widget(PredictionScreen(self._cam, name='prediction'))
sm.current = 'splash'
Clock.schedule_interval(self.on_loop, 0.001)
self._control.add_mode_sw_listener(
sm.get_screen('prediction').changed_disp_mode)
return sm
class JazzElementsApp(App):
def __init__(self):
super().__init__()
def build(self):
self.bgdColor = (0.282, 0.31, 0.34, 1)
Window.clearcolor = self.bgdColor
self.title = 'Jazz Elements'
self.root = ScreenManager()
self.root.add_widget(ScrMain(name='Main'))
self.scrMain = self.root.get_screen('Main')
self.wdgPrg = self.scrMain.ids['progression']
bar = []
bar.append(self.wdgPrg.addMeasure())
bar[-1].addChord('E', '', 'm7', 1)
bar[-1].addChord('C', '', 'm7', 1)
bar[-1].addChord('%', '', '', 1)
bar[-1].addChord('%', '', '', 1)
self.prg = Progression('Misty')
return self.root
class AndroidServerApp(App):
def build(self):
"""Execute en premier apres run()"""
# Creation des ecrans
self.screen_manager = ScreenManager()
for i in range(len(SCREENS)):
self.screen_manager.add_widget(SCREENS[i][0](name=SCREENS[i][1]))
return self.screen_manager
def on_start(self):
"""Execute apres build()"""
## Receive
tcp_port = int(self.config.get('network', 'tcp_port'))
reactor.listenTCP(tcp_port, MyTcpServerFactory())
## Send: je reçois aussi ce que j'envoie
multi_port = int(self.config.get('network', 'multi_port'))
reactor.listenMulticast(multi_port,
MyMulticastSender(self.config),
listenMultiple=True)
def build_config(self, config):
"""Si le fichier *.ini n'existe pas,
il est cree avec ces valeurs par defaut.
Si il manque seulement des lignes, il ne fait rien !
"""
config.setdefaults(
'network', {
'multi_ip': '224.0.0.11',
'multi_port': '18888',
'tcp_port': '8000',
'freq': '1'
})
config.setdefaults(
'kivy', {
'log_level': 'debug',
'log_name': 'androidserver_%y-%m-%d_%_.txt',
'log_dir': '/toto',
'log_enable': '1'
})
config.setdefaults('postproc', {
'double_tap_time': 250,
'double_tap_distance': 20
})
def build_settings(self, settings):
"""Construit l'interface de l'ecran Options,
pour le serveur seul, Kivy est par defaut,
appele par app.open_settings() dans .kv
"""
data = """[{"type": "title", "title":"Reseau"},
{ "type": "numeric",
"title": "Frequence",
"desc": "Frequence entre 1 et 60 Hz",
"section": "network",
"key": "freq"},
{"type": "title", "title":"Reseau"},
{ "type": "string",
"title": "IP Multicast",
"desc": "IP Multicast",
"section": "network",
"key": "multi_ip"},
{"type": "title", "title":"Reseau"},
{ "type": "numeric",
"title": "Port Multicast",
"desc": "Port Multicast",
"section": "network",
"key": "multi_port"},
{"type": "title", "title":"Reseau"},
{ "type": "numeric",
"title": "TCP Port",
"desc": "TCP Port",
"section": "network",
"key": "tcp_port"}
]
"""
# self.config est le config de build_config
settings.add_json_panel('AndroidServer', self.config, data=data)
def on_config_change(self, config, section, key, value):
"""Si modification des options, fonction appelee automatiquement
"""
freq = int(self.config.get('network', 'freq'))
menu = self.screen_manager.get_screen("Main")
if config is self.config:
token = (section, key)
# If frequency change
if token == ('network', 'freq'):
# TODO recalcul tempo
print("Nouvelle frequence", freq)
def go_mainscreen(self):
"""Retour au menu principal depuis les autres ecrans."""
self.screen_manager.current = ("Main")
def do_quit(self):
print("Je quitte proprement")
# Kivy
AndroidServerApp.get_running_app().stop()
# Extinction de tout
_exit(0)
def clientConnectionLost(self, conn, reason):
self.app.handle_message("connection lost")
def clientConnectionFailed(self, conn, reason):
self.app.handle_message("connection failed")
sm.get_screen('intro').info = "Server not found!!"
if __name__ == '__main__':
#Parsing line flags
# (to pass arguments to app use python main.py -- -C
# inline flag overrides ini file)
arguments = sys.argv
if "-C" in arguments:
GAMEMODE = "Client"
elif "-S" in arguments:
GAMEMODE = "Server"
# Create the screen manager
sm = ScreenManager()
sm.add_widget(IntroScreen(name='intro'))
sm.add_widget(RulesScreen(name='rules'))
sm.add_widget(SettingsScreen(name='settings'))
sm.add_widget(PinnacolaBackground(name='pinnacolabackground'))
sm.add_widget(Player2Screen(name='player2'))
sm.add_widget(Player3Screen(name='player3'))
sm.add_widget(Player4Screen(name='player4'))
# put some info about gamemode on intro screen
sm.get_screen('intro').info = " %s mode: connecting" %GAMEMODE
#run application
PinnacolaApp().run()
class PTimeApp(App):
def build(self):
self.screens = ScreenManager(transition=SlideTransition())
self.screens.app = self
self.screens.add_widget(MainScreen(name='main'))
self.screens.add_widget(ProjectScreen(name='project'))
self.screens.add_widget(CategoryScreen(name='category'))
self.screens.add_widget(TaskScreen(name='task'))
self.screens.current = 'main'
backend = get_backend(config)
self.utils = Utils(backend)
project = self.utils.get_default_project()
self.set_project(project)
categories = self.screens.get_screen('project')
categories.grid.bind(minimum_height=categories.grid.setter('height'))
return self.screens
def set_project(self, project):
if project is None:
return
self.project = project
self.screens.get_screen('main').project = self.project.name
self.screens.get_screen('project').project = self.project.name
self.screens.get_screen('category').project = self.project.name
self.screens.get_screen('task').project = self.project.name
self.update_categories(project)
def update_categories(self, project):
grid = self.screens.get_screen('project').grid
grid.clear_widgets()
for category in self.utils.get_project_categories(project):
lbl = Button(text=category.name, size_hint_y=None)
lbl.height = dp(44)
lbl.bind(on_release=lambda btn, category=category: self.select_category(category))
grid.add_widget(lbl)
def select_category(self, category):
self.category = category
self.screens.get_screen('category').category = self.category.name
self.screens.get_screen('task').category = self.category.name
self.update_tasks(self.project, category)
self.screens.transition.direction='left'
self.screens.current='category'
def update_tasks(self, project, category):
grid = self.screens.get_screen('category').grid
grid.clear_widgets()
for task in self.utils.get_project_tasks(project, category):
lbl = Button(text=task.name, size_hint_y=None)
lbl.height = dp(44)
lbl.bind(on_release=lambda btn, task=task: self.select_task(task))
grid.add_widget(lbl)
def select_task(self, task):
self.task = task
self.screens.get_screen('task').task = self.task.name
self.screens.transition.direction='left'
self.screens.current='task'
class Controller(EventDispatcher):
"""
Controls the playing of audio and coordinates the updating of the playlist
and screen displays
"""
volume = NumericProperty(1.0)
advance = True
# This flag indicates whether to advance to the next track
# once the currently playing one had ended
sm = None # THe ScreenManager
pos = 0
def __init__(self, **kwargs):
""" Initialize the screens and the screen manager """
self._store = JsonStore(
join(self._get_settings_folder(), "zenplayer.json"))
self.playlist = PlayList(self._store)
self.sm = ScreenManager()
self.playing = PlayingScreen(self, name="main")
self.sm.add_widget(self.playing)
self.sm.current = "main"
if platform not in ['ios', 'android']:
self.kb_listener = ZenKeyboardListener(self.on_key_down,
self.playing)
Sound.add_state_callback(self.playing.on_sound_state)
Sound.add_state_callback(self._on_sound_state)
super(Controller, self).__init__(**kwargs)
if self._store.exists('state'):
state = self._store.get("state")
if "volume" in state.keys():
self.volume = state["volume"]
@staticmethod
def _get_settings_folder():
""" Return the folder when the setting file is stored. """
path = expanduser("~/.zencode")
if not exists(path):
mkdir(path)
return path
def _on_sound_state(self, state):
""" The sound state has changed. If the track played to the end,
move to the next track."""
if state == "finished" and self.advance:
self.play_next()
def get_current_art(self):
return self.playlist.get_current_art()
def get_current_info(self):
return self.playlist.get_current_info()
def get_current_file(self):
return self.playlist.get_current_file()
@staticmethod
def get_pos_length():
return Sound.get_pos_length()
def on_key_down(self, keyboard, keycode, text, modifiers):
""" React to the keypress event """
key_name = keycode[1]
if key_name == "up" or text == "+":
self.volume += 0.025
elif key_name == "down" or text == "-":
self.volume -= 0.025
elif key_name == "x":
self.play_pause()
elif key_name == "z":
self.play_previous()
elif key_name == "v":
self.stop()
elif key_name == "b":
self.play_next()
elif key_name == "a":
self.show_filebrowser()
elif key_name == "p":
self.show_playlist()
elif key_name == "s":
self.show_main()
return True
def on_volume(self, widget, value):
""" Set the volume of the currently playing sound """
if 0.0 > value:
self.volume = 0.0
elif value > 1.0:
self.volume = 1.0
else:
Sound.set_volume(value)
self.playing.volume_slider.value = value
def play_index(self, index):
"""
Play the track with the specified playlist index
"""
Sound.stop()
self.playlist.current = index
self.play_pause()
def play_pause(self):
""" Play or pause the currently playing track """
self.advance = True
if Sound.state == "playing":
self.pos, x = Sound.get_pos_length()
Sound.stop()
else:
audio_file = self.get_current_file()
if audio_file:
Sound.play(audio_file, self.volume)
if self.pos > 0:
def set_pos(dt):
Sound.seek(self.pos)
self.pos = 0
Clock.schedule_once(set_pos, 0.1)
def play_next(self):
""" Play the next track in the playlist. """
Sound.stop()
self.playlist.move_next()
self.play_pause()
def play_previous(self):
""" Play the previous track in the playlist. """
Sound.stop()
self.playlist.move_previous()
self.play_pause()
@staticmethod
def set_position(value):
""" Set the playing position to the specified value. """
Sound.set_position(value)
def save(self):
""" Save the state of the the playlist and volume. """
self.playlist.save(self._store)
self._store.put("state", volume=self.volume)
if "filebrowser" in self.sm.screen_names:
self.sm.get_screen("filebrowser").save(self._store)
def show_filebrowser(self):
""" Switch to the file browser screen """
if "filebrowser" not in self.sm.screen_names:
self.sm.add_widget(
ZenFileBrowser(self,
self.playlist,
self._store,
name="filebrowser"))
self.sm.current = "filebrowser"
def show_playlist(self):
""" Switch to the playlist screen """
if "playlist" not in self.sm.screen_names:
self.sm.add_widget(
PlayListScreen(self.sm, self, self.playlist, name="playlist"))
self.sm.current = "playlist"
def show_main(self):
""" Switch to the main playing screen"""
self.sm.current = "main"
def stop(self):
""" Stop any playing audio """
self.advance = False
Sound.stop()
class TetriNET(App):
connection = None
def __init__(self, **kwargs): # inicializace
super(TetriNET, self).__init__(**kwargs)
self.id = False
self.team = ''
self.nickname = ''
self.players = {1:list(), 2:list(), 3:list(), 4:list()}
self.tetrifast = False
self.serverIP = None
self.version = "1.14"
self.transform = [5,4,3,2,1,0]
self.serverConf = None
self.paused = False
self.linesCleared = 0
self.lvl = 0
self.connLost = 0
self.L = None
self.insertStrings = []
self.disconnect = False
self.addBookmark = False
def on_pause(self, *args): # režim pozastavení pro OS Android
return True
# Import jazyků do proměnných (většinou widgetů)
def doStrInsert(self):
self.L = Strings(self.Cfg[0])
self.nickname = self.Cfg[1]
self.team = self.Cfg[2]
for string in self.insertStrings:
try:
replace = eval("self.L.{0}".format(string[1]))
if string[1] != "STR_CONNECTPOPUP":
if string[1] in ("STR_PAUSE", "STR_START", "STR_STOP"):
string[0].text = "[color=#333333]{0}[/color]".format(replace)
else:
string[0].text = replace
else:
string[0].title = replace
except IndexError:
strings = []
for y in dir(string[0]):
if y.startswith("STR_"):
strings.append(y)
for i in strings:
exec("string[0].{0} = self.L.{0}".format(i))
def build(self): # voláno automaticky při spuštění
if self.onAndroid():
self.bind(on_start = self.post_build_init)
root = self.setup_gui()
self.Cfg = self.getConfig()
if (self.Cfg != False) and (len(self.Cfg) == 5):
print self.Cfg
self.doStrInsert()
self.nickname = self.Cfg[1]
self.team = self.Cfg[2]
self.sm.current = self.sm.next()
connectScr = self.sm.get_screen('ConnectScreen')
if len(self.Cfg[3]) == 3:
connectScr.server = [y for y in self.Cfg[3]]
print self.Cfg[3]
connectScr.team = self.team
connectScr.nickname = self.nickname
else:
print LANGUAGES.keys()
print self.Cfg
return root
def setup_gui(self): # vytváří grafické rozhraní
self.sm = ScreenManager(transition=SlideTransition(direction="left"))
self.gameScreen = Screen(name='GameScreen')
self.layout = FloatLayoutBG(size_hint=(1,1))
self.sOverlay = FloatLayout(size_hint=(1,1))
self.field = GameMatrix(self, cols=12, rows=22, size_hint=(0.75, 0.83), pos_hint={'center_x':0.5, 'center_y':0.5}, master=self.layout, spacing=1)
self.id_label = Label(font_name='font/Roboto-Thin.ttf', text=u'', pos_hint={'top':1, 'right':0.125}, size_hint=(0.125,0.085), font_size='48dp')
self.overlay = Overlay(self, size_hint=(.1,1), pos_hint={"right":1})
self.dock = Dock(self, size_hint=(0.75,0.0845), pos_hint={'center_x':0.5}, opacity=1)
self.layout.add_widget(self.field, index=0)
self.layout.add_widget(self.id_label, index=0)
self.nicknameLabel = Label(font_name='font/Roboto-Regular.ttf', text=self.nickname, pos_hint={'top':1, 'center_x':0.5}, font_size='26dp', size_hint=(0.75,0.085))
self.nextPiece = NextPiece()
self.layout.add_widget(self.nextPiece)
self.layout.add_widget(self.nicknameLabel, index=0)
self.layout.add_widget(self.dock, index=0)
self.layout.add_widget(self.overlay)
self.layout.add_widget(self.sOverlay)
self.layout.add_widget(GestureListener(root=self, pos_hint={'x': 0}))
self.chat = Notification()
self.chat.unread.opacity = 0
self.layout.add_widget(self.chat)
self.gameScreen.add_widget(self.layout)
self.sm.add_widget(LanguageScreen(name='LanguageScreen', root=self))
self.sm.add_widget(MainMenuScreen(name='MainMenuScreen', root=self))
self.sm.add_widget(ConnectScreen(name='ConnectScreen', root=self))
self.sm.add_widget(self.gameScreen)
self.sm.add_widget(PartylineScreen(name="PartylineScreen", root=self))
self.sm.add_widget(StatsScreen(name="StatsScreen", root=self))
self.sm.add_widget(SettingsScreen(name="SettingsScreen", root=self))
self.sm.add_widget(BookmarksScreen(name="BookmarksScreen", root=self))
self.sm.add_widget(TutorialMove(root=self, name="TutorialMove", directory="moving", frames=5))
self.sm.add_widget(TutorialDrop(root=self, name="TutorialDrop", directory="drop", frames=3))
self.sm.add_widget(TutorialSpecial(root=self, name="TutorialSpecial", directory="sendspecial", frames=4))
self.sm.add_widget(TutorialNavigate(root=self, name="TutorialNavigate", directory="navigation", frames=7))
self.sm.add_widget(TutorialPlayers(root=self, name="TutorialPlayers", directory="players", frames=4))
return self.sm
def post_build_init(self, instance): # voláno po spuštění programu, namapuje systémové klávesy Androidu
android.map_key(android.KEYCODE_MENU, 1000)
android.map_key(android.KEYCODE_BACK, 1001)
android.map_key(android.KEYCODE_HOME, 1002)
android.map_key(android.KEYCODE_SEARCH, 1003)
android.map_key(android.KEYCODE_APP_SWITCH, 1004)
win = self._app_window
win.bind(on_keyboard=self._key_handler)
def _key_handler(self, instance, KEY, *args): # Reakce na stisk systémové klávesy OS Android
print "Key: {0}".format(KEY)
if KEY == 1001:
if self.sm.current not in ('MainMenuScreen', 'GameScreen'):
if self.sm.current == "SettingsScreen":
self.sm.get_screen("SettingsScreen").dropdown.dismiss()
self.sm.current_screen.prev()
else:
if self.sm.current == 'MainMenuScreen':
text = self.L.STR_POPUP_EXIT
title = self.L.STR_POPUP_EXIT_TITLE
yes_callback = self.popupStop
else:
text = self.L.STR_POPUP_DISCONNECT
title = self.L.STR_POPUP_DISCONNECT_TITLE
yes_callback = self.popupDisconnect
content = BoxLayout(orientation='vertical')
content.add_widget(Label(text=text, font_name='font/Roboto-Regular.ttf', font_size='14dp'))
buttons = GridLayout(cols=2, rows=1, spacing=10, size_hint=(1, .3))
yes = Button(text=self.L.STR_YES)
yes.bind(on_press=yes_callback)
no = Button(text=self.L.STR_NO)
buttons.add_widget(yes)
buttons.add_widget(no)
content.add_widget(buttons)
self.popupExit = Popup(title=title, size_hint=(.7,.3), content=content, auto_dismiss=False)
no.bind(on_press=self.popupExit.dismiss)
self.popupExit.open()
elif KEY == 1002:
self.dispatch('on_pause')
elif KEY == 1004:
self.dispatch('on_pause')
def popupDisconnect(self, instance):
# Odpojení ze serveru z vyskakovacího okna (po stisku systémové klávesy zpět v herní obrazovce)
# Pouze pro OS Android
self.popupExit.dismiss(instance)
self.print_message("endgame\xff")
self.startgame(instance)
Clock.unschedule(self.heartbeat)
self.sm.get_screen("StatsScreen").stats.clear_widgets()
self.sm.get_screen("PartylineScreen").SLayout.clear_widgets()
self.disconnect = True
self.connection.loseConnection()
self.connection = None
self.id = False
self.field.startgame = False
self.sm.transition = SlideTransition(direction="right")
self.sm.current = 'ConnectScreen'
def popupStop(self, instance):
# Ukončení aplikace přes vyskakovací okno (po stisku systémové klávesy zpět v hlavním menu)
# Pouze pro OS Android
self.popupExit.dismiss(instance)
self.stop()
def connect_to_server(self): # Připojení k serveru
self.disconnect = False
reactor.connectTCP(self.server, 31457, EchoFactory(self))
def on_connection(self, connection): # Voláno při navázání spojení, přihlašování TetriNET
self.print_message(self.L.STR_CONNECTION_SUCCESS)
self.connection = connection
self.serverIP = self.connection.getPeer().host
self.connection.write(self.loginEncode()+chr(255))
Clock.schedule_interval(self.heartbeat, 10)
def send_message(self, msg): # Odeslání zprávy na server
if self.connection:
self.connection.write(str(msg)+chr(255))
def print_message(self, msg):
# Tisk serverové zprávy do konzole a zpracování
if self.id == False:
if self.tetrifast:
numRegex = "\\)\\#\\)\\(\\!\\@\\(\\*3\\ \d"
else:
numRegex = "playernum (\d)\xff"
f = findall(numRegex, msg)
if len(f) == 1:
if self.tetrifast:
self.id = int(f[0][-1])
else:
self.id = int(f[0])
self.players[self.id] = [self.nickname, None]
self.id_label.text = str(self.id)
self.nicknameLabel.text = self.nickname
Clock.schedule_once(self.team_select, 0.5)
if self.tetrifast == False:
newgameRegex = "newgame (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*)\xff"
newgameRegex113 = "newgame (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*)\xff"
else:
newgameRegex = "\\*\\*\\*\\*\\*\\*\\* (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*)\xff"
newgameRegex113 = "\\*\\*\\*\\*\\*\\*\\* (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*) (.*)\xff"
if self.id != False:
newgame = findall(newgameRegex, msg)
print newgame
new = False
if len(newgame)==1:
self.serverConf = ServerConf._make(newgame[0][:-1]+(int(newgame[0][-1], 16), ))
print newgame[0][-1]
new = True
print "mam seed"
else:
newgame113 = findall(newgameRegex113, msg)
if len(newgame113) == 1:
self.serverConf = ServerConf._make(newgame113[0]+(randint(0,0xFFFFFF),))
new = True
print "nemam seed"
if new:
self.field.seed = self.serverConf.seed
print self.serverConf
self.btnStart.text = "[color=#333333]{0}[/color]".format(self.L.STR_STOP)
self.btnStart.bind(on_press=self.startgame)
self.field.spectate = False
self.field._build()
self.lvl = int(self.serverConf.startLvl)
for p in range(6):
self.overlay.children[0].children[p].matrix.clear_widgets()
playerjoin = findall("playerjoin (.*?) (.*?)\xff", msg)
if len(playerjoin)>=1:
for player in playerjoin:
pid = int(player[0])
name = player[1]
print pid, name
self.players[pid] = [name, None]
print self.players
print (pid, name)
child = self.transform[pid-1]
insert = self.overlay.children[0].children[child].children[0]
insert.label.text = u"[font=font/Roboto-Bold.ttf]{0}[/font] {1}".format(pid, name)
insert.label.font_size = insert.size[1]-9
print insert.size
insert.label.text_size = (self.layout.size[1]*.13, None)
self.overlay.children[0].children[child].opacity = 1
stats = findall(r"(t|p)(.*?);(\d+)", msg)
if len(stats) >= 1:
self.sm.get_screen("StatsScreen").stats.clear_widgets()
for row in stats:
add = BoxLayout(orientation='horizontal')
for cell in row:
trim = ""
for i in [y for y in cell if ord(y) in range(0,128)]:
trim += i
if trim not in ('t', 'p'):
add.add_widget(Label(font_name='font/Roboto-Regular.ttf', text=trim))
else:
if trim == 'p':
source = 'crop/icons/player.png'
elif trim == 't':
source = 'crop/icons/team.png'
add.add_widget(Image(source=source))
self.sm.get_screen("StatsScreen").stats.add_widget(add)
if self.field.startgame or self.field.spectate:
field = findall("f (.*?) (.*?)\xff", msg)
if len(field) == 1:
pid = int(field[0][0])
print field, type(field)
print self.players
print pid
self.players[pid][1] = field[0][1]
print self.players
matrix = field[0][1]
if len(matrix) < 264:
color = None
child = self.transform[pid-1]
coords = ""
for i in range(len(matrix)):
if matrix[i] in self.field.tnetColors:
color = matrix[i]
else:
if len(coords) == 0:
coords += matrix[i]
elif len(coords) == 1:
coords += matrix[i]
else:
coords = matrix[i]
if len(coords) == 2:
x = COORDS_X.index(coords[0])
y = COORDS_Y.index(coords[1])
box = self.overlay.children[0].children[child].matrix.coords[y][x]
if color == "!":
if type(box) != type(None):
self.overlay.children[0].children[child].matrix.drop((x,y))
self.overlay.children[0].children[child].matrix.coords[y][x] = None
elif color in SPECIALS_F:
if type(box) == type(None):
self.overlay.children[0].children[child].matrix.mark((x,y), [.1372,.1372,.1372,1], SPECIALS[SPECIALS_F.index(color)])
else:
box.texture = False
box.colored = [.1372,.1372,.1372,1]
box.special(SPECIALS[SPECIALS_F.index(color)], True)
else:
if type(box) == type(None):
self.overlay.children[0].children[child].matrix.mark((x,y), COLORS[color])
else:
box.texture = False
box.colored = COLORS[color]
coords = ""
if self.field.startgame:
specUsed = findall("sb (.*?) (.*?) (.*?)\xff", msg)
if len(specUsed) >= 1:
for sb in specUsed:
print sb
targetnum = int(sb[0])
sendernum = int(sb[2])
stype = sb[1]
if targetnum == self.id:
if stype == 'a':
self.field.addLine()
if stype == 'c':
self.field.clearLine()
if stype == 'n':
self.field.nuke()
if stype == 'r':
self.field.randomClear()
if stype == 's':
if sendernum != targetnum:
child = self.transform[sendernum-1]
self.field.switchField(child)
if stype == 'b':
self.field.clearSpecials()
if stype == 'g':
self.field.gravity()
if stype == 'q':
self.field.quake()
if stype == 'o':
self.field.blockBomb()
else:
if stype == 's':
if sendernum != targetnum:
child = self.transform[targetnum-1]
self.field.switchField(child)
if len(stype) == 1:
print self.L.STR_SPECIALSENT.format(self.players[sendernum][0], eval("self.L.STR_BLOCK_{0}".format(stype.upper())), self.players[targetnum][0])
else:
if (targetnum == 0) and (sendernum != self.id):
for i in range(int(stype[2:])):
self.field.addLine()
pause = findall("pause (.*?)\xff", msg)
if len(pause) >= 1:
if pause[0][0] == '1':
Clock.unschedule(self.field.fall)
self.paused = True
else:
Clock.schedule_interval(self.field.fall, 1)
self.paused = False
endgame = findall("endgame\xff", msg)
if len(endgame) == 1:
Clock.unschedule(self.field.fall)
self.field.startgame = False
self.field.spectate = False
self.btnStart.text = "[color=#333333]{0}[/color]".format(self.L.STR_START)
for y in range(22):
for x in range(12):
self.field.drop((x,y))
for p in range(6):
if type(self.overlay.children[0].children[p].matrix.coords[y][x]) != type(None):
self.overlay.children[0].children[p].matrix.drop((x,y))
self.overlay.children[0].children[p].matrix.coords[y][x] = None
self.field.colored = set()
self.field.specials = set()
self.field.fUpdate = 12*22*"0"
self.dock.layout.clear_widgets()
Animation(opacity=0).start(self.nextPiece)
playerleave = findall("playerleave (.*?)\xff", msg)
if len(playerleave) >= 1:
for player in playerleave:
print playerleave
pid = self.transform[int(player)-1]
self.overlay.children[0].children[pid].opacity = 0
self.players[int(player)] = []
if len(self.players) == 1:
self.print_message("endgame\xff")
playerlost = findall("playerlost (.*?)\xff", msg)
if len(playerlost) >= 1:
for player in playerlost:
if int(player) == self.id:
self.field.spectate = True
self.dock.layout.clear_widgets()
Animation(opacity=0).start(self.nextPiece)
playerwon = findall("playerwon (.*?)\xff", msg)
if len(playerwon) >= 1:
self.print_message('endgame\xff')
ingame = findall("ingame\xff", msg)
if len(ingame) == 1:
self.field.spectate = True
pline = findall("pline (.*?) (.*?)\xff", msg)
if len(pline) >= 1:
print pline
for msg in pline:
pid = int(msg[0])
if pid == 0:
formStr = "[font=font/Roboto-Bold.ttf][color=ff0000]<SERVER>[/color][/font] {0}"
else:
formStr = "[font=font/Roboto-Bold.ttf]<{0}>[/font] {{0}}".format(self.players[pid][0])
try:
i = int(self.chat.text)
except:
i = 0
self.chat.text = str(i+1)
self.chat.unread.opacity = 1
scr = self.sm.get_screen('PartylineScreen')
scr.SLayout.add_widget(Label(font_name='font/Roboto-Regular.ttf', text_size=(self.layout.width*.75, None), markup=True, text=formStr.format(msg[1]), size_hint=(None,None)))
scr.scroll.scroll_y = 0
def loginEncode(self):
# Algoritmus přihlášení k TetriNET serveru (zašifrování zprávy)
if self.tetrifast == True:
tetris = "tetrifaster"
else:
tetris = "tetrisstart"
msg = "{0} {1} {2}".format(tetris, self.nickname, self.version)
h = [int(y) for y in self.serverIP.split(".")]
h = str(54*h[0] + 41*h[1] + 29*h[2] + 17*h[3])
dec = randint(0, 255)
encodedStr = "{0:02X}".format(dec)
for i in range(len(msg)):
dec = ((dec + ord(msg[i]))%255) ^ ord(h[i % len(h)])
encodedStr += "{0:02X}".format(dec)
print encodedStr.upper()
return encodedStr.upper()
def heartbeat(self, dt):
# Udržení spojení, posílá znak FF hex na server
if self.connection != None:
self.connection.write(chr(255))
def team_select(self, dt):
# Výběr týmu, odesláno hned po přihlášení k serveru
if self.connection != None:
self.connection.write("team {0} {1}\xff".format(self.id, self.team))
self.print_message("playerjoin {0} {1}\xff".format(self.id, self.nickname))
def startgame(self, instance):
# Start hry po stisku tlačítka START v herní obrazovce
if self.onAndroid():
self.vibrate(0.05)
if self.connection != None:
state = 0
if self.field.startgame == False:
state = 1
self.connection.write("startgame {0} {1}\xff".format(state, self.id))
self.Cfg[3] = (self.server, self.version, 'classic' if self.tetrifast == False else 'tetrifast')
if self.addBookmark:
serv = (self.server, self.version, 'classic' if self.tetrifast == False else 'tetrifast')
if serv not in self.Cfg[-1]:
self.Cfg[-1].append(serv)
self.refreshCfg()
def pausegame(self, instance):
# Pozastavení hry tlačítkem POZASTAVIT v herní obrazovce
if self.onAndroid():
self.vibrate(0.05)
if self.paused == True:
state = 0
else:
state = 1
self.send_message("pause {0} {1}".format(state, self.id))
def onAndroid(self):
# Pomocná funkce pro Android
if PLATFORM == "android":
return True
else:
return False
def vibrate(self, t):
# Vibrace Android telefonu
android.vibrate(t)
def getConfig(self):
# Čte konfigurační soubor config.ini
try:
f = open("config.ini", "r")
cfg = [y.strip() for y in f.readlines()]
f.close()
cfg[-2] = eval(cfg[-2])
cfg[-1] = eval(cfg[-1])
print cfg
return cfg
except:
return False
def makeCfg(self, lang):
# Vytváří konfiguraci
if self.Cfg:
self.Cfg[0] = lang
else:
self.Cfg = [lang, '', '', tuple(), list()]
self.refreshCfg()
self.doStrInsert()
def refreshCfg(self):
# Zapíše změny do konfiguračního souboru
f = open("config.ini", "w")
f.writelines([str(y)+"\n" for y in self.Cfg])
f.close()
def on_swipe_right(self):
# Vyvoláno při tažení prstu doprava na obrazovkách obsahující
# GestureListener
self.sm.transition = SlideTransition(direction="right")
if self.sm.current_screen.name == "GameScreen":
self.sm.current = "PartylineScreen"
self.chat.text = ""
self.chat.unread.opacity = 0
else:
try:
if self.sm.current_screen.input.focus:
self.sm.current_screen.input.focus = False
except:
pass
self.sm.current = "StatsScreen"
print "< swipe right >"
def on_swipe_left(self):
# Vyvoláno při tažení prstu doleva na obrazovkách obsahující
# GestureListener
self.sm.transition = SlideTransition(direction="left")
if self.sm.current_screen.name == "StatsScreen":
self.sm.current = "PartylineScreen"
elif self.sm.current_screen.name == "PartylineScreen":
if self.sm.current_screen.input.focus:
self.sm.current_screen.input.focus = False
self.chat.unread.opacity = 0
self.chat.text = ""
self.sm.current = "GameScreen"
print "< swipe left >"
def build(self):
sm = ScreenManager()
sm.add_widget(Screen(name='intro'))
sm.add_widget(Screen(name='vote'))
sm.add_widget(Screen(name='result'))
#### INTRO
def goto_vote(instance):
if len(self.dniinput.text) == 8:
self.popup.dismiss()
self.dni = self.dniinput.text
self.sm.current = 'vote'
def goto_dni(instance):
layout = BoxLayout(padding=10, orientation='vertical')
dniinput = TextInput(text='', multiline=False, size_hint=(1, 0.2))
confirm_btn = Button(text='CONTINUAR', size_hint=(1, 0.2))
layout.add_widget(dniinput)
layout.add_widget(confirm_btn)
popup = Popup(title=u'Porfavor ingresa tu DNI',
content=layout,
size_hint=(None, None),
size=(400, 400))
confirm_btn.bind(on_press=goto_vote)
self.popup = popup
self.dniinput = dniinput
popup.open()
intro = sm.get_screen('intro')
welcome = RstDocument(text=intro_text)
layout = AnchorLayout(padding=10, orientation='vertical')
layout.add_widget(welcome)
layout.add_widget(
Button(text='Reportar Mi Voto',
size_hint=(0.5, 0.1),
on_press=goto_dni))
intro.add_widget(layout)
#### VOTO
def goto_result(instance):
self.sm.current = 'result'
self.popup.dismiss()
self.send_vote()
def goto_confirm(instance):
layout = BoxLayout(padding=10, orientation='vertical')
layout.add_widget(Label(text=instance.text))
btn_layout = BoxLayout(
padding=10,
orientation='horizontal',
size_hint=(1, 0.2),
)
confirm_btn = Button(text='CONFIRMAR')
cancel_btn = Button(text='CANCELAR')
btn_layout.add_widget(confirm_btn)
btn_layout.add_widget(cancel_btn)
layout.add_widget(btn_layout)
popup = Popup(title=u'Confirma tu Opción',
content=layout,
size_hint=(None, None),
size=(400, 400))
cancel_btn.bind(on_press=popup.dismiss)
confirm_btn.bind(on_press=goto_result)
self.popup = popup
self.opcion = instance.text
popup.open()
voto = sm.get_screen('vote')
layout = BoxLayout(padding=10, orientation='vertical')
random.shuffle(candidatos)
for cand in candidatos:
layout.add_widget(Button(text=cand[4], on_press=goto_confirm))
voto.add_widget(layout)
### RESULT
result = sm.get_screen('result')
goodbye = RstDocument(text=result_text)
layout = AnchorLayout(padding=10, orientation='vertical')
layout.add_widget(goodbye)
progress = ProgressBar(value=20)
layout.add_widget(progress)
result.add_widget(layout)
self.progress = progress
self.sm = sm
return sm
class Car(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.title = "Infernus"
self.theme_cls.primary_palette = "DeepOrange"
self.theme_cls.theme_style = "Light"
self.sm = ScreenManager()
self.has_animated_card = False
self.has_animated_background = False
def login(self, usr, passwd):
if (usr.text == "salman97" and passwd.text == "salman"):
#Snackbar(text="Welcome " + usr.text + "!").show()
toast("Welcome " + usr.text + "!")
self.manage_screens("home_screen", "add")
self.change_screen("home_screen")
else:
toast("Incorrect username and/or password!")
#Snackbar(text="Incorrect username and/or password!").show()
def animate_background(self, widget):
if self.has_animated_background == False:
anim = Animation(size_hint_y=1) + Animation(size_hint_y=0.5)
anim.start(widget.ids.bx)
def animate_card(self, widget):
# {"center_x": 0.5, "center_y": 0.6}
if self.has_animated_card == False:
anim = Animation(pos_hint={
"center_x": 0.5,
"center_y": 0.6
},
duration=0.5)
anim.start(widget)
self.has_animated_card = True
def change_screen(self, screen_name):
if self.sm.has_screen(screen_name):
self.sm.current = screen_name
def manage_screens(self, screen_name, action):
scns = {
"login_screen": Factory.LoginScreen,
"home_screen": Factory.HomeScreen,
"explore_screen": Factory.ExploreScreen
}
try:
if action == "remove":
if self.sm.has_screen(screen_name):
self.sm.remove_widget(self.sm.get_screen(screen_name))
#print("Screen ["+screen_name+"] removed")
elif action == "add":
if self.sm.has_screen(screen_name):
pass
#print("Screen [" + screen_name + "] already exists")
else:
self.sm.add_widget(scns[screen_name](name=screen_name))
#print(screen_name + " added")
#print("Screen ["+screen_name+"] added")
except:
print(traceback.format_exc())
print("Traceback ^.^")
def on_pause(self):
return True
def on_resume(self):
pass
def build(self):
print('hello')
self.bind(on_start=self.post_build_init)
self.sm.add_widget(Factory.LoginScreen())
self.sm.add_widget(Factory.HomeScreen())
self.sm.current = "login_screen"
return self.sm
def post_build_init(self, ev):
win = self._app_window
win.bind(on_keyboard=self._key_handler)
def _key_handler(self, *args):
key = args[1]
# 1000 is "back" on Android
# 27 is "escape" on computers
if key in (1000, 27):
try:
self.sm.current = "login_screen"
except Exception as e:
print(e)
return True
elif key == 1001:
try:
self.sm.current = "login_screen"
except Exception as e:
print(e)
return True
__version__ = "0.1"
sm = ScreenManager(transition=SwapTransition())
sm.add_widget(HomePage(name="home"))
sm.add_widget(BookResultPage(name="books_page"))
sm.add_widget(Loader(name="loading_screen"))
sm.add_widget(BookShelf(name="book_shelf"))
sm.add_widget(NOInternet(name="no_internet"))
sm.add_widget(About(name="about"))
sm.add_widget(DisClaimer(name='disclaims'))
sm.add_widget(CoverPage(name="cover_page"))
sm.add_widget(BookDetailsPage(name="details"))
sm.add_widget(Dictionary(name="dictionary"))
sm.add_widget(DictionaryRegister(name="dict_reg"))
sm.add_widget(DictionaryResults(name="dict_results"))
Clock.schedule_interval(sm.get_screen("home").update_developer, 5)
class MainApplication(App):
def build(self):
self.del_covers()
return sm
# deleting previously downloaded covers.
def del_covers(self):
try:
path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "covers")
files = os.listdir(path)
for fi in files:
os.remove(os.path.join(path, fi))
except:
os.mkdir("covers")
class Logotouch(App):
connected = BooleanProperty(False)
def build_config(self, config):
config.setdefaults('server', {
'host': 'logotouch.erasme.org',
'db': '0' })
def build(self):
from kivy.core.window import Window
Window.bind(on_keyboard=self._on_window_keyboard)
self.user_email = '*****@*****.**'
self.user_name = 'Mathieu Virbel'
self.rpc = None
self.game_screen = None
self.sm = ScreenManager(transition=SlideTransition())
self.screen_welcome = WelcomeScreen(name='welcome')
self.sm.add_widget(self.screen_welcome)
self.connect()
#self.create_session_with_corpus(0)
return self.sm
def create_session(self):
if not hasattr(self, 'screen_create_session'):
self.screen_create_session = CreateSessionScreen(name='create')
self.sm.add_widget(self.screen_create_session)
self.sm.current = 'create'
def join_session(self):
if not hasattr(self, 'screen_join_session'):
self.screen_join_session = JoinSessionScreen(name='join')
self.sm.add_widget(self.screen_join_session)
self.sm.current = 'join'
def create_session_with_corpus(self, corpus_id):
if not hasattr(self, 'screen_download_corpus'):
self.screen_download_corpus = DownloadScreen(name='download',
title=_('Game is starting'),
action=_('Creating session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus)
self.sm.current = 'download'
self.g_corpus_id = corpus_id
self.rpc.new_session(self.user_email, corpus_id,
callback=self._on_create_session)
def create_session_new_corpus(self):
if not hasattr(self, 'screen_download_corpus'):
self.screen_download_corpus = DownloadScreen(name='download',
title=_('Game is starting'),
action=_('Creating session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus)
self.sm.current = 'download'
from time import time
self.rpc.new_corpus(
'Corpus {}'.format(time()),
self.user_name,
self.user_email,
callback=self._on_create_corpus)
def _on_create_corpus(self, result, error=None):
if error is not None:
return
self.create_session_with_corpus(result)
def join_session_from_enc(self, enc):
try:
sessid = basedec(enc)
if not hasattr(self, 'screen_download_corpus2'):
self.screen_download_corpus2 = \
DownloadScreen(name='download2',
title=_('Game is starting'),
action=_('Joining session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus2)
self.sm.current = 'download2'
self.rpc.join_session(self.user_email, sessid,
callback=self._on_join_session)
except:
self.screen_join_session.error = _('Invalid session code')
self.sm.current = 'join'
self.screen_join_session.disptach('on_enter')
def add_sentence(self, data):
self.rpc.add_sentence(self.g_sessid, data)
def get_sentences(self, callback):
self.rpc.get_sentences(self.g_sessid, callback=callback)
def _on_join_session(self, result, error=None):
if error is not None:
self.screen_join_session.error = _('Error while joining the session: {}').format(error)
self.sm.current = 'join'
return
if result is None:
self.screen_join_session.error = _('Unknow session code')
self.sm.current = 'join'
return
self.g_sessid = result['sessid']
self.g_corpus_id = result['corpusid']
self.g_sentences_count = result['sentences_count']
self.rpc.bind_session(self.g_sessid)
self.sm.current_screen.action = _('Downloading Corpus')
self.sm.current_screen.progression = 66
self.rpc.get_corpus(self.g_corpus_id, callback=self._on_corpus)
def _on_create_session(self, result, error=None):
if error is not None:
return
self.g_sessid = result
self.g_sentences_count = 0
self.rpc.bind_session(self.g_sessid)
self.sm.current_screen.action = _('Downloading Corpus')
self.sm.current_screen.progression = 66
self.rpc.get_corpus(self.g_corpus_id, callback=self._on_corpus)
def _on_corpus(self, result, error=None):
if error is not None:
# TODO
return
self.g_corpus = result
self.sm.current_screen.progression = 100
Clock.schedule_once(self._start_game, 0.1)
def _start_game(self, *args):
self.game_screen = GameScreen(name='game',
sessid=self.g_sessid, corpus=self.g_corpus,
sentences_count=self.g_sentences_count)
if self.sm.has_screen('game'):
self.sm.remove_widget(self.sm.get_screen('game'))
self.sm.add_widget(self.game_screen)
self.sm.current = 'game'
def connect(self):
self.rpc = ThreadedRpcClient(
host=self.config.get('server', 'host'),
on_session_broadcast=self._on_session_broadcast)
def disconnect(self):
pass
def help_gesture(self):
popup = HelpGesturePopup()
popup.open()
def _on_window_keyboard(self, window, *largs):
key = largs[0]
if key != 27:
return
self.do_back()
def do_back(self):
# if there is a modal view in the window, avoid to check it
from kivy.core.window import Window
if any([isinstance(x, ModalView) for x in Window.children]):
return
if self.sm.current != 'welcome':
self.sm.current = 'welcome'
return True
def _on_session_broadcast(self, sessid, message):
if str(self.g_sessid) != str(sessid):
print 'Dropped message, invalid sessid {} (we accept {})'.format(
sessid, self.g_sessid)
return
if self.game_screen:
self.game_screen.on_broadcast(message)
class EmerFundVoteApp(App):
def build(self):
#self.store = JsonStore('aocfg.json')
#@if self.store.exists('Title'):
# print('Title exists:', self.store.get('Title'))
# #store.delete('Title')
#else:
# print('NI Title exists:')
# Create the screen manager
#from kivy.atlas import Atlas
#from kivy.cache import Cache
#self.atlas= Atlas('theme-1.atlas')
#Cache.append("kv.atlas", 'data/images/defaulttheme', self.atlas)
self.gui=Builder.load_string(kv)
self.sm = ScreenManager()
self.sm.add_widget(MenuScreen(name='menu'))
self.sm.add_widget(SettingsScreen(name='settings'))
self.sm.add_widget(DebugScreen(name='debug'))
self.votesapi=votesapi.votesapi()
return self.sm
def on_pause(self):
return True
def on_resume(self):
pass
def on_stop(self):
pass
#======================Конфиги
def open_settings(self, *largs):
self.sm.current = 'settings'
self.gui_load_config()
def gui_save_config(self):
#{'jsonrpc':1,'connection':{'host':'128.199.60.197'}}
if 'connection' not in self.votesapi.config:
self.votesapi.config['connection']={}
self.votesapi.config['connection']['host']= self.sm.get_screen('settings').ids.tihost.text
if self.sm.get_screen('settings').ids.btwallet.state=='down':
self.votesapi.config['wallet_method']='wallet'
elif self.sm.get_screen('settings').ids.btmanual.state=='down':
self.votesapi.config['wallet_method']='manual'
else:
self.votesapi.config['wallet_method']='json'
if self.sm.get_screen('settings').ids.btmanualsign.state=='down':
self.votesapi.config['jsonrpc_sign']=0
else:
self.votesapi.config['jsonrpc_sign']=1
self.votesapi.config['wallet_file']=self.sm.get_screen('settings').ids.ti_wallet_file.text
gl=self.sm.get_screen('settings').ids.gladdresses
self.votesapi.config['addresses']=[]
for c in gl.children:
#self.sm.get_screen('settings').ids['adr%s'%n].text
if c.children[0].state=='down':
self.votesapi.config['addresses'].append(c.children[0].text)
gl.height=len(gl.children)*32
self.votesapi.save_config()
def settings_get_addr_btn(self,addr):
gl=self.sm.get_screen('settings').ids.gladdresses
for c in gl.children:
if c.children[0].text==addr:
return c.children[0]
return None
def settings_get_address_label(self,b):
#по кнопке возвращает этикетку
return b.parent.children[1]
def settings_add_update_address_button(self,addr,text='???'):
b=self.settings_get_addr_btn(addr)
if b:
#кнопка есть
if text!='???':
self.settings_get_address_label(b).text=text
else:
#добавляем кнопку и метку
return self.add_address_panel(len(self.sm.get_screen('settings').ids.gladdresses.children),text,addr).children[0]
return b
def gui_load_config(self):
self.votesapi.load_config()
#if ('connection' not in self.votesapi.config):
# self.votesapi.config['connection']={}
if 'connection' not in self.votesapi.config or self.votesapi.config['connection']['host']=='':
self.sm.get_screen('settings').ids.tihost.text = '128.199.60.197'
else:
self.sm.get_screen('settings').ids.tihost.text = self.votesapi.config['connection']['host']
#wallet_method btjson btwallet btmanual
if 'wallet_method' in self.votesapi.config:
if self.votesapi.config['wallet_method']=='wallet':
self.sm.get_screen('settings').ids.btwallet.state='down'
elif self.votesapi.config['wallet_method']=='manual':
self.sm.get_screen('settings').ids.btmanual.state='down'
else:
self.sm.get_screen('settings').ids.btjson.state='down'
if 'jsonrpc_sign' in self.votesapi.config:
if self.votesapi.config['jsonrpc_sign']=='1' or self.votesapi.config['jsonrpc_sign']==1:
self.sm.get_screen('settings').ids.btjsonsign.state='down'
else:
self.sm.get_screen('settings').ids.btmanualsign.state='down'
if self.sm.get_screen('settings').ids.btmanualsign.state=='down':
self.votesapi.config['jsonrpc_sign']=0
else:
self.votesapi.config['jsonrpc_sign']=1
if 'wallet_file' in self.votesapi.config:
self.sm.get_screen('settings').ids.ti_wallet_file.text = self.votesapi.config['wallet_file']
if 'addresses' in self.votesapi.config:
self.rebuild_addresses_list()
#Сбрасываем выделения
for c in self.sm.get_screen('settings').ids.gladdresses.children:
c.children[0].state=='normal'
if 'addresses' in self.votesapi.config:
for addr in self.votesapi.config['addresses']:
#b=self.get_addr_btn(addr)
#if b is None:
# self.add_address_panel(len(self.sm.get_screen('settings').ids.gladdresses.children),'???',addr)
# b=self.get_addr_btn(addr)
b=self.settings_add_update_address_button(addr)
b.state='down'
def show_vote_table(self):
#Удаляем текущие голосования и запускаем запрос новых
while len(self.sm.get_screen('menu').ids.votetable.children)>0:
self.sm.get_screen('menu').ids.votetable.remove_widget(self.sm.get_screen('menu').ids.votetable.children[0])
#c.dismiss()
ThreadMessageBox(self._show_vote_table,{},self, modal=1, titleheader="Information: loading data, please wait", message="Пожалуйста, подождите, идет загрузка данных голосований")
#self._show_vote_table()
def _show_vote_table(self):
params={}
if not self.votesapi.config:
self.votesapi.load_config()
if ('connection' not in self.votesapi.config):
self.votesapi.config['connection']={}
if ('host' not in self.votesapi.config['connection']) or self.votesapi.config['connection']['host']=='':
self.votesapi.config['connection']['host'] ='128.199.60.197'
resp=self.votesapi.do_request('list',params)
#запуск в основном потоке
if resp:
self.last_vote_table_responce=resp
Clock.schedule_once(self.show_vote_table_callback, 0.01)
def show_vote_table_callback(self,*args):
children_height = 32+32+16+5
resp=self.last_vote_table_responce
for v in resp:
bl = BoxLayout(orientation= 'vertical',size_hint=(1, None), height=children_height)
blt = BoxLayout(orientation= 'horizontal',size_hint=(1, None), height=32)
blb = BoxLayout(orientation= 'horizontal')
#votes
blt.add_widget(ToggleButton(text='YES',on_press=self.on_vote_button_press,background_color=(1,1.2,1.5,1),size_hint=(None, 1), width=32,group='gg%s'%v['question_id'],id='by%s'%v['question_id'])) #, on_press=self.open_3
blt.add_widget(ToggleButton(text='NO',on_press=self.on_vote_button_press,background_color=(1,1.2,1.5,1),size_hint=(None, 1), width=32,group='gg%s'%v['question_id'],id='bn%s'%v['question_id'])) #, on_press=self.open_3
#blt.add_widget(ToggleButton(text='YES',background_color=(1,1.2,1.5,1),background_normal= '',background_down= '',size_hint=(None, 1), width=32,group='gg%s'%v['question_id'],id='by%s'%v['question_id'])) #, on_press=self.open_3
#blt.add_widget(ToggleButton(text='NO',background_color=(1,1.2,1.5,1),background_normal= '',background_down= '',size_hint=(None, 1), width=32,group='gg%s'%v['question_id'],id='bn%s'%v['question_id'])) #, on_press=self.open_3
#background_color=(1,1.2,1.5,1)
#background_normal= 'atlas://data/images/defaulttheme/button'
#background_down= 'atlas://data/images/defaulttheme/button_pressed'
#blt.add_widget(Label(text='#%s:%s'%(v['question_id'],v['name']),size_hint=(None,1), width=200))
#blt.add_widget(Label(text='Q:%s'%v['qmin'],size_hint=(None,1), width=50))
#blt.add_widget(Label(text='L:%s'%v['lmin'],size_hint=(None,1), width=50))
#blt.add_widget(Label(text='%s - %s'%(v['begin_date'],v['end_date']),size_hint=(None,1), width=200))
blt.add_widget(Label(text='#%s:%s'%(v['question_id'],v['name']),size_hint=(.4,1)))
blt.add_widget(Label(text='Q:%s'%v['qmin'],size_hint=(.1,1)))
blt.add_widget(Label(text='L:%s'%v['lmin'],size_hint=(.1,1)))
blt.add_widget(Label(text='%s - %s'%(v['begin_date'],v['end_date']),size_hint=(.4,1)))
blb.add_widget(TextInput(text=v['descr']))
bl.add_widget(Label(text='',size_hint=(1, None), height=5))
bl.add_widget(blt)
bl.add_widget(blb)
self.sm.get_screen('menu').ids.votetable.add_widget(bl)
if len(self.sm.get_screen('menu').ids.votetable.children)>0:
self.sm.get_screen('menu').ids.votetable.height=len(self.sm.get_screen('menu').ids.votetable.children)*children_height
else:
self.sm.get_screen('menu').ids.votetable.height=400
def on_vote_button_press(self,btn):
if btn.parent.children[len(btn.parent.children)-1].state=='down':
btn.parent.children[len(btn.parent.children)-1].background_color=(1,1.8,0.8,1)
else:
btn.parent.children[len(btn.parent.children)-1].background_color=(1,1.2,1.5,1)
if btn.parent.children[len(btn.parent.children)-2].state=='down':
btn.parent.children[len(btn.parent.children)-2].background_color=(5,0.7,0.4,1)
else:
btn.parent.children[len(btn.parent.children)-2].background_color=(1,1.2,1.5,1)
'''
if btn.state=='down':
if btn.text=='YES':
btn.background_color=(1,2,1,1)
else:
btn.background_color=(2,1,1,1)
else:
btn.background_color=(1,1.2,1.5,1)
'''
def debug_send(self,req,data):
#pass
#self.sm.get_screen('debug').ids.log.text +='\n send:'+data
#sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # Internet # UDP
#sock.sendto(data, ("127.0.0.1", 1984))
try:
import json
d=json.loads(data)
except:
import sys
self.sm.get_screen('debug').ids.log.text +='\n wrong data:%s'%sys.exc_info()[1]
return 0
resp=self.votesapi.do_request(req,d)
if resp:
self.sm.get_screen('debug').ids.log.text +='\n resp:%s'%resp
def turn_on_json(self):
import walletconfig
walletconfig.make_config_connectable()
MessageBox(parent=self,titleheader='Information: you have to restart the wallet app',message='Для продолжения работы перезапустите кошелек Emercoin', size_hint=(.9,None), size=(0,300))
def check_rpc_config(self):
#Подключает конфигурацию доступа к кошельку по json
#если уже подключено - ничего не делает
if not rpcconnet.configured():
if not rpcconnet.init_config():
#Спрашиваем одобрение включить json и включаем ежели одобрят
MessageBox(self, titleheader="Do you want to turn JSON RPC server on?", message="""В настоящее время функция доступа к кошельку для других приложнний отключена.
Для получения адресов и подписания голосов требуется включить эту функцию.
Потом ее можно будет отключить.
Включить сервер JSON для текущего кошелька?""", size_hint=(.9,.5), options=({"YES": "turn_on_json()", "NO (CANCEL)": ""}))
return 0
return 1
def get_addresses_list(self,wallet_method=""):
#получение списка адресов зависит от метода
#метод определен в from_wallet
res=[]
if not wallet_method:
if 'wallet_method' in self.votesapi.config:
wallet_method=self.votesapi.config['wallet_method']
else:
return res
if wallet_method=='wallet':
return res
elif wallet_method=='json':
if not self.check_rpc_config(): return []
try:
la=rpcconnet.walreq({"method": "listaccounts","params":[],"jsonrpc": "2.0","id": 0})['result']
except:
MessageBox(parent=self,titleheader='Error: can\'t access wallet application',message='Приложение "кошелек Emercoin" недоступно.\nВозможно, кошелек не запущен\nили требует его перезапуска', size_hint=(.9,0.4))
return res
if la:
for a in la.keys():
res.append((a,rpcconnet.walreq({"method": "getaddressesbyaccount","params":[a],"jsonrpc": "2.0","id": 0})['result']))
return res
def add_address_panel(self,n,ltext,addr):
bl=BoxLayout(orientation= 'horizontal',size_hint=(1, None), height=32)
bl.add_widget(Label(text=ltext,size_hint=(None,1), width=100))
bl.add_widget(ToggleButton(text=addr,id='adr%s'%n,background_color=(1,1.2,1.5,1))) #, on_press=self.open_3
self.sm.get_screen('settings').ids.gladdresses.add_widget(bl)
return bl
def settings_manual_add_address(self):
MessageBox(self, options=({"Ok": "settings_add_update_address_button('\%s')","Cancel": ""}), edit_add=True , titleheader="Request: please enter a new address", message="Пожалуйста введите новый адрес")
def rebuild_addresses_list(self):
#Удаление старых элементов. Пока не практикуем.
for c in self.sm.get_screen('settings').ids.gladdresses.children:
pass
ThreadMessageBox(self._rebuild_addresses_list,{},self, modal=1, titleheader="Information: loading data, please wait", message="Пожалуйста, подождите, идет загрузка данных")
def rebuild_addresses_list_callback(self,*args):
al=self.last_rebuild_addresses_list
for a in al:
for addr in a[1]:
self.settings_add_update_address_button(addr,a[0])
def _rebuild_addresses_list(self):
#создание нового списка адресов в
#import kivy.uix
#gl=kivy.uix.gridlayout()
#Добавляем (обновляем наименование) для новых, если они есть
wm='json'
if self.sm.get_screen('settings').ids.btwallet.state=='down':wm='wallet'
elif self.sm.get_screen('settings').ids.btmanual.state=='down':wm='manual'
#Высываем функцию основного потока
self.last_rebuild_addresses_list = self.get_addresses_list(wm)
if self.last_rebuild_addresses_list:
Clock.schedule_once(self.rebuild_addresses_list_callback, 0.01)
class SymptomDiaryApp(App):
engine_path = None
engine = None
calendar_screen = None
entry_screen = None
screen_manager = None
#### This is a global for session management
#### We assume that all processing will be called from the main GUI thread
#### And use a thread-local manager
#### We site it in symptom diary app because we can always get a running app
#### Everyone should call getDBSession to get this session
__Session = None
def __init__(self, engine_path, **kwargs):
self.engine_path = engine_path
super(SymptomDiaryApp, self).__init__(**kwargs)
self.engine = create_engine(self.engine_path, echo=True)
Base.metadata.create_all(self.engine);
session_factory = sessionmaker(bind=self.engine)
self.__Session = scoped_session(session_factory)
def build(self):
Builder.load_file('kv/diarywidgets.kv')
Builder.load_file('kv/entryedit.kv')
Builder.load_file('kv/entrydisplay.kv')
Builder.load_file('kv/appscreens.kv')
# initalise the screen manager, add screens and game widget to game screen then return it
self.screen_manager = ScreenManager(transition = ShaderTransition(duration=0.01))
self.calendar_screen = CalendarScreen(name='calendar')
self.entry_screen = EntryScreen(name='entry')
self.screen_manager.add_widget(self.calendar_screen)
self.screen_manager.add_widget(self.entry_screen)
return self.screen_manager
def show_calendar_screen(self):
self.screen_manager.current = 'calendar'
def getDBSession(self):
### This will be a locally managed session
### Because we are using scoped_session
return self.__Session()
def find_entry_by_date(self, date):
session = self.getDBSession()
entryQuery = session.query(Record).filter(Record.date_entered == date)
try:
result = entryQuery.one()
except NoResultFound:
result = None
return result
def create_entry_by_date(self, date, time, notes):
# first check if entry does not exist
if (self.find_entry_by_date(date) is None):
print "Will create entry for ", date
new_entry = Record(date_entered = date, notes = notes)
session = self.getDBSession()
session.add(new_entry)
session.commit()
else:
popup = ErrorPopup(
'Cannot create entry for the date of ' + date.isoformat() + " because one already exists. You can edit it instead",
)
popup.open()
def display_entry_by_date(self, date):
print "Will display entry for: ", date
entryScreen = self.screen_manager.get_screen('entry')
entry = self.find_entry_by_date(date)
if (entry is not None):
entryScreen.fill_in(entry)
self.screen_manager.current = 'entry'
else:
popup = ErrorPopup('No entry for the date of ' + date.isoformat())
popup.open()
def getEntryDates(self):
session = self.__Session()
return [result.date for result in session.query(Record.date_entered.label('date'))]
class Mark2MarketApp(MDApp):
processing = BooleanProperty(defaultValue=False)
analytics = BooleanProperty(defaultValue=True)
stock_fetch = BooleanProperty(defaultValue=True)
color = (0, 0, 0, 1)
def __init__(self, **kwargs):
super().__init__(**kwargs)
start = time.time()
self.updated = False
self.processing = True
self.screen_manager = ScreenManager()
self.current = "Main"
self.manager_open = False
self.filePath = ""
self.symbol = []
self.qty = []
self.cost = []
self.side = []
Window.bind(on_keyboard=self.events)
self.file_manager = MDFileManager(
exit_manager=self.exit_manager,
select_path=self.select_path,
)
self.file_manager.ext = ['.csv', '.CSV', '.xlsx', '.XLSX']
self.popup = self.get_popup()
self.no_data_popup = self.no_data_popup()
end = time.time()
print('elapsed time for startup is %d seconds ' % (end - start))
self.processing = False
def on_processing(self, instance, value):
pass
def on_analytics(self, instance, value):
pass
def on_stock_fetch(self, instance, value):
pass
def help(self):
HelpScreen().open()
def exit(self):
Window.close()
def on_state(self, instance, value):
pass
def get_popup(self):
pop = Popup(title='Transaction status', auto_dismiss=False)
lbl = Label()
lbl.text = 'Update successful'
btn = MDIconButton()
lbl.pos_hint = {'center_x': .5, 'center_y': .5}
btn.icon = 'home'
btn.bind(on_press=self.go_home)
btn.md_bg_color = (1, 1, 1, 1)
btn.pos_hint = {'center_x': .5, 'center_y': 0.1}
from kivy.uix.floatlayout import FloatLayout
layout = FloatLayout()
layout.add_widget(lbl)
layout.add_widget(btn)
pop.content = layout
pop.size_hint = .6, .6
return pop
def no_data_popup(self):
pop = Popup(title='Data status', auto_dismiss=False)
lbl = Label()
lbl.text = 'No Data!. Add some transactions'
btn = MDIconButton()
lbl.pos_hint = {'center_x': .5, 'center_y': .5}
btn.icon = 'home'
btn.bind(on_press=self.go_home)
btn.md_bg_color = (1, 1, 1, 1)
btn.pos_hint = {'center_x': .5, 'center_y': 0.1}
layout = FloatLayout()
layout.add_widget(lbl)
layout.add_widget(btn)
pop.content = layout
pop.size_hint = .8, .6
return pop
def go_nav(self):
if not os.path.exists('csv/pandb.csv'):
self.no_data_popup.open()
return
self.processing = True
Clock.schedule_once(self.nav_delegate, 1)
def add_nav_widget(self):
pnl = PnLScreen(self.screen_manager, name='NAV', updated=self.updated)
self.updated = False
self.screen_manager.add_widget(pnl)
def nav_delegate(self, dt):
try:
pnl = self.screen_manager.get_screen('NAV')
if self.updated or len(tryout.product_dict) == 0:
self.screen_manager.remove_widget(pnl)
self.add_nav_widget()
except ScreenManagerException:
self.add_nav_widget()
print('prod dict length = ', len(tryout.product_dict))
if len(tryout.product_dict) == 0:
self.no_data_popup.open()
else:
self.screen_manager.current = "NAV"
self.processing = False
def upload_screen(self):
self.screen_manager.current = 'Upload'
def entry_screen(self):
self.screen_manager.current = 'Entry'
def trading_screen(self):
self.screen_manager.current = 'Trade'
def gain_loss(self):
if not os.path.exists('csv/pandb.csv'):
self.no_data_popup.open()
return
self.processing = True
Clock.schedule_once(self.gain_loss_delegate, 1)
def gain_loss_delegate(self, dt):
self.processing = True
try:
self.screen_manager.get_screen('GainLoss')
except ScreenManagerException:
gl = GainLossScreen(self.screen_manager,
name='GainLoss',
updated=self.updated)
self.screen_manager.add_widget(gl)
if len(tryout.product_dict) == 0:
self.no_data_popup.open()
else:
self.screen_manager.current = 'GainLoss'
self.processing = False
def charts(self):
if not os.path.exists('csv/pandb.csv'):
self.no_data_popup.open()
return
self.processing = True
Clock.schedule_once(self.chart_delegate, 3)
def chart_delegate(self, dt):
try:
analysis = self.screen_manager.get_screen('Charts')
except ScreenManagerException:
analysis = Analysis(self.screen_manager,
name='Charts',
updated=self.updated)
# analysis.add_widgets()
self.screen_manager.add_widget(analysis)
if len(tryout.product_dict) > 0:
self.screen_manager.current = 'Charts'
else:
self.no_data_popup.open()
self.processing = False
def on_text(self):
symbol = self.root.get_screen("Entry").ids.symbol.text
self.symbol.append(symbol)
qty = self.root.get_screen("Entry").ids.quantity.text
self.qty.append(qty)
cost = self.root.get_screen("Entry").ids.cost.text
self.cost.append(cost)
side = self.root.get_screen("Entry").ids.side.text
self.side.append(side)
def open_url(self, instance):
tryout.open_url(instance.text)
def on_submit(self):
self.processing = True
Clock.schedule_once(self.submit_delegate, 1)
def submit_delegate(self, dt):
symbol = self.symbol.pop().upper()
qty = float(self.qty.pop().upper())
cost = float(self.cost.pop().upper())
side = self.side.pop().upper()
print(symbol, qty, cost, side)
success = tryout.update_portfolio(symbol, qty, cost, side)
if success:
self.screen_manager.get_screen('Entry').ids.symbol.text = ''
self.screen_manager.get_screen('Entry').ids.quantity.text = ''
self.screen_manager.get_screen('Entry').ids.cost.text = ''
self.screen_manager.get_screen('Entry').ids.side.text = ''
self.updated = True
self.processing = False
self.popup.open()
def home(self):
self.screen_manager.current = 'Main'
def go_home(self, instance):
self.screen_manager.current = 'Main'
self.popup.dismiss()
self.no_data_popup.dismiss()
def file_manager_open(self):
self.file_manager.show('/') # output manager to the screen
self.manager_open = True
def process_file(self, instance):
self.processing = True
Clock.schedule_once(self.process_file_delegate, 1)
def process_file_delegate(self, dt):
if len(self.filePath) == 0:
toast('You must select a transaction file')
return
csvFile = self.filePath
extn = self.filePath[-4:].upper()
if extn.__contains__('XLS'):
csvFile = convert_to_csv(self.filePath)
tryout.init()
tryout.make_product_dict_from_csv(csv_file=csvFile)
self.go_nav()
tryout.nav_name = 'NAV'
self.processing = False
self.root.get_screen(
self.root.current
).ids.file_chooser.text = 'Choose a transaction file'
def select_path(self, path):
"""It will be called when you click on the file name
or the catalog selection button.
:type path: str;
:param path: path to the selected directory or file;
"""
self.exit_manager()
self.root.get_screen(self.root.current).ids.file_chooser.text = path
self.filePath = path
# self.process_file()
def set_error_message(self, instance_textfield):
name = self.screen_manager.current
screen = self.root.get_screen(name)
screen.ids.input = True
def back(self):
self.screen_manager.current = 'Main'
def exit_manager(self, *args):
"""Called when the user reaches the root of the directory tree."""
self.manager_open = False
self.file_manager.close()
def events(self, instance, keyboard, keycode, text, modifiers):
"""Called when buttons are pressed on the mobile device."""
if keyboard in (1001, 27):
if self.manager_open:
self.file_manager.back()
elif self.screen_manager.current == 'Main':
self.exit()
else:
self.screen_manager.current = 'Main'
return True
def build(self):
Builder.load_file('RootWidget.kv')
addMainScreen(self.screen_manager, self)
self.screen_manager.current = "Main"
return self.screen_manager
class DuplicatorApp(App):
#icon = 'icon.png'
title = 'Duplicator - Ultimate 3D Printing App'
#use_kivy_settings = False
sm = 0
gcode = None
'''
def build_config(self, config):
config.setdefaults('general',
{
'app_background_color': '000000',
'app_width': '640'
}
)
config.setdefaults('printer',
{
'printer_com_port': '/dev/tty.usbmodem1411',
'printer_com_speed': '115200',
'printer_extruder_count': '2',
'printer_heated_bed': '70',
'printer_extruder_1_temp': '220',
'printer_extruder_2_temp': '220',
'printer_bed_temp': '70'
}
)
'''
def build_settings(self, settings):
settings.add_json_panel('General Panel', self.config, join(dirname(__file__),'settings/settings_general.json' ) )
settings.add_json_panel('Printer panel', self.config, join(dirname(__file__),'settings/settings_printer.json') )
settings.add_json_panel('Scanner panel', self.config, join(dirname(__file__),'settings/settings_scanner.json') )
def build(self):
self.config = ConfigParser()
self.config.read(join( dirname(__file__),'duplicator.ini') )
print( self.config.get('general','app_background_color') )
#if not self.config.has_section("general"):
# self.config.add_section("general")
self.activeprinter = None
self.printer_pause = 0
self.sm = ScreenManager()
self.sm.add_widget(MenuScreen(name='Menu'))
self.sm.add_widget(PrintScreen(name='Print'))
self.sm.add_widget(ScanScreen(name='Scan'))
self.sm.add_widget(ShareScreen(name='Share'))
self.sm.add_widget(ConfigScreen(name='Config'))
self.sm.add_widget(PlaterScreen(name='Plater'))
self.sm.add_widget(ViewScreen(name='View'))
self.sm.add_widget(FileGcodeLoadScreen(name='FileGcodeLoad'))
self.menu_bar = Factory.MenuBar()
self.sm.get_screen('Menu').ids.window_layout.add_widget(self.menu_bar)
self.menu_bar.ids.short_message.text = 'Duplicator Started\nReady for action.'
self.cam1 = cv2.VideoCapture(0)
return self.sm
def switchtoscreen(self,ScreenName):
if ScreenName == 'Menu':
self.sm.transition = SlideTransition(direction='left')
elif ScreenName == 'FileGcodeLoad':
self.sm.transition = SlideTransition(direction='up')
else:
if(self.sm.current=='FileGcodeLoad'):
self.sm.transition = SlideTransition(direction='down')
else:
self.sm.transition = SlideTransition(direction='right')
#print(self.sm.current)
print(ScreenName)
if(ScreenName != 'FileGcodeLoad') and (self.sm.current!='FileGcodeLoad'):
self.sm.get_screen(self.sm.current).ids.window_layout.remove_widget(self.menu_bar)
self.sm.get_screen(ScreenName).ids.window_layout.add_widget(self.menu_bar)
self.sm.current = ScreenName
def connectprinter(self,activeswitch):
if activeswitch:
self.menu_bar.ids.short_message.text = 'disconnecting....'
try:
self.activeprinter.disconnect()
self.menu_bar.ids.short_message.text = 'Done'
self.sm.get_screen('Print').ids.connectprinterswitch.active=0
self.activeprinter = None
self.menu_bar.ids.indicator_printer.color = (0,0,0,.3)
except:
self.menu_bar.ids.short_message.text = 'No printer!'
self.sm.get_screen('Print').ids.connectprinterswitch.active=0
self.menu_bar.ids.indicator_printer.color = (1,0,0,1)
else:
#print(self.sm.get_screen('Print').ids)
#print('connecting....')
self.menu_bar.ids.short_message.text ='connecting....'
try:
#self.config.get('printer','printer_com_port'),self.config.get('printer','printer_com_speed')
self.activeprinter=printcore('/dev/tty.usbmodem1411','115200')
#print('connected')
self.menu_bar.ids.short_message.text = 'connected'
self.sm.get_screen('Print').ids.connectprinterswitch.active=1
self.sm.get_screen('Print').ids.connectprinterswitch.state = 'down'
self.menu_bar.ids.indicator_printer.color = (0,1,0,1)
except:
self.menu_bar.ids.short_message.text = 'Unable to connect!'
#print('Unable to connect!')
self.sm.get_screen('Print').ids.connectprinterswitch.active=0
self.sm.get_screen('Print').ids.connectprinterswitch.state = 'normal'
self.menu_bar.ids.indicator_printer.color = (1,0,0,1)
def homeprinter(self):
self.Send('G28')
#if self.activeprinter != None:
#self.activeprinter.send('G28')
def homeX(self):
if self.activeprinter != None:
self.activeprinter.send('G28 X')
def homeY(self):
if self.activeprinter != None:
self.activeprinter.send('G28 Y')
def homeZ(self):
if self.activeprinter != None:
self.activeprinter.send('G28 Z')
def pause(self):
if self.activeprinter != None:
if self.printer_pause:
self.activeprinter.pause()
self.sm.get_screen('Print').ids.connectprinterswitch.state = 'normal'
else:
self.activeprinter.resume()
self.sm.get_screen('Print').ids.connectprinterswitch.state = 'down'
def emergencyStop(self):
if self.activeprinter != None:
self.activeprinter.send_now('M112')
def send(self,code):
if self.activeprinter != None:
self.activeprinter.send(code)
def move(self,axes,distance):
if self.activeprinter != None:
self.activeprinter.send('G1 '+axes+' '+distance)
def cameraSwitch(self):
if(self.sm.get_screen('Scan').ids.camera_button.state=='normal'):
#self.sm.get_screen('Scan').ids.scan_camera.play=True
#self.sm.get_screen('Scan').ids.scan_camera.resolution=(640, 480)
#self.sm.get_screen('Scan').ids.scan_camera.index=0
self.sm.get_screen('Scan').ids.camera_button.color = (1,1,1,1)
self.menu_bar.ids.indicator_scanner.color = (1,1,0,1)
self.menu_bar.ids.indicator_camera.color = (0,1,0,1)
#ret, frame = cam.read()
#Clock.schedule_interval(self.camUpdate, 1.0/33.0)
else:
#self.sm.get_screen('Scan').ids.scan_camera.play=False
self.sm.get_screen('Scan').ids.camera_button.color = (0,0,0,1)
self.menu_bar.ids.indicator_scanner.color = (1,1,1,.3)
self.menu_bar.ids.indicator_camera.color = (1,1,1,.3)
def closeSettingsScreen(self):
App.close_settings()
def printGcodeFile(self):
if self.activeprinter != None:
if self.gcode != None:
self.activeprinter.startprint(self.gcode,0)
self.menu_bar.ids.indicator_printer.color = (1,1,0,1)
else:
self.menu_bar.ids.indicator_printer.color = (0,1,0,1)
self.menu_bar.ids.short_message.text = 'No File Loaded!'
else:
self.menu_bar.ids.indicator_printer.color = (1,1,1,.33)
self.menu_bar.ids.short_message.text = 'No Printer Connected!'
def reset(self):
if self.activeprinter != None:
self.activeprinter.reset()
def show_gcode_load(self):
self.switchtoscreen('FileGcodeLoad')
def cancelFileGcodeLoad(self):
self.switchtoscreen('Print')
def load_gcode(self, path, filename):
with open(os.path.join(path, filename[0])) as stream:
gcode_string = stream.read()
self.sm.get_screen('Print').ids.gcode_file_name.text = filename[0]
self.gcode = gcode_string.split('\n')
#print(self.gcode.lines)
self.switchtoscreen('Print')
helper.hard_sleep_display()
self.sleeping = True
if self.sleeping and values["proximity"] < 100:
Clock.schedule_once(self.wake_display, 0.5)
self.sleeping = False
def wake_display(self, dt):
helper.hard_wake_display()
controller = ScreenManager()
def home_screen():
controller.transition = RiseInTransition()
controller.current = "Home"
lock_screen = LockScreen(name="Lock")
lock_screen.children[0].children[0].children[0].switch_to_home = home_screen
controller.add_widget(lock_screen)
controller.add_widget(HomeScreen(name="Home"))
controller.get_screen("Home").ready(controller)
class BEEOSApp(App):
def build(self):
return controller
if __name__ == '__main__':
app = BEEOSApp()
app.run()
outlook_server.ehlo()
outlook_server.starttls()
outlook_server.ehlo()
# ---------------------------------------------------------------------------
# Database
dbcon = pymysql.connect(host="localhost", user="******", password="******", db="emai_list", charset="utf8mb4")
# ---------------------------------------------------------------------------
# Set emails to the email list
cursor = dbcon.cursor()
cursor2 = dbcon.cursor()
email_value = screen_manager.get_screen("screen_sender").ids.email
cursor.execute("select email_name from emails_info")
rows = cursor.fetchall()
email_name = [str(t[0]) for t in rows]
email_value.values = email_name
cursor.execute("select email from emails_info")
email_rows = cursor.fetchall()
# ---------------------------------------------------------------------------
# Class to build and show the screen, and set some functions to the buttons.
class KivSenderApp(App):
def build(self):
class Controller(EventDispatcher):
"""
Controls the playing of audio and coordinates the updating of the playlist
and screen displays
"""
volume = NumericProperty(1.0)
advance = True
# This flag indicates whether to advance to the next track
# once the currently playing one had ended
sm = None # THe ScreenManager
pos = 0
def __init__(self, **kwargs):
""" Initialize the screens and the screen manager """
self._store = JsonStore(join(self._get_settings_folder(),
"zenplayer.json"))
self.playlist = PlayList(self._store)
self.sm = ScreenManager()
self.playing = PlayingScreen(self, name="main")
self.sm.add_widget(self.playing)
self.sm.current = "main"
if platform not in ['ios', 'android']:
self.kb_listener = ZenKeyboardListener(self.on_key_down,
self.playing)
Sound.add_state_callback(self.playing.on_sound_state)
Sound.add_state_callback(self._on_sound_state)
super(Controller, self).__init__(**kwargs)
if self._store.exists('state'):
state = self._store.get("state")
if "volume" in state.keys():
self.volume = state["volume"]
@staticmethod
def _get_settings_folder():
""" Return the folder when the setting file is stored. """
path = expanduser("~/.zencode")
if not exists(path):
mkdir(path)
return path
def _on_sound_state(self, state):
""" The sound state has changed. If the track played to the end,
move to the next track."""
if state == "finished" and self.advance:
self.play_next()
def get_current_art(self):
return self.playlist.get_current_art()
def get_current_info(self):
return self.playlist.get_current_info()
def get_current_file(self):
return self.playlist.get_current_file()
@staticmethod
def get_pos_length():
return Sound.get_pos_length()
def on_key_down(self, keyboard, keycode, text, modifiers):
""" React to the keypress event """
key_name = keycode[1]
if key_name == "up" or text == "+":
self.volume += 0.025
elif key_name == "down" or text == "-":
self.volume -= 0.025
elif key_name == "x":
self.play_pause()
elif key_name == "z":
self.play_previous()
elif key_name == "v":
self.stop()
elif key_name == "b":
self.play_next()
elif key_name == "a":
self.show_filebrowser()
elif key_name == "p":
self.show_playlist()
elif key_name == "s":
self.show_main()
return True
def on_volume(self, widget, value):
""" Set the volume of the currently playing sound """
if 0.0 > value:
self.volume = 0.0
elif value > 1.0:
self.volume = 1.0
else:
Sound.set_volume(value)
self.playing.volume_slider.value = value
def play_index(self, index):
"""
Play the track with the specified playlist index
"""
Sound.stop()
self.playlist.current = index
self.play_pause()
def play_pause(self):
""" Play or pause the currently playing track """
self.advance = True
if Sound.state == "playing":
self.pos, x = Sound.get_pos_length()
Sound.stop()
else:
audio_file = self.get_current_file()
if audio_file:
Sound.play(audio_file, self.volume)
if self.pos > 0:
def set_pos(dt):
Sound.seek(self.pos)
self.pos = 0
Clock.schedule_once(set_pos, 0.1)
def play_next(self):
""" Play the next track in the playlist. """
Sound.stop()
self.playlist.move_next()
self.play_pause()
def play_previous(self):
""" Play the previous track in the playlist. """
Sound.stop()
self.playlist.move_previous()
self.play_pause()
@staticmethod
def set_position(value):
""" Set the playing position to the specified value. """
Sound.set_position(value)
def save(self):
""" Save the state of the the playlist and volume. """
self.playlist.save(self._store)
self._store.put("state", volume=self.volume)
if "filebrowser" in self.sm.screen_names:
self.sm.get_screen("filebrowser").save(self._store)
def show_filebrowser(self):
""" Switch to the file browser screen """
if "filebrowser" not in self.sm.screen_names:
self.sm.add_widget(ZenFileBrowser(self,
self.playlist,
self._store,
name="filebrowser"))
self.sm.current = "filebrowser"
def show_playlist(self):
""" Switch to the playlist screen """
if "playlist" not in self.sm.screen_names:
self.sm.add_widget(PlayListScreen(self.sm,
self,
self.playlist,
name="playlist"))
self.sm.current = "playlist"
def show_main(self):
""" Switch to the main playing screen"""
self.sm.current = "main"
def stop(self):
""" Stop any playing audio """
self.advance = False
Sound.stop()
class EmerFundVoteApp(App):
def build(self):
#self.store = JsonStore('aocfg.json')
#@if self.store.exists('Title'):
# print('Title exists:', self.store.get('Title'))
# #store.delete('Title')
#else:
# print('NI Title exists:')
# Create the screen manager
#from kivy.atlas import Atlas
#from kivy.cache import Cache
#self.atlas= Atlas('theme-1.atlas')
#Cache.append("kv.atlas", 'data/images/defaulttheme', self.atlas)
self.gui = Builder.load_string(kv)
self.sm = ScreenManager()
self.sm.add_widget(MenuScreen(name='menu'))
self.sm.add_widget(SettingsScreen(name='settings'))
self.sm.add_widget(DebugScreen(name='debug'))
self.votesapi = votesapi.votesapi()
return self.sm
def on_pause(self):
return True
def on_resume(self):
pass
def on_stop(self):
pass
#======================Конфиги
def open_settings(self, *largs):
self.sm.current = 'settings'
self.gui_load_config()
def gui_save_config(self):
#{'jsonrpc':1,'connection':{'host':'128.199.60.197'}}
if 'connection' not in self.votesapi.config:
self.votesapi.config['connection'] = {}
self.votesapi.config['connection']['host'] = self.sm.get_screen(
'settings').ids.tihost.text
if self.sm.get_screen('settings').ids.btwallet.state == 'down':
self.votesapi.config['wallet_method'] = 'wallet'
elif self.sm.get_screen('settings').ids.btmanual.state == 'down':
self.votesapi.config['wallet_method'] = 'manual'
else:
self.votesapi.config['wallet_method'] = 'json'
if self.sm.get_screen('settings').ids.btmanualsign.state == 'down':
self.votesapi.config['jsonrpc_sign'] = 0
else:
self.votesapi.config['jsonrpc_sign'] = 1
self.votesapi.config['wallet_file'] = self.sm.get_screen(
'settings').ids.ti_wallet_file.text
gl = self.sm.get_screen('settings').ids.gladdresses
self.votesapi.config['addresses'] = []
for c in gl.children:
#self.sm.get_screen('settings').ids['adr%s'%n].text
if c.children[0].state == 'down':
self.votesapi.config['addresses'].append(c.children[0].text)
gl.height = len(gl.children) * 32
self.votesapi.save_config()
def settings_get_addr_btn(self, addr):
gl = self.sm.get_screen('settings').ids.gladdresses
for c in gl.children:
if c.children[0].text == addr:
return c.children[0]
return None
def settings_get_address_label(self, b):
#по кнопке возвращает этикетку
return b.parent.children[1]
def settings_add_update_address_button(self, addr, text='???'):
b = self.settings_get_addr_btn(addr)
if b:
#кнопка есть
if text != '???':
self.settings_get_address_label(b).text = text
else:
#добавляем кнопку и метку
return self.add_address_panel(
len(self.sm.get_screen('settings').ids.gladdresses.children),
text, addr).children[0]
return b
def gui_load_config(self):
self.votesapi.load_config()
#if ('connection' not in self.votesapi.config):
# self.votesapi.config['connection']={}
if 'connection' not in self.votesapi.config or self.votesapi.config[
'connection']['host'] == '':
self.sm.get_screen('settings').ids.tihost.text = '128.199.60.197'
else:
self.sm.get_screen(
'settings'
).ids.tihost.text = self.votesapi.config['connection']['host']
#wallet_method btjson btwallet btmanual
if 'wallet_method' in self.votesapi.config:
if self.votesapi.config['wallet_method'] == 'wallet':
self.sm.get_screen('settings').ids.btwallet.state = 'down'
elif self.votesapi.config['wallet_method'] == 'manual':
self.sm.get_screen('settings').ids.btmanual.state = 'down'
else:
self.sm.get_screen('settings').ids.btjson.state = 'down'
if 'jsonrpc_sign' in self.votesapi.config:
if self.votesapi.config[
'jsonrpc_sign'] == '1' or self.votesapi.config[
'jsonrpc_sign'] == 1:
self.sm.get_screen('settings').ids.btjsonsign.state = 'down'
else:
self.sm.get_screen('settings').ids.btmanualsign.state = 'down'
if self.sm.get_screen('settings').ids.btmanualsign.state == 'down':
self.votesapi.config['jsonrpc_sign'] = 0
else:
self.votesapi.config['jsonrpc_sign'] = 1
if 'wallet_file' in self.votesapi.config:
self.sm.get_screen(
'settings'
).ids.ti_wallet_file.text = self.votesapi.config['wallet_file']
if 'addresses' in self.votesapi.config:
self.rebuild_addresses_list()
#Сбрасываем выделения
for c in self.sm.get_screen('settings').ids.gladdresses.children:
c.children[0].state == 'normal'
if 'addresses' in self.votesapi.config:
for addr in self.votesapi.config['addresses']:
#b=self.get_addr_btn(addr)
#if b is None:
# self.add_address_panel(len(self.sm.get_screen('settings').ids.gladdresses.children),'???',addr)
# b=self.get_addr_btn(addr)
b = self.settings_add_update_address_button(addr)
b.state = 'down'
def show_vote_table(self):
#Удаляем текущие голосования и запускаем запрос новых
while len(self.sm.get_screen('menu').ids.votetable.children) > 0:
self.sm.get_screen('menu').ids.votetable.remove_widget(
self.sm.get_screen('menu').ids.votetable.children[0])
#c.dismiss()
ThreadMessageBox(
self._show_vote_table, {},
self,
modal=1,
titleheader="Information: loading data, please wait",
message="Пожалуйста, подождите, идет загрузка данных голосований")
#self._show_vote_table()
def _show_vote_table(self):
params = {}
if not self.votesapi.config:
self.votesapi.load_config()
if ('connection' not in self.votesapi.config):
self.votesapi.config['connection'] = {}
if ('host' not in self.votesapi.config['connection']
) or self.votesapi.config['connection']['host'] == '':
self.votesapi.config['connection']['host'] = '128.199.60.197'
resp = self.votesapi.do_request('list', params)
#запуск в основном потоке
if resp:
self.last_vote_table_responce = resp
Clock.schedule_once(self.show_vote_table_callback, 0.01)
def show_vote_table_callback(self, *args):
children_height = 32 + 32 + 16 + 5
resp = self.last_vote_table_responce
for v in resp:
bl = BoxLayout(orientation='vertical',
size_hint=(1, None),
height=children_height)
blt = BoxLayout(orientation='horizontal',
size_hint=(1, None),
height=32)
blb = BoxLayout(orientation='horizontal')
#votes
blt.add_widget(
ToggleButton(text='YES',
on_press=self.on_vote_button_press,
background_color=(1, 1.2, 1.5, 1),
size_hint=(None, 1),
width=32,
group='gg%s' % v['question_id'],
id='by%s' %
v['question_id'])) #, on_press=self.open_3
blt.add_widget(
ToggleButton(text='NO',
on_press=self.on_vote_button_press,
background_color=(1, 1.2, 1.5, 1),
size_hint=(None, 1),
width=32,
group='gg%s' % v['question_id'],
id='bn%s' %
v['question_id'])) #, on_press=self.open_3
#blt.add_widget(ToggleButton(text='YES',background_color=(1,1.2,1.5,1),background_normal= '',background_down= '',size_hint=(None, 1), width=32,group='gg%s'%v['question_id'],id='by%s'%v['question_id'])) #, on_press=self.open_3
#blt.add_widget(ToggleButton(text='NO',background_color=(1,1.2,1.5,1),background_normal= '',background_down= '',size_hint=(None, 1), width=32,group='gg%s'%v['question_id'],id='bn%s'%v['question_id'])) #, on_press=self.open_3
#background_color=(1,1.2,1.5,1)
#background_normal= 'atlas://data/images/defaulttheme/button'
#background_down= 'atlas://data/images/defaulttheme/button_pressed'
#blt.add_widget(Label(text='#%s:%s'%(v['question_id'],v['name']),size_hint=(None,1), width=200))
#blt.add_widget(Label(text='Q:%s'%v['qmin'],size_hint=(None,1), width=50))
#blt.add_widget(Label(text='L:%s'%v['lmin'],size_hint=(None,1), width=50))
#blt.add_widget(Label(text='%s - %s'%(v['begin_date'],v['end_date']),size_hint=(None,1), width=200))
blt.add_widget(
Label(text='#%s:%s' % (v['question_id'], v['name']),
size_hint=(.4, 1)))
blt.add_widget(Label(text='Q:%s' % v['qmin'], size_hint=(.1, 1)))
blt.add_widget(Label(text='L:%s' % v['lmin'], size_hint=(.1, 1)))
blt.add_widget(
Label(text='%s - %s' % (v['begin_date'], v['end_date']),
size_hint=(.4, 1)))
blb.add_widget(TextInput(text=v['descr']))
bl.add_widget(Label(text='', size_hint=(1, None), height=5))
bl.add_widget(blt)
bl.add_widget(blb)
self.sm.get_screen('menu').ids.votetable.add_widget(bl)
if len(self.sm.get_screen('menu').ids.votetable.children) > 0:
self.sm.get_screen('menu').ids.votetable.height = len(
self.sm.get_screen(
'menu').ids.votetable.children) * children_height
else:
self.sm.get_screen('menu').ids.votetable.height = 400
def on_vote_button_press(self, btn):
if btn.parent.children[len(btn.parent.children) - 1].state == 'down':
btn.parent.children[len(btn.parent.children) -
1].background_color = (1, 1.8, 0.8, 1)
else:
btn.parent.children[len(btn.parent.children) -
1].background_color = (1, 1.2, 1.5, 1)
if btn.parent.children[len(btn.parent.children) - 2].state == 'down':
btn.parent.children[len(btn.parent.children) -
2].background_color = (5, 0.7, 0.4, 1)
else:
btn.parent.children[len(btn.parent.children) -
2].background_color = (1, 1.2, 1.5, 1)
'''
if btn.state=='down':
if btn.text=='YES':
btn.background_color=(1,2,1,1)
else:
btn.background_color=(2,1,1,1)
else:
btn.background_color=(1,1.2,1.5,1)
'''
def debug_send(self, req, data):
#pass
#self.sm.get_screen('debug').ids.log.text +='\n send:'+data
#sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # Internet # UDP
#sock.sendto(data, ("127.0.0.1", 1984))
try:
import json
d = json.loads(data)
except:
import sys
self.sm.get_screen(
'debug').ids.log.text += '\n wrong data:%s' % sys.exc_info()[1]
return 0
resp = self.votesapi.do_request(req, d)
if resp:
self.sm.get_screen('debug').ids.log.text += '\n resp:%s' % resp
def turn_on_json(self):
import walletconfig
walletconfig.make_config_connectable()
MessageBox(
parent=self,
titleheader='Information: you have to restart the wallet app',
message='Для продолжения работы перезапустите кошелек Emercoin',
size_hint=(.9, None),
size=(0, 300))
def check_rpc_config(self):
#Подключает конфигурацию доступа к кошельку по json
#если уже подключено - ничего не делает
if not rpcconnet.configured():
if not rpcconnet.init_config():
#Спрашиваем одобрение включить json и включаем ежели одобрят
MessageBox(
self,
titleheader="Do you want to turn JSON RPC server on?",
message=
"""В настоящее время функция доступа к кошельку для других приложнний отключена.
Для получения адресов и подписания голосов требуется включить эту функцию.
Потом ее можно будет отключить.
Включить сервер JSON для текущего кошелька?""",
size_hint=(.9, .5),
options=({
"YES": "turn_on_json()",
"NO (CANCEL)": ""
}))
return 0
return 1
def get_addresses_list(self, wallet_method=""):
#получение списка адресов зависит от метода
#метод определен в from_wallet
res = []
if not wallet_method:
if 'wallet_method' in self.votesapi.config:
wallet_method = self.votesapi.config['wallet_method']
else:
return res
if wallet_method == 'wallet':
return res
elif wallet_method == 'json':
if not self.check_rpc_config(): return []
try:
la = rpcconnet.walreq({
"method": "listaccounts",
"params": [],
"jsonrpc": "2.0",
"id": 0
})['result']
except:
MessageBox(
parent=self,
titleheader='Error: can\'t access wallet application',
message=
'Приложение "кошелек Emercoin" недоступно.\nВозможно, кошелек не запущен\nили требует его перезапуска',
size_hint=(.9, 0.4))
return res
if la:
for a in la.keys():
res.append((a,
rpcconnet.walreq({
"method": "getaddressesbyaccount",
"params": [a],
"jsonrpc": "2.0",
"id": 0
})['result']))
return res
def add_address_panel(self, n, ltext, addr):
bl = BoxLayout(orientation='horizontal',
size_hint=(1, None),
height=32)
bl.add_widget(Label(text=ltext, size_hint=(None, 1), width=100))
bl.add_widget(
ToggleButton(text=addr,
id='adr%s' % n,
background_color=(1, 1.2, 1.5,
1))) #, on_press=self.open_3
self.sm.get_screen('settings').ids.gladdresses.add_widget(bl)
return bl
def settings_manual_add_address(self):
MessageBox(self,
options=({
"Ok": "settings_add_update_address_button('\%s')",
"Cancel": ""
}),
edit_add=True,
titleheader="Request: please enter a new address",
message="Пожалуйста введите новый адрес")
def rebuild_addresses_list(self):
#Удаление старых элементов. Пока не практикуем.
for c in self.sm.get_screen('settings').ids.gladdresses.children:
pass
ThreadMessageBox(self._rebuild_addresses_list, {},
self,
modal=1,
titleheader="Information: loading data, please wait",
message="Пожалуйста, подождите, идет загрузка данных")
def rebuild_addresses_list_callback(self, *args):
al = self.last_rebuild_addresses_list
for a in al:
for addr in a[1]:
self.settings_add_update_address_button(addr, a[0])
def _rebuild_addresses_list(self):
#создание нового списка адресов в
#import kivy.uix
#gl=kivy.uix.gridlayout()
#Добавляем (обновляем наименование) для новых, если они есть
wm = 'json'
if self.sm.get_screen('settings').ids.btwallet.state == 'down':
wm = 'wallet'
elif self.sm.get_screen('settings').ids.btmanual.state == 'down':
wm = 'manual'
#Высываем функцию основного потока
self.last_rebuild_addresses_list = self.get_addresses_list(wm)
if self.last_rebuild_addresses_list:
Clock.schedule_once(self.rebuild_addresses_list_callback, 0.01)
class TCPclientApp(App):
def build(self):
"""Execute en premier apres run()"""
# Creation des ecrans
self.screen_manager = ScreenManager()
for i in range(len(SCREENS)):
self.screen_manager.add_widget(SCREENS[i][0](name=SCREENS[i][1]))
return self.screen_manager
def on_start(self):
"""Execute apres build()"""
pass
def build_config(self, config):
"""Si le fichier *.ini n'existe pas,
il est cree avec ces valeurs par defaut.
Si il manque seulement des lignes, il ne fait rien !
"""
config.setdefaults('network', {
'tcp_ip': '127.0.0.1',
'tcp_port': '8000',
'freq': '1'
})
config.setdefaults(
'kivy', {
'log_level': 'debug',
'log_name': 'tcpclient_%y-%m-%d_%_.txt',
'log_dir': '/log',
'log_enable': '1'
})
config.setdefaults('postproc', {
'double_tap_time': 250,
'double_tap_distance': 20
})
def build_settings(self, settings):
"""Construit l'interface de l'ecran Options,
pour le serveur seul, Kivy est par defaut,
appele par app.open_settings() dans .kv
"""
data = """[{"type": "title", "title":"Reseau"},
{ "type": "numeric",
"title": "Frequence",
"desc": "Frequence entre 1 et 60 Hz",
"section": "network",
"key": "freq"},
{"type": "title", "title":"Reseau"},
{ "type": "string",
"title": "TCP IP",
"desc": "TCP IP",
"section": "network",
"key": "tcp_ip"},
{"type": "title", "title":"Reseau"},
{ "type": "numeric",
"title": "TCP Port",
"desc": "TCP Port",
"section": "network",
"key": "tcp_port"}
]
"""
# self.config est le config de build_config
settings.add_json_panel('TCPclient', self.config, data=data)
def on_config_change(self, config, section, key, value):
"""Si modification des options, fonction appelee automatiquement
"""
freq = int(self.config.get('network', 'freq'))
ip = self.config.get('network', 'tcp_ip')
port = int(self.config.get('network', 'tcp_port'))
menu = self.screen_manager.get_screen("Main")
if config is self.config:
token = (section, key)
# If frequency change
if token == ('network', 'freq'):
print("Nouvelle frequence", freq)
menu.reset_clock()
# If ip change
if token == ('network', 'tcp_ip'):
print("Nouvelle ip", ip)
menu.reset_client()
# If port change
if token == ('network', 'tcp_port'):
print("Nouveau port", port)
menu.reset_client()
def go_mainscreen(self):
"""Retour au menu principal depuis les autres ecrans."""
#if touch.is_double_tap:
self.screen_manager.current = ("Main")
def do_reset(self):
"""reset de self.num"""
menu = self.screen_manager.get_screen("Main")
menu.do_reset()
def do_quit(self):
print("Je quitte proprement")
# Kivy
TCPclientApp.get_running_app().stop()
# Extinction de tout
_exit(0)
class Test(MDApp):
def build(self):
self.theme_cls.theme_style = 'Dark'
self.theme_cls.primary_palette = "Purple"
Builder.load_file(
f"{os.environ['Scheduler-master']}/KivyFiles/Login_Signup/loginwindow.kv"
)
Builder.load_file(
f"{os.environ['Scheduler-master']}/KivyFiles/Login_Signup/newinput.kv"
)
Builder.load_file(
f"{os.environ['Scheduler-master']}/KivyFiles/Login_Signup/signupwindow.kv"
)
self.sm = ScreenManager()
self.sm.add_widget(loginwindow())
self.sm.add_widget(signupwindow())
self.sm.add_widget(newinput())
return self.sm
dialog = None
inpasdialog = None
inusedialog = None
emptydialog = None
alreadydialog = None
sameemaildialog = None
samepassdialog = None
dynamic_ip = None
val012 = None
previous_time = ObjectProperty()
fixedtimedict = {}
def get_info(self):
self.emptydialog = MDDialog(
title='[color=#FFFFFF]Empty details[/color]',
text='Please fill all the required details!',
size_hint=(0.4, 0.3),
buttons=[
MDRaisedButton(text='OK',
on_release=self.empty_close,
text_color=self.theme_cls.primary_color)
])
self.alreadydialog = MDDialog(
title='[color=#FFFFFF]Can not register![/color]',
text='Email already exists!',
size_hint=(0.4, 0.3),
buttons=[
MDRaisedButton(text='OK',
on_release=self.already_close,
text_color=self.theme_cls.primary_color)
])
self.sameemaildialog = MDDialog(
title='[color=#FFFFFF]Can not register![/color]',
text='Email and Confirm email do not match!',
size_hint=(0.4, 0.3),
buttons=[
MDRaisedButton(text='OK',
on_release=self.sameemail_close,
text_color=self.theme_cls.primary_color)
])
self.samepassdialog = MDDialog(
title='[color=#FFFFFF]Can not register![/color]',
text='Password and Confirm password do not match!',
size_hint=(0.4, 0.3),
buttons=[
MDRaisedButton(text='OK',
on_release=self.samepass_close,
text_color=self.theme_cls.primary_color)
])
name = str(self.sm.get_screen('signup').ids.name.text)
email = str(self.sm.get_screen('signup').ids.email.text)
self.mainemail = email
confirm_email = str(
self.sm.get_screen('signup').ids.confirm_email.text)
password = str(self.sm.get_screen('signup').ids.password.text)
confirm_pass = str(
self.sm.get_screen('signup').ids.confirm_password.text)
if name == '' or email == '' or confirm_email == '' or password == '' or confirm_pass == '':
self.emptydialog.open()
elif email != confirm_email:
self.sameemaildialog.open()
elif password != confirm_pass:
self.samepassdialog.open()
elif mysqllog.check(email, password) == 1 or mysqllog.check(
email, password) == 2:
self.alreadydialog.open()
else:
mysqllog.add_new_user([email, password])
self.show_dialog()
def time_picker(self):
self.time_dialog = MDTimePicker()
self.time_dialog.bind(time=self.show)
self.time_dialog.open()
def show(self, instance, time):
self.sm.get_screen('ninput').ids[self.dynamic_ip].text = str(time)
mysqllog.add_user_data(self.mainemail,
[(str(self.dynamic_ip), str(time))])
self.fixedtimedict[self.dynamic_ip] = time
def MainApp(self, *args):
self.stop()
MainApp.TestNavigationDrawer().run()
def show_dialog(self, *args):
if not self.dialog:
self.dialog = MDDialog(
title='[color=#FFFFFF]Confirmation[/color]',
text='You have been registered.',
size_hint=(0.4, 0.3),
buttons=[
MDFlatButton(text='CANCEL',
on_release=self.dialog_close,
text_color=self.theme_cls.primary_color),
MDRaisedButton(text="OK!",
on_release=self.on_signup,
text_color=self.theme_cls.primary_color)
])
self.dialog.open()
def on_stop(self):
return True
def show_dialog(self, *args):
if not self.dialog:
self.dialog = MDDialog(
title='[color=#FFFFFF]Confirmation[/color]',
text='You have been registered.',
size_hint=(0.4, 0.3),
buttons=[
MDFlatButton(text='CANCEL',
on_release=self.dialog_close,
text_color=self.theme_cls.primary_color),
MDRaisedButton(text="OK!",
on_release=self.on_signup,
text_color=self.theme_cls.primary_color)
])
self.dialog.open()
def checkpass(self, *args):
self.inusedialog = MDDialog(
title='[color=#FFFFFF]Username Incorrect[/color]',
text='Your email is not registered!.',
size_hint=(0.4, 0.3),
buttons=[
MDRaisedButton(text='OK',
on_release=self.inusedialog_close,
text_color=self.theme_cls.primary_color)
])
self.inpasdialog = MDDialog(
title='[color=#FFFFFF]Password Incorrect[/color]',
text='You have entered the incorrect password.',
size_hint=(0.4, 0.3),
buttons=[
MDRaisedButton(text='OK',
on_release=self.inpasdialog_close,
text_color=self.theme_cls.primary_color)
])
self.val012 = mysqllog.check(
str(self.sm.get_screen('login').ids.username.text),
str(self.sm.get_screen('login').ids.password.text))
if self.val012 == 1:
self.stop()
self.mainemail = str(self.sm.get_screen('login').ids.username.text)
MainApp.email = str(self.sm.get_screen('login').ids.username.text)
MainApp.TestNavigationDrawer().run()
elif self.val012 == 2:
self.inpasdialog.open()
elif self.val012 == 0:
self.inusedialog.open()
def check_focus(self, instance, text):
if not text:
self.sm.get_screen('signup').ids[
self.ip2].helper_text = 'Re-Enter your {}!'.format(self.ip1)
return
if text != self.sm.get_screen('signup').ids[self.ip1].text:
self.sm.get_screen('signup').ids[
self.ip2].helper_text = '{} does not match!'.format(self.ip1)
instance.error = True
Animation(
duration=0.2,
_current_error_color=instance.error_color).start(instance)
Animation(
duration=0.2,
_current_line_color=instance.error_color,
_current_hint_text_color=instance.error_color,
_current_right_lbl_color=instance.error_color,
).start(instance)
else:
self.sm.get_screen('signup').ids[
self.ip2].helper_text = 'Re-Enter your {}!'.format(self.ip1)
Animation(duration=0.2,
_current_error_color=(0, 0, 0, 0)).start(instance)
Animation(
duration=0.2,
_current_line_color=instance.line_color_focus,
_current_hint_text_color=instance.line_color_focus,
_current_right_lbl_color=instance.line_color_focus,
).start(instance)
instance.error = False
def dialog_close(self, *args):
self.dialog.dismiss()
def inusedialog_close(self, *args):
self.inusedialog.dismiss()
def inpasdialog_close(self, *args):
self.inpasdialog.dismiss()
def empty_close(self, *args):
self.emptydialog.dismiss()
def already_close(self, *args):
self.alreadydialog.dismiss()
def sameemail_close(self, *args):
self.sameemaildialog.dismiss()
def samepass_close(self, *args):
self.samepassdialog.dismiss()
def on_stop(self):
return True
def on_signup(self, *args):
self.dialog.dismiss()
self.sm.current = 'ninput'
class AttsApp(App):
def build(self, **kwargs):
"""Exécuté en premier après run()"""
# Creation des ecrans
self.screen_manager = ScreenManager()
for i in range(len(SCREENS)):
self.screen_manager.add_widget(SCREENS[i][0](name=SCREENS[i][1]))
return self.screen_manager
def on_start(self):
"""Exécuté apres build()"""
pass
def build_config(self, config):
"""Si le fichier *.ini n'existe pas,
il est créé avec ces valeurs par défaut.
Si il manque seulement des lignes, il ne fait rien !
"""
config.setdefaults(
'network', {
'multi_ip': '224.0.0.11',
'multi_port': '18888',
'tcp_port': '8000',
'freq': '60'
})
config.setdefaults(
'kivy', {
'log_level': 'debug',
'log_name': 'androidserver_%y-%m-%d_%_.txt',
'log_dir': '/toto',
'log_enable': '1'
})
config.setdefaults('postproc', {
'double_tap_time': 250,
'double_tap_distance': 20
})
def build_settings(self, settings):
"""Construit l'interface de l'écran Options,
pour le serveur seul, Kivy est par défaut,
appelé par app.open_settings() dans .kv
"""
data = """[{"type": "title", "title":"Réseau"},
{ "type": "numeric",
"title": "Fréquence",
"desc": "Fréquence entre 1 et 60 Hz",
"section": "network",
"key": "freq"},
{"type": "title", "title":"Réseau"},
{ "type": "string",
"title": "IP Multicast",
"desc": "IP Multicast",
"section": "network",
"key": "multi_ip"},
{"type": "title", "title":"Réseau"},
{ "type": "numeric",
"title": "Port Multicast",
"desc": "Port Multicast",
"section": "network",
"key": "multi_port"},
{"type": "title", "title":"Réseau"},
{ "type": "numeric",
"title": "TCP Port",
"desc": "TCP Port",
"section": "network",
"key": "tcp_port"}
]
"""
# self.config est le config de build_config
settings.add_json_panel('AndroidServer', self.config, data=data)
def on_config_change(self, config, section, key, value):
"""Si modification des options, fonction appelée automatiquement
"""
freq = int(self.config.get('network', 'freq'))
menu = self.screen_manager.get_screen("Main")
if config is self.config:
token = (section, key)
# If frequency change
if token == ('network', 'freq'):
print("Nouvelle fréquence", freq)
# Maj self.tempo dans Network
menu.network.set_tempo(freq)
menu.network.start()
def go_mainscreen(self):
"""Retour au menu principal depuis les autres écrans."""
#if touch.is_double_tap:
self.screen_manager.current = ("Main")
def do_quit(self):
print("Je quitte proprement")
menu = self.screen_manager.get_screen("Main")
# Multicast loop
menu.network.multi_sender.stop()
# TCP Server TODO
menu.network.stop()
# Kivy
AttsApp.get_running_app().stop()
# Extinction de tout si ça tourne encore
print("Fin finale")
_exit(0)
class ScreenApp(App):
# NOTE: don't make a __init__() - follow structure of App parent class ( study super() workings of Kivy )
# this could work:
"""
def __init__(self):
super(Main, self).__init__()
"""
# ----
def build(self):
# build
self.screen_definitions = SCREENS # screen definition objects
self.screens = [] # screen objects that are succesfully added
self.cur_screen_index = 0
self.cur_screen = None
self.cur_loop_handler = None
self.setup_screen_manager()
self.data = {} # data score across all screen
# init
self.setup()
return self.screen_manager
# ----
def setup(self):
self.setup_logger()
self.make_screens()
# ----
def setup_screen_manager(self):
self.screen_manager = ScreenManager()
self.screen_manager._keyboard = Window.request_keyboard(
self._keyboard_closed, self.screen_manager
) # see: https://github.com/kivy/kivy/issues/4746
self.screen_manager._keyboard.bind(on_key_down=self._on_keyboard_down)
# ----
def _keyboard_closed(self):
# self._keyboard.unbind(on_key_down=self._on_keyboard_down)
self._keyboard = None
# ----
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
if keycode[1] == 'spacebar':
self.get_current_screen_info()
self.goto_next_screen()
return True
# ----
def setup_logger(self):
self.logger = logging.getLogger(__name__)
self.logger.setLevel(level=logging.INFO)
try:
# logger handlers
handler = logging.StreamHandler()
handler.setLevel(logging.INFO) # does something?
formatter = logging.Formatter(
'%(asctime)s %(name)s %(levelname)-4s %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
except Exception as e:
self.logger.error(e)
# ----
def make_screens(self):
for screen_definition in self.screen_definitions:
print screen_definition
if screen_definition.get(
'name') is not None and screen_definition.get(
'image') is not None:
screen = Screen(name=screen_definition.get('name'))
self.logger.info("Make screen with image: {0}".format(
screen_definition.get('image')))
img = Image(source=screen_definition.get('image'))
screen.add_widget(img)
self.screen_manager.add_widget(screen)
# succesful added screens
self.screens.append(screen_definition)
# set first screen
if self.cur_screen is None:
self.cur_screen = screen_definition
else:
self.logger.error(
"WARNING: screen definition has no name {0} or image {1}".
format(screen_definition.get('name'),
screen_definition.get('image')))
# ----
def set_loop_handler(self, screen):
self.logger.info("=> set_loop_handler")
Clock.unschedule(self.cur_loop_handler)
self.cur_loop_handler = Clock.schedule_interval(self.do_loop, 1)
# ----
def do_loop(self, df):
# df is time difference since last call
print '==== loop action ===='
loop_func = None
on_data_command = None
on_data_param = None
if self.cur_screen.get('action'):
loop_func = self.cur_screen.get('action').get('loop_func')
on_data_command = self.cur_screen.get('action').get(
'on_data_command')
on_data_param = self.cur_screen.get('action').get('on_data_param')
if loop_func:
self.logger.info("ScreenApp: do_loop: run '{}'".format(
loop_func.__name__))
result = loop_func(self.data)
if result is not None:
self.logger.info("result: {0}".format(result))
self.data.update(
result
) # update the current state with the data we just got
# trigger command
self.handle_on_data(on_data_command, on_data_param)
else:
# do nothing
pass
else:
self.logger.info(
"ScreenApp: do_loop: no loop_func for screen '{0}'".format(
self.cur_screen.get('name')))
# ----
def handle_on_data(self, on_data_command, on_data_param):
CMD_TO_FUNC_MAP = {
'NEXT_SCREEN': self.goto_screen_name,
# TODO
}
cmd_action = CMD_TO_FUNC_MAP.get(on_data_command)
if cmd_action is None:
self.logger.error(
"ScreenApp: ERROR: on_data_handler no known 'on_data' command: {0}"
.format(on_data_command))
return False
cmd_action(on_data_param) # do action
# ----
def goto_screen_name(self, name):
self.goto_screen(self.get_screen_by_name(name))
# ----
def goto_screen(self, screen):
self.logger.info("ScreenApp: goto screen '{0}'".format(
screen.get('name')))
self.logger.info("Current state self.data: {0}".format(self.data))
self.cur_screen = screen
self.cur_screen_index = self.screens.index(screen)
self.screen_manager.current = screen.get(
'name') # # activate screen in screen manager
# set dynamic content for current screen
screen_widget = self.screen_manager.get_screen(screen.get('name'))
print screen_widget.children
if len(screen_widget.children
) == 2: # HACKY: remove existing dynamic image
screen_widget.remove_widget(
screen_widget.children[0]
) # turns out that the first is the last ( TODO: make more robust with labels? )
# if dynamic image is set make one; given by filename of file locally stored
if screen.get('dynamic_image'):
dynamic_image_data_key = screen.get('dynamic_image')
image_file_name = self.data.get(dynamic_image_data_key)
dynamic_image_widget = Image(source=image_file_name)
screen_widget.add_widget(dynamic_image_widget)
self.logger.info(
"Dynamic image for screen {0} with image {1}".format(
screen.get('name'), image_file_name))
self.set_loop_handler(self.cur_screen)
# ----
def goto_next_screen(self):
if self.cur_screen_index < len(self.screens) - 1:
self.goto_screen(self.screens[self.cur_screen_index + 1])
# ----
def get_current_screen_info(self):
self.logger.info('Current screen: "{0}" with index: {1}'.format(
self.cur_screen.get('name'), self.cur_screen_index))
# ----
def get_screen_by_name(self, name):
for screen_definition in self.screens:
if screen_definition.get('name') == name:
return screen_definition
self.logger.error("Cannot find screen with name '{0'}".format(name))
return None
