class Netpwn(App):
def __init__(self, **kwargs):
super(Netpwn, self).__init__(**kwargs)
self.sm = ScreenManager()
self.sm.add_widget(HomeScreen(name='Home'))
self.sm.add_widget(InfoScreen(name='Info'))
self.sm.switch_to(HomeScreen(name='Home'), transition=NoTransition())
def scanTargets(self):
print("Scanning...")
def attackNetwork(self):
print("Attacking Network...")
def stopNetwork(self):
print("Stopping Network...")
def yourInfo(self):
self.sm.switch_to(InfoScreen(name='Info'), transition=NoTransition())
print("Your Info")
def build(self):
self.title = 'Netpwn'
self.icon = os.path.abspath("/Images/bolt.png")
return self.sm
def main():
sm = ScreenManager()
screenshare = Screen(name="screenshare")
sm.switch_to(screenshare)
boxl = BoxLayout(orientation='vertical')
data = BytesIO()
canvas_img = Im.new('RGB', (1920, 1080), color=(0, 0, 0))
canvas_img.save(data, format='png')
data.seek(0)
kimg = KiImage(data, ext='png')
img = Image()
img.texture = kimg.texture
img.allow_strech = True
img.keep_ratio = True
btn = Button(text='start', pos_hint={'x': 0, 'y': 0}, size_hint=(0.1, 0.1))
sock = socket.socket()
host = '127.0.0.1'
port = 8000
def retreive(*a):
rwh = sock.recv(50).decode()
rwh = eval(rwh)
print(rwh)
repeat = rwh[0]
width = rwh[1]
height = rwh[2]
print(repeat)
b = bytearray()
flag = 0
for i in range(repeat):
im = sock.recv(1024)
b.extend(im)
flag = flag + 1
print(flag, len(b))
z = Im.frombytes('RGB', (width, height), bytes(b))
data.seek(0)
z.save(data, format='png')
data.seek(0)
kimg = KiImage(data, ext='png')
img.texture = kimg.texture
#img.source(z)
def startret(*a):
print('hello')
sock.connect((host, port))
Clock.schedule_interval(retreive, 1.0 / 20)
boxl.add_widget(img)
boxl.add_widget(btn)
btn.bind(on_press=startret)
screenshare.add_widget(boxl)
return sm
class TreeApp(App):
def __init__(self, **kwargs):
super(TreeApp, self).__init__(**kwargs)
self.sm = ScreenManager()
def build(self):
self.sm.switch_to(ServerSelection(name="serverselect"))
return self.sm
def build(self):
"""Init screen manager."""
sm = ScreenManager()
start_screen_ = start_screen.StartScreen(sm, name=self.start_screen_name)
sm.switch_to(start_screen_)
# end_screen_ = end_screen.EndScreen(sm, 'Trump')
# sm.switch_to(end_screen_)
return sm
class PypeApp(App):
"""Main app class.
Attributes:
gui_evt_port (int): Port of GUI event listener.
gui_evt_sender (socket.socket): UDP socket that sends GUI events to
the communication component of app.
peer (PypePeer): App's communication component.
root_sm (ScreenManager): Root screen manager.
"""
def send_gui_evt(self, data):
"""Sends GUI event to communication component of app.
Args:
data (dict): Event data (in JSON format).
"""
self.gui_evt_sender.sendto(json.dumps(data, separators=(',', ':')),
('localhost', self.gui_evt_port))
def on_stop(self):
"""Application close event callback.
"""
self.send_gui_evt({'type': 'terminate'})
def build(self):
"""App builder.
Returns:
ScreenManager: Root screen manager.
"""
# Creating root object with all app screens
self.root_sm = ScreenManager()
self.root_sm.switch_to(EntryScreen())
# Creating communication thread
self.peer = PypePeer()
self.gui_evt_port = self.peer.get_gui_evt_port()
self.peer.run()
# Creating user event sender
self.gui_evt_sender = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return self.root_sm
@mainthread
def switch_to_main_screen(self, **kwargs):
"""Switches current screen to main screen.
Args:
**kwargs: Keyword arguments supplied in dictionary form.
"""
main_screen = MainScreen(**kwargs)
self.root_sm.switch_to(main_screen)
class Example(App):
def __init__(self):
super(Example, self).__init__()
def build(self):
self.title = 'Example'
self.pos = (0, 0)
self.currentDir = dirname(__file__)
self.sm = ScreenManager()
self.screens = {}
test = DataGridScreen()
self.sm.switch_to(test)
return self.sm
class Example(App):
def __init__(self):
super(Example, self).__init__()
def build(self):
self.title = 'Example'
self.pos = (0, 0)
self.currentDir = dirname(__file__)
self.sm = ScreenManager()
self.screens = {}
test = DataGridScreen()
self.sm.switch_to(test)
return self.sm
class MyApp(App):
def build(self):
self.title = 'Text Translation'
self.sm = ScreenManager()
self.main_screen = MainScreen(name="main screen")
def move_to_main(session_id = 0):
self.sm.switch_to(self.main_screen)
self.main_screen.session_id = session_id
self.login_screen = LoginScreen(switch_main_callback=move_to_main, name="Login screen")
self.sm.switch_to(self.login_screen)
return self.sm
class ForestDefenders2App(App):
# changes window title
title = "Forest Defenders 2"
def __init__(self, **kwargs):
super(ForestDefenders2App, self).__init__(**kwargs)
# initialize new ScreenManager for handling screens, and set it as global for ease of use
self.manager = ScreenManager()
global MANAGER
MANAGER = self.manager
def build(self):
# load and start playing game audio
if musicA:
musicA.loop = True
musicA.play()
# set starting screen
self.manager.switch_to(MainMenuScreen(name="MainMenu"))
return self.manager
class Main(MDApp):
def build(self):
global screens
Builder.load_file("tmlayout.kv")
self.sm = ScreenManager(transition=NoTransition())
screens = list()
screens.append(Main_info(name="MainInfo"))
screens.append(sub_new_activity(name="subNewActivity"))
screens.append(activity_timer(name="activitytimer"))
for i in range(len(screens)):
self.sm.add_widget(screens[i])
screens[i].uxids_dict_add(screens)
print("potato" + str(screens))
self.theme_cls.primary_palette = "Blue"
print("0current Screen: " + str(self.sm.current_screen) + " | has the next screen? " +str(self.sm.has_screen("MainInfo")))
self.sm.switch_to(screens[0])
return self.sm
class YAHTRApp(App):
def __init__(self, mode, **kwargs):
super(YAHTRApp, self).__init__(**kwargs)
self.screen_manager = ScreenManager(transition=FadeTransition())
self.mode = mode
def build(self):
self.title = 'Yet Another Hex Tactical RPG'
if self.mode == 'chess_demo':
self.go_to_chess_demo()
elif self.mode == 'editor':
self.go_to_editor()
else:
self.go_to_main_menu()
return self.screen_manager
def go_to_features_demo(self):
options = {'setup_name': 'features_demo'}
game_screen = GameScreen(battle_options=options)
self.screen_manager.switch_to(game_screen)
def go_to_chess_demo(self):
options = {'setup_name': 'chess_demo'}
game_screen = GameScreen(battle_options=options)
self.screen_manager.switch_to(game_screen)
def go_to_editor(self):
self.screen_manager.switch_to(Editor())
def go_to_main_menu(self):
self.screen_manager.switch_to(MainMenu())
def go_to_credits(self):
self.screen_manager.switch_to(Credits())
class TestApp(App):
def build(self):
test = Screen()
self.sm = ScreenManager()
self.screens = {}
self.screens['test'] = MainFunctionScreen(misc_func=self.switch_screen)
self.screens['test2'] = test
# self.screens['testfunc'] = self.test_func
self.sm.switch_to(self.screens['test'])
# fetch user attributes
init_obj = {
'developer_name': "aaron",
'ticket_number': 123,
}
# sample function call to go to mainfunction screen
self.go_to_main_functions(main_func=MainFunctionScreen(
init_obj=init_obj))
return self.sm
def switch_screen(self):
self.sm.switch_to(self.screens['test2'])
# sample function to go to mainfunction screen
def go_to_main_functions(self, main_func):
self.screens['mainfunc'] = main_func
self.sm.switch_to(self.screens['mainfunc'])
def test_func(self):
print('test')
class BuRn(App):
# Initialisierung
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.path = ""
self.sm = ScreenManager() # ScreenManager verwaltet Screens und wechselt zwischen ihnen
self.main_screen = Screen()
self.browser_screen = Screen()
def build(self):
# Datei/Ordner-Auswahl-Widget
file_chooser = FileChooserListView(size_hint_y=1)
file_chooser.dirselect = True
file_chooser.multiselect = False
file_chooser.filter = ["*.-----"] # Nonsens-Dateiendung um nur Ordner anzuzeigen
file_chooser.bind(selection=lambda _, x: self.on_select(file_chooser.selection))
file_chooser.size_hint_min_y = 400
# Auswahlknopf
select_button = Button(text="Auswählen", size_hint=(1, .2))
select_button.bind(on_release=lambda x: self.on_submit())
# Container für Knopf und Ordnerauswahl
container = BoxLayout(orientation="vertical")
container.add_widget(file_chooser)
container.add_widget(Padding(select_button, 200, 5))
# Screens
self.browser_screen.add_widget(container)
self.main_screen.add_widget(BuRnScreen(switch_dirs=self.switch_dirs, run_process=self.run_process))
self.sm.switch_to(self.browser_screen) # Anfangsbildschirm ist die Ordnerauswahl
return self.sm # ScreenManager ist "root" der Oberfläche
def switch_dirs(self, _):
self.sm.switch_to(self.browser_screen)
def run_process(self, pattern, replacer):
# Wenn Muster nicht nichts ist, Crawler starten
# TODO: Komischer bug, der endlos-Rekursion hervorruft bei mehreren (verschachtelten?) Aufrufen bei einem Run
if pattern.text != "":
# Popup dient als Rueckmeldung, dass Prozess erfolgreich war (callback)
popup = Popup(title="Erfolg",
content=Label(text="Alle Dateien gescannt!"),
size=(100, 100),
size_hint=(0.3, 0.3))
start_process(self.path, pattern.text, replacer=replacer.text, callback=popup.open)
else:
# Popup um falsche Eingabe zu melden
popup = Popup(title="Fehlschlag",
content=Label(text="Bitte ein gültiges Muster eingeben!"),
size=(100, 100),
size_hint=(0.3, 0.3))
popup.open()
def on_select(self, val):
# Ordnername speichern wenn nicht nichts
if val is not None:
self.path = val[0]
def on_submit(self):
# Zu Hauptbildschirm wechseln, wenn Pfad nicht nichts ist
if self.path != "":
self.sm.switch_to(self.main_screen)
class MainWindow(App):
clock_beginning = None
processing = False
last_clocked_saved = None
def __init__(self, parent, **kwargs):
super(MainWindow, self).__init__(**kwargs)
self.app = parent
self.app.initialize()
self.screen_manager = ScreenManager()
self.screens = dict()
self.screens[START_SCREEN] = StartScreen(name='1')
self.screens[START_SCREEN].set_parameters(parent=self,
groups=self.app.groups())
self.screen_manager.add_widget(self.screens[START_SCREEN])
self.screens[INITIALIZED_SCREEN] = InitializedScreen(name='2')
self.screen_manager.add_widget(self.screens[INITIALIZED_SCREEN])
self.screens[PROJECT_CREATION_SCREEN] = CreateProjectWindow(name='3')
self.screens[PROJECT_CREATION_SCREEN].set_parameters(parent=self)
self.screen_manager.add_widget(self.screens[PROJECT_CREATION_SCREEN])
def build(self):
return self.screen_manager
def set_start_clock(self):
self.clock_beginning = datetime.datetime.now()
def create_project_window(self, instance=None):
self.screen_manager.switch_to(self.screens[PROJECT_CREATION_SCREEN])
def create_project(self, instance=None):
self.app.create_project(
self.screens[PROJECT_CREATION_SCREEN].get_text_projects_inputs())
def edit_project_window(self, instance=None):
pass
def create_group_window(self, instance=None):
pass
def edit_group_window(self, instance=None):
pass
def initialize(self, instance=None):
self.screens[INITIALIZED_SCREEN].initialize()
project = self.app.get_project()
step = self.app.get_step() if project else None
self.screens[INITIALIZED_SCREEN].set_parameters(
self, project.name
if project else "All projects are complete, congrats boi !",
step.description if step else "")
self.screen_manager.switch_to(self.screens[INITIALIZED_SCREEN])
self.resume() if project else self.app.pause()
def get_projects(self, group):
return self.app.get_projects(group)
def set_project_filter(self, project):
self.app.set_project_filter(project)
def set_group_filter(self, group):
self.app.set_group_filter(group)
def pause(self, instance=None):
self.app.pause()
self.app.save()
def resume(self, instance=None):
self.last_clock_saved = datetime.datetime.now()
self.app.resume()
def update_step(self):
step = self.app.get_step()
if not step:
return
if step is STATE_FINISHED:
self.screens[INITIALIZED_SCREEN].update_step("Project complete !")
else:
self.screens[INITIALIZED_SCREEN].update_step(step.description)
def validate(self, instance=None):
#TODO : reset timer
self.app.validate()
self.app.save()
self.update_step()
#self.screen_manager.switch_to(self.screens[INITIALIZED_SCREEN])
self.resume()
def stop(self, instance=None):
self.pause()
self.screens[INITIALIZED_SCREEN].clear_widgets()
self.screen_manager.switch_to(self.screens[START_SCREEN])
self.app.reset_session_elapsed_time()
def calculate_elapsed_time(self, instance=None):
if not self.app.is_processing():
return
elapsed_time = self.app.register_elapsed_time(datetime.datetime.now() -
self.last_clock_saved)
hours, remainder = divmod(elapsed_time.seconds, 3600)
minutes, seconds = divmod(remainder, 60)
self.screens[INITIALIZED_SCREEN].set_label_elapsed_time(
hours, minutes, seconds)
self.last_clock_saved = datetime.datetime.now()
class KivyClientApp(App):
def build(self):
#non_update_message boolean is checked by scheduled send_request in order to decide whether to simply request
#an update on the state of the drivers or to send an actual event request(turn on/off, rename, etc)
self.non_update_message = False
self.sm = ScreenManager()
self.password_screen = PasswordScreen(name='PASSWORD_SCREEN')
self.sm.add_widget(self.password_screen)
#self.password_screen.user_input.focus = True
self.drivers_screen = Drivers_Screen(name='DRIVERS_SCREEN')
self.name_screen = NameScreen(name='NAME_SCREEN')
self.timer_screen = TimerScreen(name='TIMER_SCREEN')
self.client = GUI_Client()
self.drivers_panel = DriversPanel()
#request update to initialize widgets for driver board
return self.sm
def _toggle_event(self, driverid):
self.non_update_message = True
self.request = message.Message('toggle', [driverid])
def _name_event(self, driverid, new_name):
self.non_update_message = True
self.request = message.Message('name', [driverid, new_name])
def _timer_event(self, driverid, time):
self.non_update_message = True
self.request = message.Message('timer', [driverid, time])
def request_server_info(self, dt):
if self.non_update_message:
print self.request
self.client.send(self.request)
self.request = None
self.non_update_message = False
else:
self.client.send(message.Message('update', ['update info']))
new_driver_info = self.client.receive()
assert new_driver_info.type == 'motor_response', 'unrecognized response type %s' % new_driver_info.type
self.timers = new_driver_info.data['timers']
self._update_GUI(new_driver_info.data['drivers'])
def _update_GUI(self, new_info):
widget_driver_pairs = zip(self.widget_drivers, new_info)
#each driver is a flattened representation with fields (id, name, state, state_time)
for widget, driver in widget_driver_pairs:
assert widget.driverid == driver[0], 'widgetid %d driverid %d' % (widget.driverid, driver[0])
widget.name = driver[1]
widget.state = driver[2]
widget.state_time = driver[3]
def _update_times(self, dt):
for driver in self.widget_drivers:
driver.update_time()
for driverid, remaining_time in self.timers:
self.widget_drivers[driverid].update_remaining_time(remaining_time)
def _generate_drivers_screen(self):
self.client.send(message.Message('update', ['update info']))
print 'requested server info'
#each driver in driver_info is a tuple (id, name, state, state_time) representing a driver on the server side
driver_information = self.client.receive().data
for driver in driver_information['drivers']:
print driver
self.drivers_panel.add_widget(DriverWidget(*driver))
#must reverse children list, since it is in order of last widget added(id 7) to first(id 0) where the update
#info is the other way around when matching up with the new driver information received by the servers
self.widget_drivers = self.drivers_panel.children[:]
self.widget_drivers.reverse()
self.drivers_screen.add_widget(self.drivers_panel)
Clock.schedule_interval(self.request_server_info, 0.1)
Clock.schedule_interval(self._update_times, 1.0)
self.sm.switch_to(self.drivers_screen)
def login(self, username, password):
response = self.client.login(username, password)
if (response == 's'):
self._generate_drivers_screen()
elif(response == 'u'):
self.password_screen.invalid_user()
elif(response == 'p'):
self.password_screen.invalid_password()
else:
pass
def change_name(self, driverid, name):
self.name_screen.old_name = name
self.name_screen.new_name.focus = True
self.name_screen.identifier = driverid
self.sm.switch_to(self.name_screen, direction='right')
def set_timer(self, driverid, name):
self.timer_screen.name = name
self.timer_screen.driverid = driverid
self.sm.switch_to(self.timer_screen, direction='right')
self.timer_screen.seconds_input.focus = True
def back_to_main(self):
self.sm.switch_to(self.drivers_screen, direction='left')
Config.set('graphics', 'width', '320')
Config.set('graphics', 'height', '480')
Builder.load_file('kv/sudoku.kv')
LabelBase.register(
'SeoulNamsan',
fn_regular='static/font/SeoulNamsanM.ttf',
fn_bold='static/font/SeoulNamsanB.ttf')
problem = Problem.loads(
"800523910162489075350170420425008009690000"
"057700600234037062041540317692016954003",
"87452391616248937535917642842573816969324185"
"7781695234937862541548317692216954783",
9)
board = Board(problem)
sm = ScreenManager()
sm.switch_to(SudokuScreen(board_model=board))
class SudokuApp(App):
def build(self):
return sm
if __name__ == '__main__':
SudokuApp().run()
from model import Board, Problem
from view import SudokuScreen
from view.widget import *
Config.set('graphics', 'width', '320')
Config.set('graphics', 'height', '480')
Builder.load_file('kv/sudoku.kv')
LabelBase.register('SeoulNamsan',
fn_regular='static/font/SeoulNamsanM.ttf',
fn_bold='static/font/SeoulNamsanB.ttf')
problem = Problem.loads(
"800523910162489075350170420425008009690000"
"057700600234037062041540317692016954003",
"87452391616248937535917642842573816969324185"
"7781695234937862541548317692216954783", 9)
board = Board(problem)
sm = ScreenManager()
sm.switch_to(SudokuScreen(board_model=board))
class SudokuApp(App):
def build(self):
return sm
if __name__ == '__main__':
SudokuApp().run()
class SystemyWspomaganiaDecyzji(App):
def __init__(self):
super(SystemyWspomaganiaDecyzji,self).__init__()
self.sharedInstance = ManagerPlikow()
self.menuLeftWrapper = None;
self.meuCenterWrapper = None;
self.checkBoxesPlotBind = {}
# def on_start(self):
#Window.bind(on_key_down=self.on_key_down)
def on_key_down(self, win, key, scancode, string, modifiers):
print( win.size, key)
if key == 102: # 'f'
normalsize = [ Config.getint('graphics', 'width'), Config.getint('graphics', 'height') ]
if (win._size == normalsize):
win._size = [1440, 900]
else:
win._size = normalsize
win.toggle_fullscreen()
win.update_viewport()
return True
def getLeftWrapper(self):
return self.me
def pokazWyborPliku(self, animated, instance, *args):
modalType = 1
anim = None;
#modal animation
if(animated):
anim = Animation(size=(640, 480), duration=0.5)
#modal frame size
size=(240, 160)
if(anim==None):
size = (640,480)
else:
#TODO:
pass
self.modalView = ModalView(size_hint=(None, None), size=size)
self.modalView.add_widget(self.sharedInstance.przegladajDysk())
#paramter in the method call, will perform some basic slace animation
if(animated):
anim.start(self.modalView)
self.modalView.open()
def pokazDodanieAtrybutu(self):
view = ModalView(size_hint=(None, None), size=(640, 480))
view.open()
return view
def pokazDodanieObiektu(self, *args):
view = ModalView(size_hint=(None, None), size=(640, 480))
box = BoxLayout(orientation="vertical",spacing=10)
scrollView = ScrollView(bar_margin=10, bar_color=[1,1,1,1])
viewWrapper = GridLayout(cols=2, row_default_height=40,size_hint_y=None,padding=[-20,20,20,20])
viewWrapper.bind(minimum_height=viewWrapper.setter('height'))
listaTextBoxow = []
for i in range(len(self.sharedInstance.data.temp)):
l = Label(text=self.sharedInstance.data.temp[i],halign="left", width=50)
#textPlaceHolder = 'Tutaj wpisz wartosc dla {0}'.format(self.sharedInstance.data.temp[i])
#textPlaceHolder,multiline=False, )
textinput = TextInput(multiline=False, text="0",focus=True)
listaTextBoxow.append(textinput)
viewWrapper.add_widget(l)
viewWrapper.add_widget(textinput)
#background_color=[51/255.0, 181.0/255, 229/255.0,1]
scrollView.add_widget(viewWrapper)
box.add_widget(scrollView)
box.add_widget(Button(text='Dodaj', font_size=14, on_press=partial(self.dodajObiekt,view, listaTextBoxow), size_hint=(1, .1)))
view.add_widget(box)
view.open()
return view
def dodajObiekt(self,view,lista,*args):
self.sharedInstance.data.dodajNowyWiersz([element.text for element in lista])
view.dismiss()
def setOrientation(self, orient):
self.orient = orient
def onPressCallback(self,instance):
self.pokazWyborPliku(instance,False)
def onPressGraphConsoleSwitch(self,instance):
if(instance.text=="Konsola"):
instance.text = "Graf"
self.sm.switch_to(self.console, direction='up')
elif(instance.text=="Graf"):
instance.text = "Konsola"
self.sm.switch_to(self.graphScreen, direction='down')
def checkBoxCallback(self,instance,value, *args):
if(value==False):
self.graphScreen.getGraph().remove_plot(app.checkBoxesPlotBind[instance])
else:
self.graphScreen.getGraph().add_plot(app.checkBoxesPlotBind[instance])
self.graphScreen.getGraph()._redraw_all
def buttonCallback(self, instance):
for plot in self.graphScreen.getGraph().plots:
plot.points = []
poNormalizacji = {}
for property in self.sharedInstance.data.temp:
poNormalizacji[property] = self.sharedInstance.data.normalizacja(property)
for property in poNormalizacji:
points = []
lista = poNormalizacji[property]
i, j = 0
pprint.pprint(lista)
for j in range(len(lista)):
points.append((i,lista[j]))
i+=1
pprint.pprint(points)
# for plot in self.graph.plots:
# plot.points = points
self.graph.ymax = 10
self.graph.ymin = -10
def buildCenterMenu(self, wrapper, rebuild=False):
if(rebuild): wrapper.clear_widgets()
numberOfItems = len(self.sharedInstance.data.temp) if self.sharedInstance.data.temp else 0
for i in range(0, numberOfItems):
checkbox = CheckBox(active=True)
checkbox.bind(active=app.checkBoxCallback)
self.checkBoxesPlotBind[checkbox] = self.graphScreen.getGraph().plots[i]
labelText = self.sharedInstance.data.temp[i] if self.sharedInstance.data.temp else "Nazwa atrybutu"
label = Label(text=labelText, halign = "right",width=100, col_default_width=20, col_force_default=True)
wrapper.add_widget(label)
wrapper.add_widget(checkbox)
def buildLeftMenu(self, wrapper):
buttonWybierzPlik = Button(text='Wczytaj plik', font_size=14)
buttonWybierzPlik.bind(on_press=partial(self.pokazWyborPliku,False))
wrapper.add_widget(buttonWybierzPlik)
buttonDodajObiekt = Button(text='Dodaj obiekt', font_size=14)
buttonDodajObiekt.bind(on_press=partial(self.pokazDodanieObiektu))
wrapper.add_widget(buttonDodajObiekt)
buttonDodajAtrybut = Button(text='Dodaj atrybut', font_size=14)
buttonDodajAtrybut.bind(on_press=self.onPressCallback)
wrapper.add_widget(buttonDodajAtrybut)
buttonStatystyki = Button(text='Statystyki', font_size=14)
buttonStatystyki.bind(on_press=self.onPressCallback)
wrapper.add_widget(buttonStatystyki)
buttonKonsola = Button(text='Graf', font_size=14)
buttonKonsola.bind(on_press=self.onPressGraphConsoleSwitch)
wrapper.add_widget(buttonKonsola)
def sliderValueChanged(self,label,description,slider,*args):
if(description.tag==1):
self.graphScreen.getGraph().x_ticks_major = 100//args[0] if args[0]!=0.0 else 100
label.text = "{0} {1}".format(description.value,int(args[0]))
elif(description.tag==2):
if(int(args[1])<self.graphScreen.getGraph().xmax):
self.graphScreen.getGraph().xmin = int(args[1])
label.text = "{0} {1}".format(description.value,int(args[1]))
args[0].max = slider.value
elif(description.tag==3):
if(int(args[1])>self.graphScreen.getGraph().xmin):
self.graphScreen.getGraph().xmax = int(args[1])
label.text = "{0} {1}".format(description.value,int(args[1]))
args[0].min = slider.value
elif(description.tag==4):
self.graphScreen.getGraph().x_ticks_major = int(args[0])
label.text = "{0} {1}".format(description.value,int(args[0]))
else:
raise ValueError("Wrong tag of the slider, check it.", self)
self.graphScreen.getGraph()._redraw_all()
def build(self):
self.sm = ScreenManager(transition=SlideTransition())
layout = BoxLayout(padding=20, orientation=self.orient, spacing=20)
self.graphScreen = GraphScreen()
self.console = Console(app=app)
self.sm.switch_to(self.console)
self.graph = self.graphScreen.getGraph();
layout.add_widget(self.sm)
menuWrapper = BoxLayout()
for i in range(0,3):
#pragma mark boczne menu z lewej
if(i==0):
menuInside = BoxLayout(orientation="vertical")
self.meuCenterWrapper = menuInside;
self.buildLeftMenu(menuInside)
menuWrapper.add_widget(menuInside)
#srodkowa czesc
if(i==1):
scrollView = ScrollView(bar_margin=10, bar_color=[1,1,1,1])
#pragma mark padding narzucony w srodkowym menu
menuInside = GridLayout(cols=4, row_default_height=40,size_hint_y=None,padding=[50,0,0,0])
menuInside.bind(minimum_height=menuInside.setter('height'))
self.menuCenterWrapper = menuInside;
self.buildCenterMenu(menuInside)
scrollView.add_widget(menuInside)
menuWrapper.add_widget(scrollView)
#menu po prawej
if(i==2):
menuInside = BoxLayout(orientation="vertical")
gridWrapper = GridLayout(cols=2)
#liczba przedzialow
s = Slider(min=0, max=10, value=5, step=1)
s.value = 10
numberOfIntervalsBaseString = Constant("Liczba przedzialow:",1)
textNumberOfIntervalsBaseString = "{0} {1}".format(numberOfIntervalsBaseString.value, s.value)
l = Label(text=textNumberOfIntervalsBaseString, halign="center")
gridWrapper.add_widget(l)
s.bind(value=partial(self.sliderValueChanged,l,numberOfIntervalsBaseString))
gridWrapper.add_widget(s)
#wartosc min delklaracja
minSlider = Slider(min=0, max=100, value=5, step=1)
#wartosc max deklaracja
maxSlider = Slider(min=0, max=100, value=5, step=1)
#wartosc min cd
minSlider.value = 0
textMinBaseString = Constant("Wartosc min\nuzytkownika:",2)
textMinString = "{0} {1}".format(textMinBaseString.value, minSlider.value)
min = Label(text=textMinString, halign="center")
gridWrapper.add_widget(min)
minSlider.bind(value=partial(self.sliderValueChanged,min,textMinBaseString, maxSlider))
gridWrapper.add_widget(minSlider)
#wartosc max cd
maxSlider.value = 100
textMaxBaseString = Constant("Wartosc max\nuzytkownika:",3)
textMaxString = "{0} {1}".format(textMaxBaseString.value, maxSlider.value)
max = Label(text=textMaxString, halign="center")
gridWrapper.add_widget(max)
maxSlider.bind(value=partial(self.sliderValueChanged,max,textMaxBaseString, minSlider))
gridWrapper.add_widget(maxSlider)
#skok dla przedzialu
s = Slider(min=0, max=10, value=5, step=.1)
s.value = 0
textJumpBaseString = Constant("Szerokosc przedzialu:",4)
textJump = "{0} {1}".format(textJumpBaseString.value, s.value_normalized)
j = Label(text=textJump, halign="left")
s.bind(value=partial(self.sliderValueChanged,j,textJumpBaseString))
gridWrapper.add_widget(j)
gridWrapper.add_widget(s)
# Normalizacja zmiennych rzeczywistych ( (wartosc-srednia)/odchylenie_standardowe)
b = Button(text="Normalizacja danych", on_press=self.buttonCallback)
gridWrapper.add_widget(b)
z = Button(text="Zamiana danych tekstowych\nna numeryczne", halign='center')
gridWrapper.add_widget(z)
menuInside.add_widget(gridWrapper);
menuWrapper.add_widget(menuInside)
layout.add_widget(menuWrapper)
return layout
# create ScreenManager as root, put all screens into
sm = ScreenManager()
sm.transition = SlideTransition()
screens = []
# load kv files
Builder.load_file('screens.kv')
class DefaultScreen(Screen):
# DefaultScreen, other screen should be subclass of DefaultScreen
pass
class MainScreen(DefaultScreen):
# main menu on startup
pass
class CartApp(App):
# main app
def build(self):
return sm
if __name__ == '__main__':
app = CartApp()
screens.append(MainScreen())
sm.switch_to(screens[-1])
app.run()
class DemoApp(App, CustomerDataUtility):
def __init__(self, eventGroup, queue, **kwargs):
super(DemoApp, self).__init__(**kwargs)
self.m_event = eventGroup
self.m_queue = queue
def sendDataEventToPrinter(self, dbtype, params):
self.m_queue.put(dbtype)
self.m_queue.put(params)
self.m_event.set()
return True
def build(self):
self.m_sm = ScreenManager(transition=WipeTransition())
self.switchScreen("home", transition=WipeTransition())
Window.bind(on_key_down=self.key_action)
return self.m_sm
def switchScreen(self, screenName, transition):
if(screenName == "home"):
self.switchToHomeScreen(transition)
elif(screenName == "mainMenu"):
self.switchToMainMenuScreen(transition)
elif(screenName == "firstCollectionMenu"):
self.switchToFirstCollectionScreen(transition)
elif(screenName == "CustomerMenu"):
self.switchToCustomerWidgetScreen(transition)
elif(screenName == "CustomerDb"):
self.switchToCustomerDbScreen(transition)
elif(screenName == "SignUp"):
self.switchToSignUpScreen(transition)
def switchToHomeScreen(self, transition):
home = Builder.load_file('HomePage.kv')
homeScreen = CustomScreen(name='home')
homeScreen.add_widget(home)
self.m_sm.switch_to(homeScreen, transition=transition, duration=0.3)
def switchToMainMenuScreen(self, transition):
navbar = Builder.load_file('navBarMain.kv')
root = Builder.load_file('root.kv')
root.navBar.add_widget(navbar)
layout1 = Builder.load_file('layout.kv')
layout2 = Builder.load_file('layout2.kv')
root.boxes.add_widget(layout1)
root.boxes.add_widget(layout2)
mainMenuScreen = CustomScreen(name='mainMenu')
mainMenuScreen.add_widget(root)
self.m_sm.switch_to(mainMenuScreen, transition=transition, duration=0.3)
def switchToFirstCollectionScreen(self, transition):
navbar = Builder.load_file('navBarSubMenu.kv')
navbar.MenuName = 'Collection Menu'
navbar.Icon = './images/operationsOutbound.png'
navbar.ColorMenuIcon = [0, 1, 0, 0.8]
firstCollectWidget = Builder.load_file('firstCollectionMenu.kv')
firstCollectWidget.navBar.add_widget(navbar)
firstCollectionScreen = CustomScreen(name='firstCollectionMenu')
firstCollectionScreen.add_widget(firstCollectWidget)
self.m_sm.switch_to(firstCollectionScreen, transition=transition, duration=0.3)
def switchToCustomerWidgetScreen(self, transition):
navbar = Builder.load_file('navBarSubMenu.kv')
navbar.MenuName = 'Operation Inbound'
navbar.Icon = './images/union.png'
navbar.ColorMenuIcon = [0, 1, 0, 0.8]
CustomerWidget = Builder.load_file('Customer.kv')
CustomerWidget.navBar.add_widget(navbar)
CustomerWidgetScreen = CustomScreen(name='CustomerMenu')
CustomerWidgetScreen.add_widget(CustomerWidget)
self.m_sm.switch_to(CustomerWidgetScreen, transition=transition, duration=0.3)
def switchToCustomerDbScreen(self, transition):
navbar = Builder.load_file('navBarSubMenu.kv')
navbar.MenuName = 'Inbound-Customer'
navbar.Icon = './images/reports6.png'
navbar.ColorMenuIcon = [0, 1, 0, 0.8]
CustomerDbWidget = Builder.load_file('CustomerDatabaseScreen.kv')
CustomerDbWidget.navBar.add_widget(navbar)
CustomerDbWidgetScreen = CustomScreen(name='CustomerDb')
CustomerDbWidgetScreen.add_widget(CustomerDbWidget)
self.m_sm.switch_to(CustomerDbWidgetScreen, transition=transition, duration=0.3)
def switchToSignUpScreen(self, transition):
SignUpWidget = Builder.load_file('SignUp.kv')
SignUpScreen = Screen(name='SignUp')
SignUpScreen.add_widget(SignUpWidget)
self.m_sm.switch_to(SignUpScreen, transition=transition, duration=0.3)
def key_action(self, *args):
# app.root.
print("got a key event: ", args[2], args[3])
app = App.get_running_app()
isPopupOpen = False
for widget in app.root_window.children:
if isinstance(widget, Popup):
isPopupOpen = True
if (args[2] == 53 and (isPopupOpen == False)):
if (app.root.current_screen.children[0].firstFocusWidget is not None):
app.root.current_screen.children[0].firstFocusWidget.focus = True
else:
navbar = app.root.current_screen.children[0].navBar
if (navbar is not None and navbar.children[0] is not None):
numChildren = len(navbar.children[0].children)
navbar.children[0].children[numChildren - 1].focus = True
class SystemyWspomaganiaDecyzji(App):
def __init__(self):
super(SystemyWspomaganiaDecyzji, self).__init__()
self.sharedInstance = ManagerPlikow()
self.menuLeftWrapper = None
self.meuCenterWrapper = None
self.checkBoxesPlotBind = {}
# def on_start(self):
#Window.bind(on_key_down=self.on_key_down)
def on_key_down(self, win, key, scancode, string, modifiers):
print(win.size, key)
if key == 102: # 'f'
normalsize = [
Config.getint('graphics', 'width'),
Config.getint('graphics', 'height')
]
if (win._size == normalsize):
win._size = [1440, 900]
else:
win._size = normalsize
win.toggle_fullscreen()
win.update_viewport()
return True
def getLeftWrapper(self):
return self.me
def pokazWyborPliku(self, animated, instance, *args):
modalType = 1
anim = None
#modal animation
if (animated):
anim = Animation(size=(640, 480), duration=0.5)
#modal frame size
size = (240, 160)
if (anim == None):
size = (640, 480)
else:
#TODO:
pass
self.modalView = ModalView(size_hint=(None, None), size=size)
self.modalView.add_widget(self.sharedInstance.przegladajDysk())
#paramter in the method call, will perform some basic slace animation
if (animated):
anim.start(self.modalView)
self.modalView.open()
def pokazDodanieAtrybutu(self):
view = ModalView(size_hint=(None, None), size=(640, 480))
view.open()
return view
def pokazDodanieObiektu(self, *args):
view = ModalView(size_hint=(None, None), size=(640, 480))
box = BoxLayout(orientation="vertical", spacing=10)
scrollView = ScrollView(bar_margin=10, bar_color=[1, 1, 1, 1])
viewWrapper = GridLayout(cols=2,
row_default_height=40,
size_hint_y=None,
padding=[-20, 20, 20, 20])
viewWrapper.bind(minimum_height=viewWrapper.setter('height'))
listaTextBoxow = []
for i in range(len(self.sharedInstance.data.temp)):
l = Label(text=self.sharedInstance.data.temp[i],
halign="left",
width=50)
#textPlaceHolder = 'Tutaj wpisz wartosc dla {0}'.format(self.sharedInstance.data.temp[i])
#textPlaceHolder,multiline=False, )
textinput = TextInput(multiline=False, text="0", focus=True)
listaTextBoxow.append(textinput)
viewWrapper.add_widget(l)
viewWrapper.add_widget(textinput)
#background_color=[51/255.0, 181.0/255, 229/255.0,1]
scrollView.add_widget(viewWrapper)
box.add_widget(scrollView)
box.add_widget(
Button(text='Dodaj',
font_size=14,
on_press=partial(self.dodajObiekt, view, listaTextBoxow),
size_hint=(1, .1)))
view.add_widget(box)
view.open()
return view
def dodajObiekt(self, view, lista, *args):
self.sharedInstance.data.dodajNowyWiersz(
[element.text for element in lista])
view.dismiss()
def setOrientation(self, orient):
self.orient = orient
def onPressCallback(self, instance):
self.pokazWyborPliku(instance, False)
def onPressGraphConsoleSwitch(self, instance):
if (instance.text == "Konsola"):
instance.text = "Graf"
self.sm.switch_to(self.console, direction='up')
elif (instance.text == "Graf"):
instance.text = "Konsola"
self.sm.switch_to(self.graphScreen, direction='down')
def checkBoxCallback(self, instance, value, *args):
if (value == False):
self.graphScreen.getGraph().remove_plot(
app.checkBoxesPlotBind[instance])
else:
self.graphScreen.getGraph().add_plot(
app.checkBoxesPlotBind[instance])
self.graphScreen.getGraph()._redraw_all
def buttonCallback(self, instance):
for plot in self.graphScreen.getGraph().plots:
plot.points = []
poNormalizacji = {}
for property in self.sharedInstance.data.temp:
poNormalizacji[property] = self.sharedInstance.data.normalizacja(
property)
for property in poNormalizacji:
points = []
lista = poNormalizacji[property]
i, j = 0
pprint.pprint(lista)
for j in range(len(lista)):
points.append((i, lista[j]))
i += 1
pprint.pprint(points)
# for plot in self.graph.plots:
# plot.points = points
self.graph.ymax = 10
self.graph.ymin = -10
def buildCenterMenu(self, wrapper, rebuild=False):
if (rebuild): wrapper.clear_widgets()
numberOfItems = len(self.sharedInstance.data.temp
) if self.sharedInstance.data.temp else 0
for i in range(0, numberOfItems):
checkbox = CheckBox(active=True)
checkbox.bind(active=app.checkBoxCallback)
self.checkBoxesPlotBind[checkbox] = self.graphScreen.getGraph(
).plots[i]
labelText = self.sharedInstance.data.temp[
i] if self.sharedInstance.data.temp else "Nazwa atrybutu"
label = Label(text=labelText,
halign="right",
width=100,
col_default_width=20,
col_force_default=True)
wrapper.add_widget(label)
wrapper.add_widget(checkbox)
def buildLeftMenu(self, wrapper):
buttonWybierzPlik = Button(text='Wczytaj plik', font_size=14)
buttonWybierzPlik.bind(on_press=partial(self.pokazWyborPliku, False))
wrapper.add_widget(buttonWybierzPlik)
buttonDodajObiekt = Button(text='Dodaj obiekt', font_size=14)
buttonDodajObiekt.bind(on_press=partial(self.pokazDodanieObiektu))
wrapper.add_widget(buttonDodajObiekt)
buttonDodajAtrybut = Button(text='Dodaj atrybut', font_size=14)
buttonDodajAtrybut.bind(on_press=self.onPressCallback)
wrapper.add_widget(buttonDodajAtrybut)
buttonStatystyki = Button(text='Statystyki', font_size=14)
buttonStatystyki.bind(on_press=self.onPressCallback)
wrapper.add_widget(buttonStatystyki)
buttonKonsola = Button(text='Graf', font_size=14)
buttonKonsola.bind(on_press=self.onPressGraphConsoleSwitch)
wrapper.add_widget(buttonKonsola)
def sliderValueChanged(self, label, description, slider, *args):
if (description.tag == 1):
self.graphScreen.getGraph(
).x_ticks_major = 100 // args[0] if args[0] != 0.0 else 100
label.text = "{0} {1}".format(description.value, int(args[0]))
elif (description.tag == 2):
if (int(args[1]) < self.graphScreen.getGraph().xmax):
self.graphScreen.getGraph().xmin = int(args[1])
label.text = "{0} {1}".format(description.value, int(args[1]))
args[0].max = slider.value
elif (description.tag == 3):
if (int(args[1]) > self.graphScreen.getGraph().xmin):
self.graphScreen.getGraph().xmax = int(args[1])
label.text = "{0} {1}".format(description.value, int(args[1]))
args[0].min = slider.value
elif (description.tag == 4):
self.graphScreen.getGraph().x_ticks_major = int(args[0])
label.text = "{0} {1}".format(description.value, int(args[0]))
else:
raise ValueError("Wrong tag of the slider, check it.", self)
self.graphScreen.getGraph()._redraw_all()
def build(self):
self.sm = ScreenManager(transition=SlideTransition())
layout = BoxLayout(padding=20, orientation=self.orient, spacing=20)
self.graphScreen = GraphScreen()
self.console = Console(app=app)
self.sm.switch_to(self.console)
self.graph = self.graphScreen.getGraph()
layout.add_widget(self.sm)
menuWrapper = BoxLayout()
for i in range(0, 3):
#pragma mark boczne menu z lewej
if (i == 0):
menuInside = BoxLayout(orientation="vertical")
self.meuCenterWrapper = menuInside
self.buildLeftMenu(menuInside)
menuWrapper.add_widget(menuInside)
#srodkowa czesc
if (i == 1):
scrollView = ScrollView(bar_margin=10, bar_color=[1, 1, 1, 1])
#pragma mark padding narzucony w srodkowym menu
menuInside = GridLayout(cols=4,
row_default_height=40,
size_hint_y=None,
padding=[50, 0, 0, 0])
menuInside.bind(minimum_height=menuInside.setter('height'))
self.menuCenterWrapper = menuInside
self.buildCenterMenu(menuInside)
scrollView.add_widget(menuInside)
menuWrapper.add_widget(scrollView)
#menu po prawej
if (i == 2):
menuInside = BoxLayout(orientation="vertical")
gridWrapper = GridLayout(cols=2)
#liczba przedzialow
s = Slider(min=0, max=10, value=5, step=1)
s.value = 10
numberOfIntervalsBaseString = Constant("Liczba przedzialow:",
1)
textNumberOfIntervalsBaseString = "{0} {1}".format(
numberOfIntervalsBaseString.value, s.value)
l = Label(text=textNumberOfIntervalsBaseString,
halign="center")
gridWrapper.add_widget(l)
s.bind(value=partial(self.sliderValueChanged, l,
numberOfIntervalsBaseString))
gridWrapper.add_widget(s)
#wartosc min delklaracja
minSlider = Slider(min=0, max=100, value=5, step=1)
#wartosc max deklaracja
maxSlider = Slider(min=0, max=100, value=5, step=1)
#wartosc min cd
minSlider.value = 0
textMinBaseString = Constant("Wartosc min\nuzytkownika:", 2)
textMinString = "{0} {1}".format(textMinBaseString.value,
minSlider.value)
min = Label(text=textMinString, halign="center")
gridWrapper.add_widget(min)
minSlider.bind(value=partial(self.sliderValueChanged, min,
textMinBaseString, maxSlider))
gridWrapper.add_widget(minSlider)
#wartosc max cd
maxSlider.value = 100
textMaxBaseString = Constant("Wartosc max\nuzytkownika:", 3)
textMaxString = "{0} {1}".format(textMaxBaseString.value,
maxSlider.value)
max = Label(text=textMaxString, halign="center")
gridWrapper.add_widget(max)
maxSlider.bind(value=partial(self.sliderValueChanged, max,
textMaxBaseString, minSlider))
gridWrapper.add_widget(maxSlider)
#skok dla przedzialu
s = Slider(min=0, max=10, value=5, step=.1)
s.value = 0
textJumpBaseString = Constant("Szerokosc przedzialu:", 4)
textJump = "{0} {1}".format(textJumpBaseString.value,
s.value_normalized)
j = Label(text=textJump, halign="left")
s.bind(value=partial(self.sliderValueChanged, j,
textJumpBaseString))
gridWrapper.add_widget(j)
gridWrapper.add_widget(s)
# Normalizacja zmiennych rzeczywistych ( (wartosc-srednia)/odchylenie_standardowe)
b = Button(text="Normalizacja danych",
on_press=self.buttonCallback)
gridWrapper.add_widget(b)
z = Button(text="Zamiana danych tekstowych\nna numeryczne",
halign='center')
gridWrapper.add_widget(z)
menuInside.add_widget(gridWrapper)
menuWrapper.add_widget(menuInside)
layout.add_widget(menuWrapper)
return layout
print(traceback.format_exc())
self.loading = False
connectionScreen = ConnectionScreen(name="connection")
settingsScreen = SettingsScreen(name="settings")
loginScreen = LoginScreen(name="login")
mainScreen = MainScreen(name="main")
sm = ScreenManager()
sm.add_widget(connectionScreen)
sm.add_widget(settingsScreen)
sm.add_widget(loginScreen)
sm.add_widget(mainScreen)
sm.switch_to(connectionScreen)
class PasswordApp(App):
# Build
def build(self):
self._keyboard = Window.request_keyboard(self._keyboard_closed,
self.root, "text")
self._keyboard.bind(on_key_down=self._on_keyboard_down)
Window.show_cursor = False
connectionScreen.startConnect()
return sm
# Keyboard Down Event
class DekatrianApp(App):
"""Classe Principal da Aplicação"""
dataAtual = ObjectProperty(Data(date.today()))
dataSelecionada = ObjectProperty(Data(date.today()))
tela = ObjectProperty(str())
title = ObjectProperty(str())
version = __version__
def _defineBarra(self):
if plataforma.system() == 'Windows':
return '\\'
else:
return '/'
def __init__(self, version, **kwargs):
self.version = version
self._configuracaoInicial()
self._carregaKv()
super(DekatrianApp, self).__init__(**kwargs)
self._telas = [
TelaMenu(),
TelaInicial(),
TelaDekatrian(),
TelaDesenvolvimento(),
]
def _configuracaoInicial(self):
self.barra = self._defineBarra()
self.pasta_projeto = os.path.dirname(os.path.abspath(__file__))
self.pasta_imagens = self.pasta_projeto+self.barra+'img'+self.barra
Config.set('graphics', 'resizable', 0)
Config.set('kivy', 'window_icon', self.pasta_imagens + 'icon.png')
if platform != 'android':
Window.size = (360, 640)
def _carregaKv(self):
kv_path = self.pasta_projeto+self.barra+'infra'+self.barra+'view'
kvs = self._listarArquivos(".kv", kv_path)
for kv in kvs:
Builder.load_file(kv_path+self.barra+kv)
def _listarArquivos(self, ext, path):
"""Lista todos os arquivos que estão em um diretório
com a extencao definida"""
caminhos = [os.path.join(path, nome) for nome in os.listdir(path)]
arquivos = [arq for arq in caminhos if os.path.isfile(arq)]
arqFiltrados = [arq for arq in arquivos if arq.lower().endswith(ext)]
return [arq.split(self.barra)[-1] for arq in arqFiltrados]
def build(self):
barra = self._defineBarra()
pasta_projeto = os.path.dirname(os.path.abspath(__file__))
pasta_imagens = pasta_projeto+barra+'img'+barra
self.icon = pasta_imagens+'icon.png'
self.title = 'Calendario Dekatrian'
self.telaSecundaria = Button()
self.gerenciador = ScreenManager()
self._defineTela(1)
return self.gerenciador
def _defineTela(self, tela):
self.title = self._telas[tela].title
self.gerenciador.switch_to(self._telas[tela])
def mudarTela(self, tela):
if self.gerenciador.current_screen != self._telas[tela]:
if tela == 0:
self.gerenciador.transition.direction = 'right'
else:
self.gerenciador.transition.direction = 'left'
self._defineTela(tela)
def mudarTelaSecundaria(self, tela):
tela_secundaria = self.gerenciador.current_screen.ids.tela_secundaria
tela_secundaria.remove_widget(self.telaSecundaria)
self.telaSecundaria = tela()
tela_secundaria.add_widget(self.telaSecundaria)
@property
def tela_menu(self):
return 0
@property
def tela_inicial(self):
return 1
@property
def tela_dekatrian(self):
return 2
@property
def tela_desenvolvimento(self):
return 3
class TeachYourselfApp(App):
def build(self):
self.points = 0
self.db = Database()
self.screenManager = ScreenManager()
self.registerScreen = RegisterScreen()
self.loginScreen = LoginScreen()
self.loadingScreen = LoadingScreen()
self.selectScreen = SelectScreen()
self.classesScreen = ClassesScreen()
self.homeScreen = HomeScreen()
self.screenManager.add_widget(self.loadingScreen)
self.screenManager.add_widget(self.registerScreen)
self.screenManager.add_widget(self.selectScreen)
self.screenManager.add_widget(self.loginScreen)
self.screenManager.add_widget(self.classesScreen)
self.screenManager.add_widget(self.homeScreen)
return self.screenManager
#ezek itt a screenvaltoztatgato metodusok
def switchScreenSelect(self):
self.screenManager.switch_to(self.selectScreen)
def switchScreenLogin(self):
self.screenManager.switch_to(self.loginScreen)
def switchScreenLogin(self, app):
self.screenManager.switch_to(self.loginScreen)
def switchScreenRegister(self, app):
self.screenManager.switch_to(self.registerScreen)
def switchScreenHome(self):
self.screenManager.switch_to(self.homeScreen)
def switchScreenHome(self, app):
self.screenManager.switch_to(self.homeScreen)
def switchScreenClasses(self):
self.screenManager.switch_to(self.classesScreen)
def switchScreenResult(self):
self.screenManager.switch_to(self.resultScreen)
def exit(self, app):
self.stop()
def on_start(self):
if True:
Clock.schedule_once(self.switchScreenLogin, 2)
class StudentPortal(MDApp):
title = "Student Portal"
icon = 'icon.ico'
use_kivy_settings = False
color_theme = 'dark'
bg_color = ListProperty([29 / 255, 29 / 255, 29 / 255, 1])
tile_color = ListProperty([40 / 255, 40 / 255, 40 / 255, 1])
raised_button_color = ListProperty([52 / 255, 52 / 255, 52 / 255, 1])
text_color = ListProperty([1, 1, 1, 1])
title_text_color = ListProperty([1, 1, 1, 1])
accent_color = ListProperty([0.5, 0.7, 0.5, 1])
app_font = StringProperty(
resource_path(
os.path.join(
'data',
'fonts',
'Code2000',
'CODE2000.ttf')))
cursor_width = NumericProperty(3)
home_icon = StringProperty('home')
home_icon_tooltip = StringProperty('Back')
add_icon = StringProperty('plus-circle-outline')
add_icon_tooltip = StringProperty('Create new')
search_icon = StringProperty('magnify')
search_icon_tooltip = StringProperty('Search')
def open_settings(self, *largs):
self.mainmenu.ids.settings_button.trigger_action()
def build(self):
self.themes = {
'dark': self.color_theme_dark,
'light': self.color_theme_light,
'rgb': self.color_theme_rgb,
'custom': None
}
self.transitions = {
'slide': SlideTransition,
'wipe': WipeTransition,
'fade': FadeTransition,
'fall out': FallOutTransition,
'none': NoTransition
}
if getattr(sys, 'frozen', False):
from app.screens import mainmenu, wikipedia, notebook, translation, youtube, todo, books, settings, about
else:
from screens import mainmenu, wikipedia, notebook, translation, youtube, todo, books, settings, about
self.user_settings = settings.SettingsBackend().show_settings()
self.root = ScreenManager()
self.mainmenu = mainmenu.MainMenu()
self.wikipedia = wikipedia.Wikipedia()
self.notebook = notebook.Notebook()
self.translation = translation.Translation()
self.youtube = youtube.Youtube()
self.todo = todo.ToDo()
self.books = books.Books()
self.settings = settings.Settings()
self.about = about.About()
self.screens = {
'mainmenu': self.mainmenu,
'wikipedia': self.wikipedia,
'notebook': self.notebook,
'translation': self.translation,
'youtube': self.youtube,
'todo': self.todo,
'books': self.books,
'settings': self.settings,
'about': self.about
}
self.themes['custom'] = self.settings.color_theme_custom
self.root.switch_to(self.mainmenu)
try:
self.root.transition = self.transitions.get(
self.user_settings.get('page_transition'))()
except BaseException:
self.root.transition = SlideTransition()
self.themes.get(self.user_settings.get('theme'))()
Window.show()
return self.root
def switch_screen(self, screen_name, direction='left'):
self.root.transition.direction = direction
self.root.switch_to(self.screens.get(screen_name))
def color_theme_dark(self):
self.color_theme = 'dark'
try:
Animation.cancel_all(self)
except BaseException:
pass
self.bg_color = [29 / 255, 29 / 255, 29 / 255, 1]
self.tile_color = [40 / 255, 40 / 255, 40 / 255, 1]
self.raised_button_color = [52 / 255, 52 / 255, 52 / 255, 1]
self.text_color = [1, 1, 1, 1]
self.title_text_color = [1, 1, 1, 1]
self.accent_color = [0.5, 0.7, 0.5, 1]
def color_theme_light(self):
self.color_theme = 'light'
try:
Animation.cancel_all(self)
except BaseException:
pass
self.bg_color = [0.989, 0.989, 0.989, 1.0]
self.tile_color = [0.94, 0.94, 0.94, 1.0]
self.raised_button_color = [0.823, 0.823, 0.823, 1.0]
self.text_color = [0.0, 0.0, 0.0, 1.0]
self.title_text_color = [0.0, 0.0, 0.0, 1.0]
self.accent_color = [0.212, 0.099, 1.0, 1.0]
def color_theme_rgb(self):
self.color_theme = 'rgb'
def update_bg_anim(self):
self.bg_color_animation = Animation(
bg_color=utils.get_random_color(), duration=4.)
self.bg_color_animation.bind(
on_complete=lambda idk,
a=self: update_bg_anim(a))
self.bg_color_animation.start(self)
update_bg_anim(self)
def update_tile_anim(self):
self.tile_color_animation = Animation(
tile_color=utils.get_random_color(), duration=4.)
self.tile_color_animation.bind(
on_complete=lambda idk, a=self: update_tile_anim(a))
self.tile_color_animation.start(self)
update_tile_anim(self)
def update_raised_button_anim(self):
self.raised_button_color_animation = Animation(
raised_button_color=utils.get_random_color(), duration=4.)
self.raised_button_color_animation.bind(
on_complete=lambda idk, a=self: update_raised_button_anim(a))
self.raised_button_color_animation.start(self)
update_raised_button_anim(self)
def update_text_anim(self):
self.text_color_animation = Animation(
text_color=utils.get_random_color(), duration=4.)
self.text_color_animation.bind(
on_complete=lambda idk, a=self: update_text_anim(a))
self.text_color_animation.start(self)
update_text_anim(self)
def update_title_text_anim(self):
self.title_text_color_animation = Animation(
title_text_color=utils.get_random_color(), duration=4.)
self.title_text_color_animation.bind(
on_complete=lambda idk, a=self: update_title_text_anim(a))
self.title_text_color_animation.start(self)
update_title_text_anim(self)
def update_accent_anim(self):
self.accent_color_animation = Animation(
accent_color=utils.get_random_color(), duration=4.)
self.accent_color_animation.bind(
on_complete=lambda idk, a=self: update_accent_anim(a))
self.accent_color_animation.start(self)
update_accent_anim(self)
def color_theme_custom(self, user_settings):
self.color_theme = 'custom'
try:
Animation.cancel_all(self)
except BaseException:
pass
self.bg_color = user_settings.get('bg_color') if len(
user_settings.get('bg_color')) == 4 else [
29 / 255, 29 / 255, 29 / 255, 1]
self.tile_color = user_settings.get('tile_color') if len(
user_settings.get('tile_color')) == 4 else [
40 / 255, 40 / 255, 40 / 255, 1]
self.raised_button_color = user_settings.get('raised_button_color') if len(
user_settings.get('raised_button_color')) == 4 else [
52 / 255, 52 / 255, 52 / 255, 1]
self.text_color = user_settings.get('text_color') if len(
user_settings.get('text_color')) == 4 else [1, 1, 1, 1]
self.title_text_color = user_settings.get('title_text_color') if len(
user_settings.get('title_text_color')) == 4 else [1, 1, 1, 1]
self.accent_color = user_settings.get('accent_color') if len(
user_settings.get('accent_color')) == 4 else [0.5, 0.7, 0.5, 1]
def transition_changed(self, user_settings):
try:
self.root.transition = self.transitions.get(
user_settings.get('page_transition'))()
except BaseException:
self.root.transition = SlideTransition()
class ChatBot(MDApp):
name = "Chat Bot"
theme = 'Light'
bg_color = ColorProperty([0.97, 0.97, 0.97, 1])
text_color = ColorProperty([0, 0, 0, 1])
def build(self):
self.title = "Bitbot"
self.app_settings_folder = os.path.join(getattr(self, 'user_data_dir'),
'database')
self.app_settings = os.path.join(self.app_settings_folder,
'config.json')
self.logger = Logger
from screens.home import home
from screens.chat import chat
self.root = ScreenManager()
self.home = home.Home()
self.chat = chat.Chat()
self.screens = {
"home": self.home,
"chat": self.chat,
}
self.screen_history = []
Window.bind(on_key_up=self.back_button)
Window.softinput_mode = "below_target"
self.root.transition = NoTransition()
self.get_theme()
self.switch_screen("home")
def on_pause(self):
self.set_theme()
def on_stop(self):
self.set_theme()
def switch_screen(self, screen_name):
self.root.switch_to(self.screens.get(screen_name))
self.screen_history.append(screen_name)
def back_button(self, instance, keyboard, *args):
if keyboard in (1001, 27):
self.screen_history.pop()
if self.screen_history != []:
self.root.switch_to(self.screens.get(self.screen_history[-1]))
else:
self.stop()
return True
def get_theme(self):
if os.path.exists(self.app_settings):
try:
with open(self.app_settings, 'r') as fp:
self.theme = json.load(fp).get("theme")
except BaseException as e:
self.logger.error(e)
else:
if not os.path.isdir(self.app_settings_folder):
os.makedirs(self.app_settings_folder)
self.set_theme()
if self.theme == "Dark":
self.home.ids.theme_switch.active = True
elif self.theme == "Light":
pass
def set_theme(self):
try:
with open(self.app_settings, 'w+') as fp:
json.dump({"theme": self.theme}, fp)
except BaseException as e:
self.logger.error(e)
@staticmethod
def resource_path(relative_path):
try:
base_path = sys._MEIPASS
except Exception:
base_path = os.path.abspath(os.path.dirname(sys.argv[0]))
return os.path.join(base_path, relative_path)
def build(self):
sm = ScreenManager()
oMenu = startmenu.CStartMenu(name=define.START_MENU)
sm.switch_to(oMenu)
return sm
return second
class WindowManager(ScreenManager):
pass
#this loads the kivy code file with the GUI customizations
loading = Builder.load_file("my.kv")
screens = [
OpeningScreen(name="opening"),
MainWindow(name="main"),
RecordingWindow(name="recording"),
HostPlayersChoiceWindow(name="playeramountchoice"),
TeamChoiceWindow(name='teamchoice')
]
kv = ScreenManager(transition=SwapTransition())
#sets first screen to open
kv.switch_to(screens[0])
#complies app
class MyMainApp(App):
def build(self):
return kv
if __name__ == "__main__":
MyMainApp().run()
class OSPApp(MDApp):
def __init__(self):
super().__init__()
self.myfirebase = MyFirebase()
self.dialog = MDDialog()
self.report = ""
self.theme_cls.primary_palette = 'Red'
self.start_screen = StartScreen(self)
self.menu_screen = MenuScreen(self)
self.screen_manager = ScreenManager()
def build(self):
self.screen_manager.switch_to(self.start_screen.start_screen)
return self.screen_manager
def change_screen(self, name):
self.screen_manager.current = name
def change_to_start(self):
self.screen_manager.switch_to(self.start_screen.start_screen)
def change_to_login(self):
self.start_screen.make_login()
self.screen_manager.switch_to(self.start_screen.log_in_screen)
def change_to_second_menu(self):
self.screen_manager.switch_to(self.menu_screen.screen)
def change_to_sign_up(self):
self.screen_manager.switch_to(self.start_screen.sign_up_screen)
def change_to_log(self, obj):
self.screen_manager.switch_to(self.start_screen.log_in_screen)
self.dialog.dismiss()
def show_snackbar(self, text):
Snackbar(text=text,
snackbar_x="10dp",
snackbar_y="10dp",
size_hint_x=(Window.width - (dp(10) * 2)) /
Window.width).open()
def close_dialog(self, obj):
self.dialog.dismiss()
