class CellAutomatonApp(App):
modes = {
"Main Menu": "MainController",
"Binary Rule": "BinaryRuleSetController",
"Game of Life": "GameOfLifeController",
"Nucleation": "NucleationController"
}
def __init__(self):
super(CellAutomatonApp, self).__init__()
Window.clearcolor = (0.2, 0.2, 0.2, 1)
Window.size = (1150, 700)
Window.top = 75
Window.left = 200
def build(self):
self.root = BoxLayout()
self.view = BaseView(MainController.modes, 150)
self.set_view(self.view)
self.controller = MainController(self)
return self.root
def set_view(self, view):
self.view = view
self.root.clear_widgets()
self.root.add_widget(view)
def set_controller(self, mode):
self.controller = eval(self.modes[mode])(self)
def get_modes(self):
return self.modes
class DataGrid(BoxLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.orientation = 'vertical'
self._header = BoxLayout()
self._header.size_hint_y = None
self._header.height = dp(40)
self._header.orientation = 'horizontal'
self.add_widget(self._header)
self._rows = DataGridRows()
self.add_widget(self._rows)
def set_header(self, *headers):
self._header.clear_widgets()
for header in headers:
self._header.add_widget(Label(text=header))
with self._header.canvas.before:
Color(0.5, 0.5, 0.5, 1)
Rectangle(pos=self._header.pos, size=self._header.size)
def clear_data(self):
self._rows.data = []
def add_row(self, *rows):
if self._rows.data is None:
self._rows.data = []
for row in rows:
self._rows.data.append({"data": row})
def next_label(self):
global list_tasks
global list_completed
global check_ref_box
global whole_box
lay = BoxLayout(orientation='vertical',
size=self.size,
size_hint=(1, .4),
pos_hint={
'center_x': .4,
'center_y': .5
})
lay.clear_widgets()
for i, task in enumerate(list_tasks):
layout = BoxLayout(orientation="horizontal",
size_hint=(.5, 1),
pos_hint={
'center_x': .5,
'center_y': .5
})
check_ref_box.append(layout)
check = CheckBox()
self.check_ref[f'checkbox_{i}'] = [check, task]
check.bind(active=lambda checkid, checkval: on_checkbox_active(
self.check_ref))
layout.add_widget(check)
layout.add_widget(Label(text=task, color=(1, 1, 1, 1)))
lay.add_widget(layout)
self.add_widget(lay)
event_3 = Clock.create_trigger(self.speaker_end,
timeout=1,
interval=False)
event_3()
whole_box = lay
class GUI:
root = None
_properties = None
_window = None
def __init__(self, kvFile):
self.root = BoxLayout()
Builder.load_file(kvFile)
self._properties = {}
def setWindow(self, window):
self.root.clear_widgets()
self._window = window()
self._window.setProperty(self._properties)
self.root.add_widget(self._window)
def getWindow(self):
return self._window.__class__
def setProperty(self, key, value):
self._properties[key] = value
if self._window <> None: self._window.setProperty({key:value})
def getProperty(self, key):
return self._properties[key]
class NyanCell(BoxLayout):
def __init__(self, nyan_pos):
super().__init__()
# self.width, self.height = SK.CELL_WIDTH, SK.CELL_HEIGHT
self.angle = 0
self.cell_x, self.cell_y = nyan_pos
self.orientation = "vertical"
self.status_label = Label(
text="[size=12]" + "cell x:" + str(self.cell_x) + " y:" + str(self.cell_y) + "[/size]",
markup=True,
size_hint_y=1,
)
# self.add_widget(self.status_label)
self.space = BoxLayout(size_hint_y=8, background_normal="", background_color=(0.5, 0.9, 0.1, 1))
self.add_widget(self.space)
def check_updates(self, stater):
# with self.canvas.before:
# Color(0, 0, 0)
# br = 1
# self.rect = Rectangle(x=self.x + br, y=self.y + br, width=self.width - 2 * br,
# height=self.height - 2 * br)
self.space.clear_widgets()
if stater.hunter_p is not None and self.cell_x == stater.hunter_p[0] and self.cell_y == stater.hunter_p[1]:
if stater.cat_direction in [CM.RIGHT, CM.UP, CM.LEFT, CM.DOWN]:
angle = 90 * [CM.RIGHT, CM.UP, CM.LEFT, CM.DOWN].index(stater.cat_direction)
self.space.add_widget(NyanArrow(nyan_angle=angle, source="helpers/images/arrow.png"))
self.space.add_widget(Label(text=stater.cat_direction))
if stater.cat_p is not None and self.cell_x == stater.cat_p[0] and self.cell_y == stater.cat_p[1]:
self.space.add_widget(Image(source="helpers/images/min_cat.png"))
class RevealedAnswersBox(BoxLayout):
expected_answers_in_latex = DictProperty({'x_placeholder': 'placeholder'})
reveal_button = ObjectProperty()
answers_input_box = ObjectProperty()
check_answers_button = ObjectProperty()
def __init__(self, **kwargs):
super(RevealedAnswersBox, self).__init__(**kwargs)
self.latex_widg = LatexWidget()
self.special_answer_label = Label()
self.main_content_box = BoxLayout(orientation='vertical')
self.main_content_box.add_widget(
Label(text=languages.CORRECT_ANSWER_IS_MSG))
self.main_label_box = BoxLayout()
self.main_content_box.add_widget(self.main_label_box)
self.user_reaction_options_box = UserReactionToRevealedAnswersBox()
self.user_reaction_options_box.ids.ok_button.bind(
on_release=self.on_ok_button_release)
self.main_content_box.add_widget(self.user_reaction_options_box)
def _main_label(self):
special_found = set(arbitrary_pieces.SPECIAL_ANSWERS_TYPES) & set(
self.expected_answers_in_latex.values())
if special_found:
w = self.special_answer_label
w.text = list(special_found)[0].long_description
else:
w = self.latex_widg
w.text = self.all_answers_as_latex_str()
return w
def create_main_label(self, *args):
self.main_label_box.clear_widgets()
self.main_label_box.add_widget(self._main_label())
def show_main_content(self, *args):
self.clear_widgets()
self.create_main_label()
self.add_widget(self.main_content_box)
def all_answers_as_latex_str(self):
non_latex_s = ''
for a_name in sorted(self.expected_answers_in_latex):
a_val = self.expected_answers_in_latex[a_name]
# (simply places "z=" at the start;
# different type of answers would need different implementation elsewhere too)
if non_latex_s:
non_latex_s += ', '
non_latex_s += ANSWER_KEY_EQUALS.format(a_name) + r'{}'.format(
a_val.strip('$'))
return '${}$'.format(non_latex_s)
def on_ok_button_release(self, *args):
self.clear_widgets()
self.add_widget(Label())
self.reveal_button.disabled = False
self.check_answers_button.disabled = False
self.answers_input_box.disabled = False
app.root.exercise = exercises.SolveForXLinear(difficulty=2)
class AnswersInputBox(BoxLayout):
exercise = ObjectProperty()
answers_given = DictProperty()
def __init__(self, **kwargs):
super(AnswersInputBox, self).__init__(**kwargs)
self.textinputs_box = BoxLayout(orientation='vertical', padding='3sp')
self.textinputs_lst = []
self.add_widget(self.textinputs_box)
self.specials_buttons_box = BoxLayout(orientation='vertical',
size_hint_x=.3)
self.add_widget(self.specials_buttons_box)
Clock.schedule_once(self.populate_textinputs_box, .5)
Clock.schedule_once(self.populate_specials_buttons_box, .5)
def set_input_text_to_answer(self, *args):
obj = args[0]
self.answers_given[obj.answer_name] = obj.text
def populate_textinputs_box(self, *args):
self.textinputs_box.clear_widgets()
self.textinputs_lst = []
for answer_name in self.exercise.expected_answers:
box = BoxLayout(size_hint_y=None, height=STANDARD_BUTTON_HEIGHT)
self.textinputs_box.add_widget(box)
label_text = ANSWER_KEY_EQUALS.format(answer_name)
box.add_widget(Label(text=label_text, size_hint_x=.2))
t_input = TextInput(hint_text=languages.TYPE_ANSWER_PROMPT_MSG,
multiline=False)
t_input.answer_name = answer_name
t_input.bind(text=self.set_input_text_to_answer)
box.add_widget(t_input)
self.textinputs_lst.append(t_input)
def set_special_answer_to_answers(self, *args):
obj = args[0]
# (text must be changed first otherwise answers will change twice `on_text`)
for i in self.textinputs_lst:
i.text = ''
for a in self.answers_given:
self.answers_given[a] = obj.special_val_
def populate_specials_buttons_box(self, *args):
self.specials_buttons_box.clear_widgets()
for a_class in self.exercise.special_answers_allowed:
b = Button(text=a_class.button_text,
size_hint_y=None,
height=STANDARD_BUTTON_HEIGHT)
b.special_val_ = a_class
b.bind(on_release=self.set_special_answer_to_answers)
self.specials_buttons_box.add_widget(b)
def populate_everything(self, *args):
self.populate_textinputs_box()
self.populate_specials_buttons_box()
def on_exercise(self, *args):
self.populate_everything()
class MainWindow(BoxLayout):
def __init__(self, **kwargs):
kwargs['orientation'] = 'vertical'
super(MainWindow, self).__init__(**kwargs)
spinner = Spinner(
# default value shown
text='Home',
# available values
values=('Home', 'Test', 'AddWord'),
# just for positioning in our example
size_hint=(1, None),
size=(100, 44),
pos_hint={
'center_x': .5,
'center_y': .5
})
spinner.bind(text=self.set_page_vidget)
self.add_widget(spinner)
self.work_area = BoxLayout()
self.work_area.add_widget(Home())
self.add_widget(self.work_area)
def set_page_vidget(self, _, name):
self.work_area.clear_widgets()
vidget = globals()[name]
self.work_area.add_widget(vidget())
class MainWindow(BoxLayout):
def __init__(self, **kwargs):
kwargs['orientation'] = 'vertical'
super(MainWindow, self).__init__(**kwargs)
spinner = Spinner(
# default value shown
text='Home',
# available values
values=('Home', 'Test', 'AddWord'),
# just for positioning in our example
size_hint=(1, None),
size=(100, 44),
pos_hint={'center_x': .5, 'center_y': .5})
spinner.bind(text=self.set_page_vidget)
self.add_widget(spinner)
self.work_area = BoxLayout()
self.work_area.add_widget(Home())
self.add_widget(self.work_area)
def set_page_vidget(self, _, name):
self.work_area.clear_widgets()
vidget = globals()[name]
self.work_area.add_widget(vidget())
class DatePicker(BoxLayout):
def __init__(self, **kwargs):
super(DatePicker, self).__init__(**kwargs)
self.date = date.today()
self.orientation = "vertical"
self.header = BoxLayout(orientation='horizontal', size_hint=(1, 0.2))
self.body = GridLayout(cols=7)
self.add_widget(self.header)
self.add_widget(self.body)
self.populate_body()
self.populate_header()
def populate_header(self):
self.header.clear_widgets()
self.previous_month = Button(text="<")
self.next_month = Button(text=">")
self.current_month = Label(text=repr(self.date), size_hint=(2, 1))
self.header.add_widget(self.previous_month)
self.header.add_widget(self.current_month)
self.header.add_widget(self.next_month)
def populate_body(self):
self.body.clear_widgets()
date_cursor = date(self.date.year, self.date.month, 1)
while date_cursor.month == self.date.month:
self.date_label = Label(text=str(date_cursor.day))
self.body.add_widget(self.date_label)
date_cursor += timedelta(days=1)
def createPopupWidget2(sm,dictOfStatus,size): mainBox = BoxLayout(orientation='vertical',id="mainBox") mainBox.clear_widgets() label = Label(text='Completed',color=(1,0,0,1),size_hint=(1,.3),id="label") mainBox.add_widget(label) for eachScript in dictOfStatus: textContent = "Filename containing scripts: " + os.path.basename(eachScript) + '\n' + "Total number of scripts generated: " + str((dictOfStatus[eachScript])[2]) +'\n' +"Number of Scripts that ran to success: " + str((dictOfStatus[eachScript])[0]) + '\n' + "Number of Scripts that did not run: " + str((dictOfStatus[eachScript])[1]) + '\n\n' labelScript = Label(text=textContent,multiline=True,color=(1,0,0,1)) mainBox.add_widget(labelScript) innerButtonControlBox = BoxLayout(orientation='horizontal', size_hint=(1,.25)) btn_ok = Button(text='Ok. Take me back to Run Control Screen',background_color=(1,0,0,1), size_hint=(.6,1)) btn_cancel = Button(text='Cancel',background_color=(1,0,0,1),size_hint=(.2,1)) innerButtonControlBox.add_widget(btn_ok) innerButtonControlBox.add_widget(btn_cancel) mainBox.add_widget(innerButtonControlBox) popup1 = Popup(title='Status of test suits run screen', content=mainBox, size_hint=(None,None), size=size, auto_dismiss=False) btn_ok.bind(on_press=popup1.dismiss) btn_ok.bind(on_press=Par(backApp1,sm)) btn_cancel.bind(on_press=popup1.dismiss) btn_cancel.bind(on_press=Par(backApp1,sm)) return popup1
class SideMenu(BoxLayout):
def __init__(self, map, **kwargs):
super().__init__(**kwargs)
self.width = 0
self.scrollView = ScrollView(do_scroll_y=True)
self.scrollView.clear_widgets()
self.sideMenuItems = []
self.boxView = BoxLayout(orientation="vertical", size_hint_y=None)
self.boxView.bind(minimum_height=self.boxView.setter('height'))
self.scrollView.add_widget(self.boxView)
self.add_widget(self.scrollView)
def close(self):
self.width = 0
def open(self):
self.width = 200
def up(self):
for i in range(len(self.sideMenuItems)):
if(self.sideMenuItems[i].selected and i > 0):
self.selectByIndex(i-1)
break
def down(self):
for i in range(len(self.sideMenuItems)):
if(self.sideMenuItems[i].selected and i < len(self.sideMenuItems)):
self.selectByIndex(i+1)
break
def resetColors(self):
for sideMenuItem in self.sideMenuItems:
sideMenuItem.resetColor()
def selectByIndex(self, index):
if(len(self.sideMenuItems) > index):
self.sideMenuItems[index].selectWithCallback()
def select(self, state):
for sideMenuItem in self.sideMenuItems:
if( sideMenuItem.contentState == state):
sideMenuItem.select()
def clearItems(self):
self.boxView.clear_widgets()
self.sideMenuItems = []
def addSideMenuItem(self, sideMenuItem):
self.boxView.add_widget(sideMenuItem)
self.sideMenuItems.append(sideMenuItem)
sideMenuItem.setSideMenu(self)
def clearAndAddSideMenuItems(self, sideMenuItems):
self.clearItems()
for sideMenu in sideMenuItems:
self.addSideMenuItem(sideMenu)
class PageSelection(BoxLayout):
"""The "right" widget, that is used to select which page to plot"""
cinfdata = ObjectProperty(None)
def __init__(self, **kwargs):
super(PageSelection, self).__init__(**kwargs)
self.mainbutton = Button(text='Select Setup', size_hint=(1, 0.2))
self.pages_widget = BoxLayout(orientation='vertical', size_hint=(1, None))
#self.pages_widget.bind(minimum_height=self.pages_widget.setter('height'))
self.pages_widget.add_widget(Button(text='Pages', size_hint=(1, 1)))
self.scroll_view = ScrollView(size_hint=(1, 0.8), do_scroll_x=False)
self.scroll_view.add_widget(self.pages_widget)
self.add_widget(self.mainbutton)
self.add_widget(self.scroll_view)
def on_cinfdata(self, instance, value):
"""Setup the setup selection page, when the cinfdata ObjectProperty is set
(happens only on startup)"""
dropdown = DropDown()
for setup in self.cinfdata.get_setups():
# Do not show setups that has no dateplots
if len([l for l in setup['links']
if l['pagetype'] == 'dateplot']) == 0:
continue
btn = SetupButton(text='Setup: ' + setup['title'], size_hint_y=None,
height=44, setup=setup)
btn.bind(on_release=lambda btn: dropdown.select(btn))
dropdown.add_widget(btn)
self.mainbutton.bind(on_release=lambda widget: dropdown.open(widget))
dropdown.bind(on_select=self._select)
def _select(self, dropdown, setup_button):
"""Set the selected plot"""
Logger.debug('PageSelection._select: %s', setup_button.text)
self.mainbutton.text = setup_button.text
self.pages_widget.clear_widgets()
setup = setup_button.data
for link in setup_button.data['links']:
# So far only dateplots are implemented
if link['pagetype'] != 'dateplot':
continue
codename = setup['codename']
button = ToggleButton(text=link['title'], group=codename,
size_hint_y=None, height=50)
button.bind(on_release=partial(self._select_page, setup, link))
self.pages_widget.add_widget(button)
self.pages_widget.height = len(setup_button.data['links']) * 50
# Eventually set self.cinfdata.selected_plot with (setup, link)
def _select_page(self, setup, link, widget):
""" """
Logger.debug('PageSelection._select_page: %s - %s', setup['title'], link['title'])
self.cinfdata.selected_plot = (setup, link)
class PreparationScreen(Screen):
def __init__(self, **kwargs):
Screen.__init__(self, name="Preparation", **kwargs)
_layout = BoxLayout(orientation='vertical')
self._question_grid = BoxLayout(orientation='vertical',
size_hint=(1, 0.2))
_layout.add_widget(self._question_grid)
self._answer_grid = GridLayout(cols=3, size_hint=(1, 0.4))
_layout.add_widget(self._answer_grid)
self.send_btn = Button(text="Send", font_size=36, size_hint=(1, 0.2))
self.send_btn.bind(on_release=self.on_send)
_layout.add_widget(self.send_btn)
self.add_widget(_layout)
self._questions = []
self._answers = []
def init(self, num_questions, num_answers):
self._question_grid.clear_widgets()
self._answer_grid.clear_widgets()
self._questions = [
TextInput(multiline=False, font_size=36)
for _ in range(num_questions)
]
for widget in self._questions:
self._question_grid.add_widget(widget)
self._answers = [
TextInput(multiline=False, font_size=28)
for _ in range(num_answers)
]
for widget in self._answers:
self._answer_grid.add_widget(widget)
def on_pre_enter(self, *args):
client.add_listener(self.game_started_handler)
def on_pre_leave(self, *args):
client.remove_listener(self.game_started_handler)
def on_leave(self, *args):
self.send_btn.disabled = False
self.send_btn.text = 'Send'
def on_send(self, instance: Button):
questions = [widget.text for widget in self._questions]
answers = [widget.text for widget in self._answers]
if all(questions) and all(answers):
instance.disabled = True
instance.text = "Waiting for others..."
client.send({"op": "AddQuestions", "questions": questions})
client.send({"op": "AddAnswers", "answers": answers})
def game_started_handler(self, msg):
if msg.get('op') == 'MainStarted':
players = [(plr['id'], plr['name']) for plr in msg['players']
if plr['id'] != player_id]
next_screen = GameScreen(players)
self.manager.add_widget(next_screen)
self.manager.current = next_screen.name
class PageSelection(BoxLayout):
"""The "right" widget, that is used to select which page to plot"""
cinfdata = ObjectProperty(None)
def __init__(self, **kwargs):
super(PageSelection, self).__init__(**kwargs)
self.mainbutton = Button(text='Select Setup', size_hint=(1, 0.2))
self.pages_widget = BoxLayout(orientation='vertical',
size_hint=(1, None))
#self.pages_widget.bind(minimum_height=self.pages_widget.setter('height'))
self.pages_widget.add_widget(Button(text='Pages', size_hint=(1, 1)))
self.scroll_view = ScrollView(size_hint=(1, 0.8), do_scroll_x=False)
self.scroll_view.add_widget(self.pages_widget)
self.add_widget(self.mainbutton)
self.add_widget(self.scroll_view)
def on_cinfdata(self, instance, value):
"""Setup the setup selection page, when the cinfdata ObjectProperty is set
(happens only on startup)"""
dropdown = DropDown()
for setup in self.cinfdata.get_setups():
btn = SetupButton(text='Setup: ' + setup['title'],
size_hint_y=None,
height=44,
setup=setup)
btn.bind(on_release=lambda btn: dropdown.select(btn))
dropdown.add_widget(btn)
self.mainbutton.bind(on_release=lambda widget: dropdown.open(widget))
dropdown.bind(on_select=self._select)
def _select(self, dropdown, setup_button):
"""Set the selected plot"""
Logger.debug('PageSelection._select: %s', setup_button.text)
self.mainbutton.text = setup_button.text
self.pages_widget.clear_widgets()
setup = setup_button.data
for link in setup_button.data['links']:
codename = setup['codename']
button = ToggleButton(text=link['title'],
group=codename,
size_hint_y=None,
height=50)
button.bind(on_release=partial(self._select_page, setup, link))
self.pages_widget.add_widget(button)
self.pages_widget.height = len(setup_button.data['links']) * 50
# Eventually set self.cinfdata.selected_plot with (setup, link)
def _select_page(self, setup, link, widget):
""" """
Logger.debug('PageSelection._select_page: %s - %s', setup['title'],
link['title'])
self.cinfdata.selected_plot = (setup, link)
class RuleBox(BoxLayout):
def __init__(self, app=None, **kwargs):
self.types_container = BoxLayout(orientation="vertical")
self.app = app
super(RuleBox, self).__init__(**kwargs)
self.add_widget(self.types_container)
def load_rules(self, rules_widget):
self.types_container.clear_widgets()
self.types_container.add_widget(rules_widget)
class AddIten(Popup):
"""Popup to add an iten to the order."""
def close_btn_touch(self, btn, touch):
"""Close and cancel."""
if is_left_click(btn, touch):
self.dismiss()
def new_iten_btn_touch(self, btn, touch):
"""Add a new iten."""
if is_left_click(btn, touch):
self.dismiss()
NewIten().open()
def __init__(self, **kwargs):
"""Initialization method with style information."""
super().__init__(**kwargs)
self.title = "Adicionar Item"
self.title_size = 25
self.title_align = 'center'
self.size_hint = .7, .7
self.content = BoxLayout(orientation='vertical')
self.grid = BoxLayout(orientation="vertical", size_hint_y=None)
self.grid.bind(minimum_height=self.grid.setter('height'))
scroll = ScrollView()
scroll.add_widget(self.grid)
self.content.add_widget(scroll)
buttons = BoxLayout(size_hint_y=None, height=60)
buttons.add_widget(
BorderedButton(background_color=(1, 0, 0, 1),
on_touch_down=self.close_btn_touch,
text="Fechar",
font_size=25,
size_hint_y=None,
height=60))
buttons.add_widget(
BorderedButton(background_color=(0, 1, 0, 1),
text="Novo Item",
on_touch_down=self.new_iten_btn_touch,
font_size=25,
size_hint_y=None,
height=60))
self.content.add_widget(buttons)
def on_open(self):
"""Get all the itens options."""
app = App.get_running_app()
for iten in app.session.query(Iten).all():
self.grid.add_widget(ItenToAdd(iten))
def on_dismiss(self):
"""Clear the current itens when closed."""
self.grid.clear_widgets()
class Rate(ModalView):
prev_rating = 0
star_id = {}
def on_open(self):
self.rate_stars = BoxLayout(orientation="horizontal")
self.rate_stars.size_hint = [1, 0.075]
self.rate_stars.padding = (0, -30)
# Replace Tile image with Gray star img, and Tile_Down with yellow star img
for i in range(5):
button = Button(background_normal="../Art/NOSTAR.png",
background_down="../Art/GOLDSTAR.png")
self.star_id[button] = (i + 1)
button.bind(on_release=self.stars)
self.rate_stars.add_widget(button, len(self.rate_stars.children))
#self.rate_stars.pos = (50, 50)
self.add_widget(self.rate_stars)
def stars(self, instance):
rating = 6 - self.star_id[instance]
if rating > self.prev_rating:
for i in range(5):
self.rate_stars.children[
i].background_normal = "../Art/NOSTAR.png"
self.rate_stars.children[
i].background_down = "../Art/GOLDSTAR.png"
if rating > 0:
self.rate_stars.children[
4].background_normal = "../Art/GOLDSTAR.png"
self.rate_stars.children[4].background_down = "../Art/NOSTAR.png"
if rating > 1:
self.rate_stars.children[
3].background_normal = "../Art/GOLDSTAR.png"
self.rate_stars.children[3].background_down = "../Art/NOSTAR.png"
if rating > 2:
self.rate_stars.children[
2].background_normal = "../Art/GOLDSTAR.png"
self.rate_stars.children[2].background_down = "../Art/NOSTAR.png"
if rating > 3:
self.rate_stars.children[
1].background_normal = "../Art/GOLDSTAR.png"
self.rate_stars.children[1].background_down = "../Art/NOSTAR.png"
if rating > 4:
self.rate_stars.children[
0].background_normal = "../Art/GOLDSTAR.png"
self.rate_stars.children[0].background_down = "../Art/NOSTAR.png"
def clean(self):
self.rate_stars.clear_widgets()
self.remove_widget(self.rate_stars)
self.prev_rating = 0
self.dismiss()
class crestChooser(Image):
def __init__(self, position, **kwargs):
super(crestChooser, self).__init__(**kwargs)
self.source = './data/images/interface-choose-crest.png'
self.size_hint = (None, None)
self.size = (310, 90)
self.pos = position
self.scroller = ScrollView(do_scroll_y=False,
bar_color=[.0, .0, .0, .0])
self.scroller.size_hint = (None, None)
self.scroller.size = (310, 90)
self.scroller.pos = position
self.crest_box = BoxLayout(orientation='horizontal')
self.crest_box.size_hint = (None, None)
self.available_crests = [
] #A stub. Will be filled when the screen is called.
self.scroller.add_widget(self.crest_box)
self.add_widget(self.scroller)
def get_selected(self):
"""Returns the selected crest object. It has a 'name' property."""
selected = 'none'
for button in self.available_crests:
if button.state == 'down':
selected = button
if selected == 'none':
return None
else:
return selected
def fill_crests(self, list_of_crest_names):
"""Places the correct crests. Loaded when the screen is called."""
#First we erase the crests that are there already
self.crest_box.clear_widgets()
self.available_crests = []
##We read the save in search of the new available crests
#list_of_crest_names = g.save.crests
#Then add them to the box and to a parallel list that guard the btn objects
for name in list_of_crest_names:
btn = ToggleButton(group='crests')
btn.name = name
btn.background_normal = './data/images/crest_' + name + '_no.png'
btn.background_down = './data/images/crest_' + name + '.png'
self.crest_box.add_widget(btn)
self.available_crests.append(btn)
#Then we align everything right
self.crest_box.size = (len(list_of_crest_names) * 90, 90)
if len(list_of_crest_names) == 3:
self.scroller.pos = (45, self.pos[1])
class GameAPP(App):
_maze = ObjectProperty(None)
_map = ObjectProperty(None,force_dispatch = True)
engine = ObjectProperty(None)
_lighting = DictProperty({})
interface = ObjectProperty(None)
console = ObjectProperty(None)
def output(self,text):
self.console.add(text)
def parse(self,keyboard,keycode,text,modifiers):
if text not in "wasdf":
return
self.engine.parse(text)
self.interface.update()
#print keyboard,keycode,text,modifiers
def build(self):
self._maze = Maze()
self.title = "can't think of one now"
self.icon = "graphics/icon.png"
#self.root = ScreenManager()
self.root = BoxLayout(orientation = "horizontal")
self.keyboard = Window.request_keyboard(None,self.root)
self.keyboard.bind(on_key_down = self.parse)
self.reset()
#Clock.schedule_interval(self.update,0.5)
return self.root
def update(self,dt):
self.engine.monaction()
self.engine.cleanup()
if not self.engine.player._alive:
gameoversound.play()
Clock.unschedule(self.update)
popup = GameOver()
popup.bind(on_dismiss = lambda x:self.reset())
popup.open()
self.interface.update()
def reset(self):
self.root.clear_widgets()
#screen = Screen(name = "Game")
shapep = int(mapsize)+((initlevel-1)*5)
if shapep % 2 == 0:
shapep += 1
self._map = self._maze((shapep,shapep),0.75,0.75,new = True)
self.engine = Engine(_maze = self._map,_level = initlevel,outputfunc = self.output)
self.interface = LayeredMap(_shape = shapep,_map = self.engine._map)
self.root.add_widget(self.interface)
self.console = Console()
self.root.add_widget(self.console)
#screen.add_widget(self.interface)
#self.root.add_widget(screen)
#self.root.current = "Game"
Clock.schedule_interval(self.update,0.5)
class TaskApp(App):
detailsID = 0
BiD = 0
taskId = 0
def build(self):
self.layout = BoxLayout(orientation='vertical')
self.menuBar = MenuBar()
self.menuBar.app = self
self.layout.add_widget(self.menuBar)
self.sublayout = BoxLayout(orientation='horizontal')
self.layout.add_widget(self.sublayout)
self.tv = CustomTreeView(root_options=dict(text='Tree One'), hide_root=True, indent_level=4)
self.tv.size_hint = 1, None
self.tv.bind(minimum_height = self.tv.setter('height'))
self.tv.app = self
populate_tree_view(self.tv)
self.sv = ScrollView()
self.sv.add_widget(self.tv)
self.sublayout.add_widget(self.sv)
# subsublayout = GridLayout()
if self.detailsID != 0:
self.details = Details.giveDetailsObject(self.detailsID)
self.sublayout.add_widget(self.details)
else:
self.details = BoxLayout(orientation="vertical")
self.sublayout.add_widget(self.details)
# sublayout.add_widget(subsublayout)
# sublayout.add_widget(Button(text='Test'))
return self.layout
def updateDetails(self, *args):
children = self.sublayout.children[:1]
self.sublayout.clear_widgets(children=children)
self.details = Details.giveDetailsObject(self.detailsID)
self.sublayout.add_widget(self.details)
def getTaskScreen(self,*args):
children = self.sublayout.children[:1]
self.sublayout.clear_widgets(children=children)
print(self.taskId, 'taskid')
print(self.BiD, 'buildid')
self.details = AddTaskScreen(task=AddTaskScreen.get_rigt_task_for_task_screen(self.taskId,self.BiD), app=self)
print("after AddTaskScreen()")
#self.details.buildID = self.BiD
#self.details.task = Task.getTask(self.taskId)
#self.details.app = self
self.sublayout.add_widget(self.details)
print('im here')
class AskUserEventHandler(EventHandler):
"""Handles user input for actions which require special input."""
menu: BoxLayout = None
bg: Rectangle = None
def __init__(self, engine, **kwargs):
super(AskUserEventHandler, self).__init__(engine)
# Create Framed Menu with Cursor or Highlight
self.menu = BoxLayout(pos_hint={
"top": 0.75,
"center_x": 0.35
},
orientation="vertical",
size_hint=(None, None))
with self.menu.canvas:
Color(0.5, 0.25, 0.1, 1)
self.bg = Rectangle(pos=self.menu.pos, size=self.menu.size)
def __on_exit__(self, root_widget: Widget) -> None:
root_widget.remove_widget(self.menu)
self.menu.clear_widgets()
self.menu.canvas.clear()
self.rect = None
def ev_keydown(self,
event: tcod.event.KeyDown) -> Optional[ActionOrHandler]:
"""By default any key exits this input handler."""
if event.sym in { # Ignore modifier keys.
tcod.event.K_LSHIFT,
tcod.event.K_RSHIFT,
tcod.event.K_LCTRL,
tcod.event.K_RCTRL,
tcod.event.K_LALT,
tcod.event.K_RALT,
}:
return None
return self.on_exit()
def ev_mousebuttondown(
self,
event: tcod.event.MouseButtonDown) -> Optional[ActionOrHandler]:
"""By default any mouse click exits this input handler."""
return self.on_exit()
def on_exit(self) -> Optional[ActionOrHandler]:
"""Called when the user is trying to exit or cancel an action.
By default this returns to the main event handler.
"""
return MainGameEventHandler(self.engine)
class MainWid(ScreenManager):
def __init__(self, *args, **kwargs):
super(MainWid, self).__init__()
# Control de Path
self.APP_PATH = os.getcwd()
self.DB_PATH = self.APP_PATH + '/database.db'
self.MenuWid = MenuWid(self) #Screen: menu
self.CreatureListWid = CreatureListWid(self) #Screen: creaturelist
self.CreatureCreateWid = BoxLayout() #Screen: creaturecreate
self.CreatureUpdateWid = BoxLayout() #Screen: creatureupdate
wid = Screen(name='menu')
wid.add_widget(self.MenuWid)
self.add_widget(wid)
wid = Screen(name='creaturelist')
wid.add_widget(self.CreatureListWid)
self.add_widget(wid)
wid = Screen(name='creaturecreate')
wid.add_widget(self.CreatureCreateWid)
self.add_widget(wid)
wid = Screen(name='creatureupdate')
wid.add_widget(self.CreatureUpdateWid)
self.add_widget(wid)
self.goto_menu()
def goto_menu(self):
self.current = 'menu'
def goto_creturelist(self):
self.CreatureListWid.check_memory()
self.current = 'creaturelist'
def goto_creaturecreate(self):
self.CreatureCreateWid.clear_widgets()
wid = CreatureCreateWid(self)
self.CreatureCreateWid.add_widget(wid)
self.current = 'creaturecreate'
def goto_creatureupdate(self, data_id):
self.CreatureUpdateWid.clear_widgets()
wid = CreatureUpdateWid(self, data_id)
self.CreatureUpdateWid.add_widget(wid)
self.current = 'creatureupdate'
class MainWid(ScreenManager):
def __init__(self, **kwargs): #recibe un diccionario de parametros
super(MainWid, self).__init__()
self.APP_PATH = os.getcwd() #constante DB
self.DB_PATH = self.APP_PATH + "/my_database.db"
self.StartWid = StartWid(self) #instancia de la clase StartWid
self.DataBaseWid = DataBaseWid(self)
self.InsertDataWid = BoxLayout(
) #Limpiar para inicar nuevo widget %%%%%
self.UpdateDataWid = BoxLayout() #Actualizar producto
self.Popup = MessagePopup()
wid = Screen(name="start")
wid.add_widget(self.StartWid)
self.add_widget(wid)
wid = Screen(name="database")
wid.add_widget(self.DataBaseWid)
self.add_widget(wid)
#%%%%%
wid = Screen(name="insertdata")
wid.add_widget(self.InsertDataWid)
self.add_widget(wid)
wid = Screen(name="updatedata")
wid.add_widget(self.UpdateDataWid)
self.add_widget(wid)
#Función que ayuda a acomodar las pantallas en el momento que se invoquen.
self.goto_start()
def goto_start(self):
self.current = "start"
def goto_database(self):
self.DataBaseWid.check_memory()
self.current = "database"
#%%%%%
def goto_insertdata(self):
self.InsertDataWid.clear_widgets() #para limpiarlo
wid = InsertDataWid(self)
self.InsertDataWid.add_widget(wid)
self.current = "insertdata"
def goto_updatedata(self, data_id):
self.UpdateDataWid.clear_widgets() #para limpiarlo
wid = UpdateDataWid(self, data_id)
self.UpdateDataWid.add_widget(wid)
self.current = "updatedata"
class MainApp(App):
def build(self):
self.layout = BoxLayout(padding=30)
button = Button(text='Try me',
size_hint=(.5, .5),
pos_hint={'center_x': .5, 'center_y': .5})
button.bind(on_press=self.on_press_button)
self.layout.add_widget(button)
return self.layout
def on_press_button(self, instance):
self.layout.clear_widgets()
to_birthday = ToBirthday()
Clock.schedule_interval(to_birthday.update, 1)
self.layout.add_widget(to_birthday)
class LienzoApp(ScreenManager):
def __init__(self):
super(LienzoApp, self).__init__()
self.APP_PATH = os.getcwd()
self.DB_PATH = self.APP_PATH + "/testdb.db"
self.InicioLienzo = InicioLienzo(self)
self.DBWid = DBWid(self)
self.InsertarDataWid = BoxLayout()
self.ActualizaCajas = BoxLayout()
self.popup = MensajePopUp()
wid = Screen(name="inicio")
wid.add_widget(self.InicioLienzo)
self.add_widget(wid)
wid = Screen(name="productos")
wid.add_widget(self.DBWid)
self.add_widget(wid)
wid = Screen(name="insertardatos")
wid.add_widget(self.InsertarDataWid)
self.add_widget(wid)
wid = Screen(name="actualizar")
wid.add_widget(self.ActualizaCajas)
self.add_widget(wid)
self.goto_inicio()
def goto_inicio(self):
self.current = "inicio"
def goto_soluciones(self):
self.DBWid.check_memory()
self.current = "productos"
def goto_insertar(self):
self.InsertarDataWid.clear_widgets()
wid = InsertarDataWid(self)
self.InsertarDataWid.add_widget(wid)
self.current = "insertardatos"
def goto_actualizar(self, data_id):
self.ActualizaCajas.clear_widgets()
wid = ActualizaCajas(self, data_id)
self.ActualizaCajas.add_widget(wid)
self.current = "actualizar"
class MainWid(ScreenManager):
def __init__(self, *args, **kwargs):
super().__init__(**kwargs)
self.APP_PATH = os.getcwd()
self.DB_PATH = self.APP_PATH + '/db_sqlite3.db'
self.startWid = StartWid(self)
self.dataBaseWid = DataBaseWid(self)
self.insertDataWid = InsertDataWid(self) # BoxLayout()
self.updateDataWid = BoxLayout()
self.popup = MessagePopup()
wid = Screen(name='start')
wid.add_widget(self.startWid)
self.add_widget(wid)
wid = Screen(name='database')
wid.add_widget(self.dataBaseWid)
self.add_widget(wid)
wid = Screen(name='insertdata')
wid.add_widget(self.insertDataWid)
self.add_widget(wid)
wid = Screen(name='updatedata')
wid.add_widget(self.updateDataWid)
self.add_widget(wid)
self.start()
def start(self):
self.current = 'start'
def dataBase(self):
self.dataBaseWid.check_mem()
self.current = 'database'
def insert_data(self):
self.insertDataWid.clear_widgets()
wid = InsertDataWid(self)
self.insertDataWid.add_widget(wid)
self.current = 'insertdata'
def update_data(self, data_id):
self.updateDataWid.clear_widgets()
wid = UpdateDataWid(self, data_id)
self.updateDataWid.add_widget(wid)
self.current = 'updatedata'
class MainWid(ScreenManager):
def __init__(self, **kwarg):
super(MainWid, self).__init__()
self.app_path = os.getcwd()
self.db_path = self.app_path + "/my_database.db"
self.StartWid = StartWid(self)
self.DataBaseWid = DataBaseWid(self)
self.InsertDataWid = BoxLayout()
self.UpdateDataWid = BoxLayout()
self.Popup = MessagePopup()
wid = Screen(name='start')
wid.add_widget(self.StartWid)
self.add_widget(wid)
wid = Screen(name='database')
wid.add_widget(self.DataBaseWid)
self.add_widget(wid)
wid = Screen(name='insertdata')
wid.add_widget(self.InsertDataWid)
self.add_widget(wid)
wid = Screen(name='updatedata')
wid.add_widget(self.UpdateDataWid)
self.add_widget(wid)
self.goto_start()
def goto_start(self):
self.current = 'start'
def goto_database(self):
self.DataBaseWid.check_memory()
self.current = 'database'
def goto_insertdata(self):
self.InsertDataWid.clear_widgets()
wid = InsertDataWid(self)
self.InsertDataWid.add_widget(wid)
self.current = 'insertdata'
def goto_updatedata(self, data_id):
self.UpdateDataWid.clear_widgets()
wid = UpdateDataWid(self, data_id)
self.UpdateDataWid.add_widget(wid)
self.current = 'updatedata'
class MainWindow(App):
settings_popup = Settings()
def add_widgets(self, root):
self.settings_popup.ok.bind(on_press=self.re_build)
page = PageLayout(border=30, swipe_threshold=0.2)
p1 = BoxLayout(orientation='horizontal', background_color=[1, 1, 1, 1])
p1.add_widget(self.settings_popup.specimen.eps_sig_wid)
p1.add_widget(self.settings_popup.specimen.f_u_wid)
page.add_widget(p1)
p2 = BoxLayout(orientation='horizontal', background_color=[1, 1, 1, 1])
p2.add_widget(self.settings_popup.specimen.disp_slip_wid)
p2.add_widget(self.settings_popup.specimen.shear_flow_wid)
page.add_widget(p2)
upper = BoxLayout(orientation='horizontal', size_hint=(1, 0.7))
upper.add_widget(page)
root.add_widget(upper)
btns = BoxLayout(orientation='horizontal', size_hint=(1, 0.1))
settings = Button(text='Settings')
settings.bind(on_press=self.settings_popup.open)
reset = Button(text='Reset')
reset.bind(on_press=self.settings_popup.reset)
btns.add_widget(Label())
btns.add_widget(Label())
btns.add_widget(settings)
btns.add_widget(reset)
root.add_widget(self.settings_popup.specimen)
root.add_widget(btns)
def build(self):
self.root = BoxLayout(orientation='vertical')
self.add_widgets(self.root)
return self.root
def re_build(self, btn):
self.settings_popup.confirm_settings(btn)
self.root.clear_widgets()
self.add_widgets(self.root)
self.settings_popup.reset(None)
def disabled_menu(self):
"""
Creates a disabled messaging menu should xmpp be disabled.
"""
self.clear_widgets()
sub_layout = BoxLayout(size_hint=(1, 1))
sub_layout.clear_widgets()
lab = Label(text='XMPP messaging is disabled due to config errors!',
size_hint=(1, 1),
markup=True)
lab.color = colorsys.hsv_to_rgb(0, 0, 1)
with lab.canvas.before:
Color(1, 1, 0, mode='hsv')
lab.bg_rect = Rectangle(pos=self.pos, size=self.size)
lab.bind(pos=self.redraw, size=self.redraw)
sub_layout.add_widget(lab)
self.add_widget(sub_layout)
class MyApp(App):
isConnected = False
connect = object
def build(self):
global connect
self.mainview = BoxLayout(orientation='horizontal')
self.startscreen = SimMainScreen(self)
self.mainview.add_widget(self.startscreen)
return self.mainview
def on_stop(self):
return
def showStartScreen(self):
self.mainview.clear_widgets()
self.mainview.add_widget(self.startscreen)
def showResult(self, simobj):
self.mainview.clear_widgets()
resultpage = SimResultScreen(self, simobj)
self.mainview.add_widget(resultpage)
def showEditorNew(self):
self.mainview.clear_widgets()
editorpage = SimParamEditor(self)
self.mainview.add_widget(editorpage)
class CityChooser(BoxLayout):
def __init__(self, main, caller, next_screen, returner, **kwargs):
super().__init__(**kwargs, orientation='horizontal')
self.next_screen = next_screen
self.callnext = main.callnext
self.caller = caller
self.returner = returner
self.moves = 0
self.cdc = 1
color_btns = BoxLayout(orientation='vertical')
bluebtn = Button(text="Blue")
yellowbtn = Button(text="Yellow")
blackbtn = Button(text="Black")
redbtn = Button(text="Red")
bluebtn.bind(on_press=self.color_clicked)
yellowbtn.bind(on_press=self.color_clicked)
blackbtn.bind(on_press=self.color_clicked)
redbtn.bind(on_press=self.color_clicked)
color_btns.add_widget(bluebtn)
color_btns.add_widget(yellowbtn)
color_btns.add_widget(blackbtn)
color_btns.add_widget(redbtn)
self.citybtns = BoxLayout(orientation='vertical')
self.add_widget(color_btns)
self.add_widget(self.citybtns)
def color_clicked(self, btn):
self.citybtns.clear_widgets()
cities = city_list[btn.text.lower()]
for city in cities:
btn = Button(text=city)
btn.bind(on_press=self.city_choosen)
self.citybtns.add_widget(btn)
def city_choosen(self, btn):
if self.returner(btn.text):
self.callnext(self.next_screen)
else:
self.callnext(self.caller)
class AddWord(ScreenManager):
def __init__(self, **kwargs):
super(AddWord, self).__init__(**kwargs)
layout = BoxLayout(orientation='vertical')
self.word_input = TextInput(multiline=False, size_hint=(1, .5))
layout.add_widget(self.word_input)
self.button = Button(
on_press=self.send_word,
on_error=self.on_error,
text="Send", size_hint=(1, .5),
pos_hint={'center_x': .5, 'center_y': .5})
layout.add_widget(self.button)
add = Screen(name='Add')
add.add_widget(layout)
self.add_widget(add)
# --
self.status_layout = BoxLayout(orientation='vertical')
status = Screen(name='Status')
status.add_widget(self.status_layout)
self.add_widget(status)
def send_word(self, *args):
self.status_layout.clear_widgets()
self.status_layout.add_widget(Label(text='Loading..'))
self.current = 'Status'
word = self.word_input.text
headers = {'Content-type': 'application/x-www-form-urlencoded', 'Accept': 'application/json'}
UrlRequest(POST_WORD_URL, method="POST",
req_headers=headers,
req_body=urlencode({'word': word}),
on_success=self.show_response,
on_error=self.on_error,
on_failure=self.on_error)
def show_response(self, _, data):
if data['name']:
text = "%s \n\n%s" % (data['name'], "\n".join(["-(%s) %s" % tuple(i) for i in data['meanings_list']]))
else:
text = "The word wasn't found"
self.status_layout.clear_widgets()
self.status_layout.add_widget(Label(text=text, text_size=(self.width, None), padding_x=10))
self.status_layout.add_widget(Button(text='OK', on_press=self.reset))
def on_error(self, *args):
print('on_error', args)
def reset(self, *args):
self.word_input.text = ""
self.current = 'Add'
self.status_layout.clear_widgets()
def do_popup_file_select(self):
"""
Prompts the user to navigate to the WAV file.
"""
self.filewidget = FileWidget()
box = BoxLayout(orientation='vertical')
box_int = BoxLayout(orientation='horizontal', size_hint=(1, .2))
close_button = Button(text='Load')
close_button.bind(on_release=lambda x: self.copy_sound())
dismiss_button = Button(text='Cancel')
dismiss_button.bind(
on_release=lambda x: self.file_select_popup.dismiss())
box.clear_widgets()
box_int.add_widget(close_button)
box_int.add_widget(dismiss_button)
box.add_widget(self.filewidget)
box.add_widget(box_int)
self.file_select_popup = Popup(title='Choose File',
content=box,
size_hint=(None, None),
size=(800, 1000),
auto_dismiss=False)
self.file_select_popup.open()
class MusicApp(App):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.window_x = Window.size[0]
self.window_y = Window.size[1]
self.all_window = BoxLayout(orientation='vertical', size_hint=[1, 1])
if True: # Make fast_menu
self.fast_menu = BoxLayout(size_hint=[1, .0625])
self.btn1 = Button(text='music',
size_hint=[1, 1],
on_press=self.press_chart)
self.btn2 = Button(text='+',
size_hint=[1, 1],
on_press=self.press_add_music)
self.btn3 = Button(text='profil',
size_hint=[1, 1],
on_press=self.press_profile)
self.fast_menu.add_widget(self.btn1)
self.fast_menu.add_widget(self.btn2)
self.fast_menu.add_widget(self.btn3)
if True: # Make main_menu and variety of main menu
self.profile_menu = BoxLayout()
self.make_profile_menu()
self.chart_menu = BoxLayout()
self.make_chart_menu()
self.add_music_menu = BoxLayout()
self.make_add_music_menu()
self.main_menu = BoxLayout(size_hint=[1, .9375])
self.main_menu.add_widget(self.profile_menu)
self.all_window.add_widget(self.main_menu)
self.all_window.add_widget(self.fast_menu)
def build(self):
return self.all_window
def press_chart(self, instance): # at the moment it is finished
self.main_menu.clear_widgets()
self.main_menu.add_widget(self.chart_menu)
def press_add_music(self, instance): # at the moment it is finished
self.main_menu.clear_widgets()
self.main_menu.add_widget(self.add_music_menu)
def press_profile(self, instance): # at the moment it is finished
self.main_menu.clear_widgets()
self.main_menu.add_widget(self.profile_menu)
def make_profile_menu(self): # a lot of work
self.profile_menu.add_widget(Button(text='profile', size_hint=[1, 1]))
def make_add_music_menu(self): # a lot of work
self.add_music_menu.add_widget(
Button(text='add music', size_hint=[1, 1]))
def make_chart_menu(self): # a lot of work
self.chart_menu.add_widget(Button(text='chart', size_hint=[1, 1]))
class SettingContainer(BoxLayout):
def __init__(self, app, **kwargs):
self.app = app
self.settings = self.app.settings
self.settings_container = BoxLayout(orientation="vertical")
super(SettingContainer, self).__init__(**kwargs)
self.create_button = Button(text="create", size_hint_x=None)
self.create_button.bind(on_press=lambda widget: self.create_item())
self.add_widget(self.settings_container)
self.add_widget(self.create_button)
self.update_widgets()
def update_widgets(self):
self.settings_container.clear_widgets()
for widget in self.settings:
self.settings_container.add_widget(widget)
def create_item(self):
w = SetItem(None)
self.settings_container.add_widget(w)
def remove_item(self, item):
self.settings_container.remove_widget(item)
del item
class AdventureApp(App):
def __init__(self, **kwargs):
super(AdventureApp, self).__init__(**kwargs)
Builder.load_file('mainMenu.kv')
Builder.load_file('adventure.kv')
Builder.load_file('movement.kv')
self.WidgetSet = BoxLayout()
self.Game = Main_Menu()
self.b = None
f = open("gamechoice.txt", "w")
f.write('mainmenu')
f.close()
def build(self):
Clock.schedule_interval(self.update, 1)
return self.WidgetSet
def update(self, dt):
print 'update'
f = open('gamechoice.txt', 'r')
a = f.read()
f.close()
if self.b == a:
print 'passed'
else:
self.b = a
if a == "mainmenu":
print 'MainMenu!!'
self.WidgetSet.clear_widgets()
self.Game = Main_Menu()
self.WidgetSet.add_widget(self.Game)
elif a == 'scratch':
print 'Scratch!!'
self.WidgetSet.clear_widgets()
self.Game = map.Mechanics()
self.WidgetSet.add_widget(self.Game)
elif a == 'box':
print 'BOX!!'
self.WidgetSet.clear_widgets()
self.Game = box.stuff_moving()
self.WidgetSet.add_widget(self.Game)
else:
pass
class InfoPopup(Scatter):
"""Widget that contains detailed information in a draggable popup."""
def __init__(self, **kwargs):
global popups
popups.append(self)
self._built = False
self._window = None
self._parent = None
self._old_center = (0, 0)
self.layout = None
self.label = None
self.container = None
self.background = kwargs.get(
'background',
'atlas://data/images/defaulttheme/modalview-background'
)
self.border = kwargs.get('border', [16, 16, 16, 16])
self._title = kwargs.get('title', 'No title')
self._content = kwargs.get('content', None)
self.register_event_type('on_show')
self.register_event_type('on_dismiss')
super(InfoPopup, self).__init__(**kwargs)
def build(self):
"""Render the popup."""
with self.canvas:
Color(1, 1, 1)
BorderImage(
source=self.background,
border=self.border,
pos=self.pos,
size=self.size
)
self.layout = GridLayout(
cols=1,
padding=12,
spacing=5,
size_hint=(None, None),
pos=self.pos,
size=self.size
)
header = BoxLayout(size_hint_y=None, height=28)
# Set the popup's title
self.label = Label(
text=self.title,
size_hint_y=None,
height=24,
valign='middle',
font_size=12,
padding=(0, 6),
text_size=(self.width - 124, 24)
)
header.add_widget(self.label)
# Add a close button
close_btn = Button(
text='Close',
size_hint=(None, None),
size=(100, 28)
)
close_btn.bind(on_release=self.dismiss)
header.add_widget(close_btn)
self.layout.add_widget(header)
separator = WRectangle(
size_hint_y=None,
height=2,
color=[.2, .6, .9, 1.]
)
self.layout.add_widget(separator)
# Add the popup's contents
self.container = BoxLayout()
if self._content:
self.container.add_widget(self._content)
self.layout.add_widget(self.container)
self.add_widget(self.layout)
self._built = True
def update_textures(self, widget=None, *largs):
"""Update all labels inside the popup."""
if not isinstance(widget, Widget):
widget = self
if isinstance(widget, Label):
Logger.debug("InfoPopup: Update texture of %s" % widget.__class__)
widget.texture_update()
for child in widget.children:
self.update_textures(child)
def show(self, *largs):
"""Open the popup."""
if self._window:
# Bring to front
self._window.remove_widget(self)
self._window.add_widget(self)
self._align_center()
return self
self._window = Window
if not self._window:
Logger.warning('InfoPopup: cannot open popup, no window found.')
return self
self._window.add_widget(self)
self._window.bind(on_resize=self._align_center)
if not self._built:
# Render the popup when not done so yet
self.build()
self.center = self._window.mouse_pos
self._align_center()
Clock.schedule_once(self.update_textures, .5)
self.dispatch('on_show')
return self
def dismiss(self, *largs):
"""Close the popup."""
if self._window:
self._window.remove_widget(self)
self._window.unbind(on_resize=self._align_center)
self._window = None
self.dispatch('on_dismiss')
return self
def swerve(self, *largs):
"""Move the popup to the closest side of the screen."""
if not self._window:
return
self._old_center = self.center
dx = self._window.center[0] - self.center[0]
dy = self._window.center[1] - self.center[1]
# Window dimensions
ww = self._window.width
wh = self._window.height
# Extended sizes
eww = ww + (self.width - 40)
ewh = wh + (self.height - 40)
if abs(dx) / ww >= abs(dy) / wh:
if dx > 0:
tx = -(self.width / 2 - 20)
else:
tx = ww + (self.width / 2 - 20)
if dy > 0:
ty = self.center[1] - eww / 2 * abs(dy) / (abs(dx) + 1e-5) + dy
else:
ty = self.center[1] + eww / 2 * abs(dy) / (abs(dx) + 1e-5) + dy
else:
if dx > 0:
tx = self.center[0] - ewh / 2 * abs(dx) / (abs(dy) + 1e-5) + dx
else:
tx = self.center[0] + ewh / 2 * abs(dx) / (abs(dy) + 1e-5) + dx
if dy > 0:
ty = -(self.height / 2 - 20)
else:
ty = wh + (self.height / 2 - 20)
Animation(
center=(tx, ty),
t='in_out_expo',
d=.3
).start(self)
def swerve_back(self, *largs):
"""Move the popup back to where it came from."""
if not self._window:
return
Animation(
center=self._old_center,
t='in_out_expo',
d=.3
).start(self)
def on_size(self, instance, value):
"""Handler when the popup is resized. Re-align the popup."""
self._align_center()
def _align_center(self, *largs):
"""Re-align the popup to the center of the screen."""
if self._window:
Animation(
center=self._window.center,
t='in_out_expo',
d=.3
).start(self)
def on_show(self):
"""Handler when the popup is opened. Does nothing."""
pass
def on_dismiss(self):
"""Handler when the popup is closed. Does nothing."""
pass
def get_title(self):
"""Getter for the popup's title."""
return self._title
def set_title(self, value):
"""Setter for the popup's title."""
self._title = value
if self.label:
self.label.text = self._title
def get_content(self):
"""Getter for the popup's content."""
return self._content
def set_content(self, value):
"""Setter for the popup's content."""
self._content = value
if self.container:
self.container.clear_widgets()
if self._content:
self.container.add_widget(self._content)
Clock.schedule_once(self.update_textures, .5)
# Define getters and setters
title = property(get_title, set_title)
content = property(get_content, set_content)
class SubstitutingScreen(Screen):
def __init__(self, **kwargs):
result = super(SubstitutingScreen, self).__init__(**kwargs)
layout = BoxLayout(orientation='vertical')
backButton = Button(text='<<<', size_hint=(1, 0.1))
scroll = ScrollView(size_hint=(1,1))
self._contentSpace = BoxLayout(orientation='vertical')
scroll.add_widget(self._contentSpace)
backButton.bind(on_press=self.goBack)
layout.add_widget(backButton)
layout.add_widget(scroll)
self.add_widget(layout)
self.bind(on_enter=self.displayContent)
return result
def goBack(self, invoker):
self.manager.current="Menu"
def downloadContent(self):
date = datetime.date.today()
# Tomorrow
#date = datetime.date.today() + datetime.timedelta(days=1)
dateText = str(date.year) + str(date.month).zfill(2) + str(date.day).zfill(2)
url = 'http://www.glstn.sk/zastupo/zast_' + dateText + '.htm'
htmlRequest = requests.get(url)
htmlRequest.encoding = 'windows-1250'
return htmlRequest.text.encode('utf-8')
def parseContent(self, htmlText):
# Cut the interesting portion
htmlStart = re.search('zastupovanie', htmlText)
htmlText = htmlText[htmlStart.regs[0][0]:]
htmlStart = re.search('<table.*class="Pozadie".*>', htmlText)
htmlText = htmlText[htmlStart.regs[0][1]:]
htmlEnd = re.search('</table>', htmlText)
htmlText = htmlText[:htmlEnd.regs[0][0]]
htmlText = re.sub('nowrap| ', '', htmlText)
htmlText = '<body>' + htmlText + '</body>'
# Parse the html
htmlDom = xml.dom.minidom.parseString(htmlText)
# Build dictionary where class is the key
substitutionByClass = {}
missingTeacher = None
hour = None
schoolClasses = None
subject = None
classroom = None
substitutingTeacher = None
substitutionType = None
note = None
for row in htmlDom.getElementsByTagName('tr'):
correctRow = True
for cell in row.getElementsByTagName('td'):
atr = cell.getAttribute('class')
if cell.firstChild:
data = cell.firstChild.data
else:
data = ''
if atr == 'C11':
if data != '':
missingTeacher = data
elif atr == 'C12':
hour = int(data)
elif atr == 'C13':
schoolClasses = data
elif atr == 'C14':
subject = data
elif atr == 'C15':
classroom = data
elif atr == 'C16':
substitutingTeacher = data
elif atr == 'C17':
substitutionType = data
elif atr == 'C18':
note = data
else:
correctRow = False
break
if not correctRow:
continue
# The schoolClasses might contain a list of classes separated by comma
for schoolClass in schoolClasses.split(', '):
if not schoolClass in substitutionByClass:
substitutionByClass[schoolClass] = []
substitutionByClass[schoolClass].append(SubstituteItem(hour, subject, substitutingTeacher, note, missingTeacher, classroom, substitutionType))
return substitutionByClass
def prepareContent(self):
htmlText = self.downloadContent()
return self.parseContent(htmlText)
def displayContent(self, invoker):
self._contentSpace.clear_widgets()
self._contentSpace.size_hint=(1, 1)
self._contentSpace.size=(0,0)
try:
content = self.prepareContent()
if Settings.schoolClass in content:
for x in content[Settings.schoolClass]:
self._contentSpace.add_widget(x.kivy_short(self.displayFull))
self._contentSpace.add_widget(Spacer())
self._contentSpace.size_hint=(1, None)
self._contentSpace.size=(0,1000)
else:
self._contentSpace.add_widget(Label(text='No substituting today :('))
except Exception, e:
self._contentSpace.add_widget(Label(text='An error occured.'))
MessagePopup('Error', traceback.format_exc(e))
class DatePicker(BoxLayout):
def __init__(self, *args, **kwargs):
super(DatePicker, self).__init__(**kwargs)
self.date = date.today()
self.orientation = "vertical"
self.month_names = ('January', 'February', 'March', 'April', 'May',
'June', 'July', 'August', 'September', 'October',
'November', 'December')
if kwargs.has_key("month_names"):
self.month_names = kwargs['month_names']
self.header = BoxLayout(orientation='horizontal', size_hint=(1, 0.2))
self.body = GridLayout(cols=7)
self.add_widget(self.header)
self.add_widget(self.body)
self.populate_body()
self.populate_header()
def populate_header(self, *args, **kwargs):
self.header.clear_widgets()
previous_month = Button(text="<")
previous_month.bind(on_press=partial(self.move_previous_month))
next_month = Button(text=">", on_press=self.move_next_month)
next_month.bind(on_press=partial(self.move_next_month))
month_year_text = self.month_names[self.date.month - 1] + ' ' + str(
self.date.year)
current_month = Label(text=month_year_text, size_hint=(2, 1))
self.header.add_widget(previous_month)
self.header.add_widget(current_month)
self.header.add_widget(next_month)
def populate_body(self, *args, **kwargs):
self.body.clear_widgets()
date_cursor = date(self.date.year, self.date.month, 1)
for filler in range(date_cursor.isoweekday() - 1):
self.body.add_widget(Label(text=""))
while date_cursor.month == self.date.month:
date_label = Button(text=str(date_cursor.day))
date_label.bind(
on_press=partial(self.set_date, day=date_cursor.day))
if self.date.day == date_cursor.day:
date_label.background_normal, date_label.background_down = date_label.background_down, date_label.background_normal
self.body.add_widget(date_label)
date_cursor += timedelta(days=1)
def set_date(self, *args, **kwargs):
self.date = date(self.date.year, self.date.month, kwargs['day'])
self.populate_body()
self.populate_header()
def move_next_month(self, *args, **kwargs):
if self.date.month == 12:
self.date = date(self.date.year + 1, 1, self.date.day)
else:
self.date = date(self.date.year, self.date.month + 1,
self.date.day)
self.populate_header()
self.populate_body()
def move_previous_month(self, *args, **kwargs):
if self.date.month == 1:
self.date = date(self.date.year - 1, 12, self.date.day)
else:
self.date = date(self.date.year, self.date.month - 1,
self.date.day)
self.populate_header()
self.populate_body()
class DatePicker(BoxLayout):
def __init__(self, *args, **kwargs):
super(DatePicker, self).__init__(**kwargs)
self.date = date.today()
self.orientation = "vertical"
self.month_names = ('January',
'February',
'March',
'April',
'May',
'June',
'July',
'August',
'September',
'October',
'November',
'December')
if kwargs.has_key("month_names"):
self.month_names = kwargs['month_names']
self.header = BoxLayout(orientation = 'horizontal',
size_hint = (1, 0.2))
self.body = GridLayout(cols = 7)
self.add_widget(self.header)
self.add_widget(self.body)
self.populate_body()
self.populate_header()
def populate_header(self, *args, **kwargs):
self.header.clear_widgets()
previous_month = Button(text = "<")
previous_month.bind(on_press=partial(self.move_previous_month))
next_month = Button(text = ">", on_press = self.move_next_month)
next_month.bind(on_press=partial(self.move_next_month))
month_year_text = self.month_names[self.date.month -1] + ' ' + str(self.date.year)
current_month = Label(text=month_year_text, size_hint = (2, 1))
self.header.add_widget(previous_month)
self.header.add_widget(current_month)
self.header.add_widget(next_month)
def populate_body(self, *args, **kwargs):
self.body.clear_widgets()
date_cursor = date(self.date.year, self.date.month, 1)
for filler in range(date_cursor.isoweekday()-1):
self.body.add_widget(Label(text=""))
while date_cursor.month == self.date.month:
date_label = Button(text = str(date_cursor.day))
date_label.bind(on_press=partial(self.set_date,
day=date_cursor.day))
if self.date.day == date_cursor.day:
date_label.background_normal, date_label.background_down = date_label.background_down, date_label.background_normal
self.body.add_widget(date_label)
date_cursor += timedelta(days = 1)
def set_date(self, *args, **kwargs):
self.date = date(self.date.year, self.date.month, kwargs['day'])
self.populate_body()
self.populate_header()
def move_next_month(self, *args, **kwargs):
if self.date.month == 12:
self.date = date(self.date.year + 1, 1, self.date.day)
else:
self.date = date(self.date.year, self.date.month + 1, self.date.day)
self.populate_header()
self.populate_body()
def move_previous_month(self, *args, **kwargs):
if self.date.month == 1:
self.date = date(self.date.year - 1, 12, self.date.day)
else:
self.date = date(self.date.year, self.date.month -1, self.date.day)
self.populate_header()
self.populate_body()
class CancelLunchScreen(Screen):
def __init__(self, **kwargs):
result = super(CancelLunchScreen, self).__init__(**kwargs)
layout = BoxLayout(orientation='vertical')
backButton = Button(text='<<<', size_hint=(1, 0.1))
scroll = ScrollView(size_hint=(1,1))
self._contentSpace = BoxLayout(orientation='vertical')
scroll.add_widget(self._contentSpace)
backButton.bind(on_press=self.goBack)
layout.add_widget(backButton)
layout.add_widget(scroll)
self.add_widget(layout)
self.bind(on_enter=self.displayContent)
self.dateField = None
return result
def goBack(self, invoker):
self.dateField = None
self.manager.current="Menu"
def downloadContent(self):
htmlRequest = requests.get('http://www.google.com/recaptcha/api/noscript?k=6Led_70SAAAAALznKUaJm-fIGI4FFzUvUymYq_6w')
htmlRequest.encoding = 'utf-8'
return htmlRequest.text
def parseContent(self, htmlText):
recaptchaChallengeRegex = re.compile('<input.*name="recaptcha_challenge_field".*value=["]([^"]+)["]>', re.UNICODE)
imgRegex = re.compile('<img.*src=["](image[?]c=[^"]+)["]>', re.UNICODE)
recaptchaChallengeResult = recaptchaChallengeRegex.search(htmlText)
imgResult = imgRegex.search(htmlText)
recaptchaChallengeId = recaptchaChallengeResult.group(1)
imgUrl = 'http://www.google.com/recaptcha/api/' + imgResult.group(1)
return (recaptchaChallengeId, imgUrl)
def prepareContent(self):
htmlText = self.downloadContent()
parsedData = self.parseContent(htmlText)
self.recaptchaChallengeId = parsedData[0]
with open(Settings.captchaPath, 'wb') as imageFile:
r = requests.get(parsedData[1])
imageFile.write(r.content)
def displayContent(self, invoker):
self._contentSpace.clear_widgets()
self._contentSpace.size_hint=(1, 1)
self._contentSpace.size=(0,0)
try:
self.prepareContent()
if not self.dateField:
self.dateField = TextInput(multiline=False, size_hint=(1,None), size=(0,30))
hlayoutSetDate = BoxLayout(orientation='horizontal', size_hint_y=0.2)
hlayoutSetDate.add_widget(Button(text='Today', on_press=lambda x: self.setDate('today')))
hlayoutSetDate.add_widget(Button(text='Tomorrow', on_press=lambda x: self.setDate('tomorrow')))
self._contentSpace.add_widget(hlayoutSetDate)
self._contentSpace.add_widget(self.dateField)
self.captchaImage = Image(source=Settings.captchaPath, nocache=True)
self._contentSpace.add_widget(Button(text='Reload', on_press=self.reloadCaptcha, size_hint_y = 0.2))
self._contentSpace.add_widget(self.captchaImage)
self.captchaResponse = TextInput(multiline=False, size_hint=(1,None), size=(0,30))
self._contentSpace.add_widget(self.captchaResponse)
self._contentSpace.add_widget(Button(text='Submit', on_press=self.postData, size_hint_y=0.3))
except Exception, e:
self._contentSpace.add_widget(Label(text='An error occured.'))
MessagePopup('Error', traceback.format_exc(e))
class DatePicker(BoxLayout,Form):
date=ObjectProperty(date.today())
__stereotype__ = StringProperty('widget')
def on_date(self,sender,value):
self.data['date']=self.transform_date_oerp(value)
self.data['date_display']=self.transform_date_human(value)
self.populate_header()
self.populate_body()
def __init__(self, *args, **kwargs):
super(DatePicker, self).__init__(**kwargs)
self.orientation = "vertical"
self.month_names = (_('Enero'),
_('Febrero'),
_('Marzo'),
_('Abril'),
_('Mayo'),
_('Junio'),
_('Julio'),
_('Agosto'),
_('Septiembre'),
_('Octubre'),
_('Noviembre'),
_('Diciembre'))
if kwargs.has_key("month_names"):
self.month_names = kwargs['month_names']
self.header = BoxLayout(orientation = 'horizontal',
size_hint = (1, 0.2))
self.body = GridLayout(cols = 7)
self.add_widget(self.header)
self.add_widget(self.body)
self.populate_body()
self.populate_header()
if kwargs.has_key("init_vals"):
if kwargs["init_vals"].has_key('date') and kwargs["init_vals"]['date']!='':
self.date=datetime.strptime(kwargs["init_vals"]['date'],'%Y-%m-%d')
self.data['date']=self.transform_date_oerp(self.date)
self.data['date_display']=self.transform_date_human(self.date)
def populate_header(self, *args, **kwargs):
self.header.clear_widgets()
previous_month = Button(text = "<")
previous_month.bind(on_press=partial(self.move_previous_month))
next_month = Button(text = ">")
next_month.bind(on_press=partial(self.move_next_month))
month_year_text = self.month_names[self.date.month -1] + ' ' + str(self.date.year)
current_month = Label(text=month_year_text, size_hint = (2, 1))
self.header.add_widget(previous_month)
self.header.add_widget(current_month)
self.header.add_widget(next_month)
def populate_body(self, *args, **kwargs):
self.body.clear_widgets()
date_cursor = date(self.date.year, self.date.month, 1)
for filler in range(date_cursor.isoweekday()-1):
self.body.add_widget(Label(text=""))
while date_cursor.month == self.date.month:
date_label = Button(text = str(date_cursor.day))
date_label.bind(on_press=partial(self.set_date,day=date_cursor.day))
if self.date.day == date_cursor.day:
date_label.background_normal, date_label.background_down = date_label.background_down, date_label.background_normal
self.body.add_widget(date_label)
date_cursor += timedelta(days = 1)
def set_date(self, *args, **kwargs):
self.date = date(self.date.year, self.date.month, kwargs['day'])
self.populate_body()
self.populate_header()
def move_next_month(self, *args, **kwargs):
if self.date.month == 12:
self.date = date(self.date.year + 1, 1,min(self.date.day,calendar.monthrange(self.date.year,1)[1]) )
else:
self.date = date(self.date.year, self.date.month + 1,min(self.date.day,calendar.monthrange(self.date.year, self.date.month +1)[1]))
self.populate_header()
self.populate_body()
def move_previous_month(self, *args, **kwargs):
if self.date.month == 1:
self.date = date(self.date.year - 1, 12, min(self.date.day,calendar.monthrange(self.date.year,12)[1]))
else:
self.date = date(self.date.year, self.date.month -1, min(self.date.day,calendar.monthrange(self.date.year, self.date.month -1)[1]))
self.populate_header()
self.populate_body()
def transform_date_oerp(self, date):
select_date = str(date.year)+'-'+str(date.month).zfill(2)+'-'+str(date.day).zfill(2)
return select_date
def transform_date_human(self, date):
select_date = str(date.day).zfill(2)+'-'+str(date.month).zfill(2)+'-'+str(date.year)
return select_date
class LeafScreen(Screen):
def on_pre_enter(self):
self.clear_widgets()
self.leafLayout = BoxLayout(orientation = 'vertical')
self.readMode()
#self.editMode()
self.add_widget(self.leafLayout)
self.win = Window
self.win.bind(on_keyboard=self.keyboardHandler)
self.leafLayout.bind(
size=self._update_rect,
pos=self._update_rect)
with self.leafLayout.canvas.before:
Color(0.5, 0.8, 1, 0.9)
self.rect = Rectangle(
size=self.leafLayout.size,
pos=self.leafLayout.pos)
def _update_rect(self, instance, value):
self.rect.pos = instance.pos
self.rect.size = instance.size
def on_pre_leave(self):
self.win.unbind(on_keyboard=self.keyboardHandler)
def keyboardHandler(self, window, keycode1, keycode2, text, modifiers):
if keycode1 == systemBtnBack:
self.back()
return True
return False
def readMode(self, *args):
self.leafLayout.clear_widgets()
# top
btnBack = Button(text='Back', size_hint_x=0.1)
capture = Label(text=tree.curItem().name, size_hint_x=0.8, color = color['lblPath'])
btnEdit = Button(text='Edit', size_hint_x=0.1)
topLayout = BoxLayout(size_hint_y = 0.1)
topLayout.add_widget(btnBack)
topLayout.add_widget(capture)
topLayout.add_widget(btnEdit)
self.leafLayout.add_widget(topLayout)
btnBack.bind(on_press=self.back)
# Content
self.textField = TextInputForScroll(
size_hint_y=None,
text=tree.curItem().read(),
background_color = color['readLeaf'],
readonly = True,
focus = True)
self.textField.on_text()
textFieldScroll = ScrollView( bar_width = 10)
textFieldScroll.add_widget(self.textField)
self.leafLayout.add_widget(textFieldScroll)
btnEdit.bind(on_release=self.editMode)
def editMode(self, *args):
self.leafLayout.clear_widgets()
# top
btnBack = Button(text='Back', size_hint_x=0.1)
capture = Label(text=tree.curItem().name, size_hint_x=0.8, color = color['lblPath'])
btnSave = Button(text='Save', size_hint_x=0.1)
topLayout = BoxLayout(size_hint_y = 0.1)
topLayout.add_widget(btnBack)
topLayout.add_widget(capture)
topLayout.add_widget(btnSave)
self.leafLayout.add_widget(topLayout)
btnBack.bind(on_press=self.back)
# Content
self.textField = TextInput(
text=tree.curItem().read(),
background_color = color['editLeaf'],
focus = True)
self.leafLayout.add_widget(self.textField)
btnSave.bind(on_release=self.readMode,
on_press=self.save)
def save(self, *args):
tree.curItem().write(self.textField.text)
def back(self, *args):
if sm.current == "leafScreen" :
self.save()
if not tree.reachRoot():
tree.down()
sm.transition = SlideTransition(direction='right')
sm.current = 'mainScreen'
class LunchScreen(Screen):
def __init__(self, **kwargs):
result = super(LunchScreen, self).__init__(**kwargs)
layout = BoxLayout(orientation='vertical')
backButton = Button(text='<<<', size_hint=(1, 0.1))
scroll = ScrollView(size_hint=(1,1))
self._contentSpace = BoxLayout(orientation='vertical')
scroll.add_widget(self._contentSpace)
backButton.bind(on_press=self.goBack)
layout.add_widget(backButton)
layout.add_widget(scroll)
self.add_widget(layout)
self.bind(on_enter=self.displayContent)
return result
def goBack(self, invoker):
self.manager.current="Menu"
def downloadContent(self):
url = 'http://www.gymnaziumtrencin.sk/stravovanie/jedalny-listok.html?page_id=198'
htmlRequest = requests.get(url)
htmlRequest.encoding = 'utf-8'
return htmlRequest.text
def parseContent(self, htmlText):
# Cut out only the data that are needed to improve performance later
dateRegex = re.compile('<h2>Od\s([\d]+)[.]([\d]+)[.](\d+)\sdo\s([\d]+)[.]([\d]+)[.](\d+)<\/h2>', re.UNICODE)
cutLunchDataRegex = re.compile('<table\s+class=["]obed_menu["]\s*>(.*?)</table>', re.DOTALL | re.UNICODE)
soupRegex = re.compile('<td\s+class=["]v_align["]\s*>(.*)<\/td>', re.UNICODE)
mealRegex = re.compile('<td>(.*?)<\/td>', re.DOTALL | re.UNICODE)
dateResult = dateRegex.search(htmlText)
if not dateResult:
#TODO: Error
return None
cutLunchDataResult = cutLunchDataRegex.search(htmlText, dateResult.end())
if not cutLunchDataResult:
#TODO: Error
return None
dateStart = datetime.date(day=int(dateResult.group(1)), month=int(dateResult.group(2)), year=int(dateResult.group(3)))
dateEnd = datetime.date(day=int(dateResult.group(4)), month=int(dateResult.group(5)), year=int(dateResult.group(6)))
cutLunchData = cutLunchDataResult.group(1)
searchStart = 0
lunches = []
for i in range(5):
soupResult = soupRegex.search(cutLunchData, searchStart)
if not soupResult:
#TODO: Error
return None
searchStart = soupResult.end()
mealResult = mealRegex.search(cutLunchData, searchStart)
if not mealResult:
#TODO: Error
return None
searchStart = mealResult.end()
soupText = soupResult.group(1).strip()
mealText = mealResult.group(1).strip()
lunches.append(Lunch(i, soupText, mealText))
return LunchWeek(dateStart, dateEnd, lunches)
def prepareContent(self):
htmlText = self.downloadContent()
return self.parseContent(htmlText)
def displayContent(self, invoker):
self._contentSpace.clear_widgets()
self._contentSpace.size_hint=(1, 1)
self._contentSpace.size=(0,0)
try:
self._contentSpace(self.prepareContent().kivy())
except Exception, e:
self._contentSpace.add_widget(Label(text='An error occured.'))
MessagePopup('Error', traceback.format_exc(e))
class ScrollBox(ScrollView):
orientation = StringProperty("default")
spacing = NumericProperty(10)
padding = NumericProperty(10)
def __init__(self, **kwargs):
self.layout = BoxLayout()
super(ScrollBox, self).__init__(size_hint=(1,1), **kwargs)
self.layout.height = 0
self.layout.width = 0
super(ScrollBox, self).add_widget(self.layout)
def on_orientation(self, w, val):
if not hasattr(self, "layout"):
return
self.layout.orientation = val
if val == 'vertical':
self.layout.size_hint_y = None
self.layout.width = self.width
else:
self.layout.size_hint_x = None
self.layout.height = self.height
self.update_layout_size()
def on_spacing(self, w, val):
self.layout.spacing = val
def on_padding(self, w, val):
self.layout.padding = val
def add_widget(self, w, index=0):
self.layout.add_widget(w, index)
self.update_layout_size()
def remove_widget(self, w):
self.layout.remove_widget(w)
self.update_layout_size()
'''
def collide_point(self, x, y):
print self.pos, x, y
super(ScrollBox, self).collide_point(x, y+self.height)
'''
def update_layout_size(self):
if self.layout.orientation == 'vertical':
self.layout.width = self.width
self.layout.height = self.layout.padding[0]
self.layout.size_hint_y = None
else:
self.layout.height = self.height
self.layout.width = self.layout.padding[0]
self.layout.size_hint_x = None
for i in self.layout.children:
if self.layout.orientation == 'vertical':
self.layout.height += i.height + self.layout.spacing
else:
self.layout.width += i.width + self.layout.spacing
def on_size(self, w, val):
self.update_layout_size()
def clear(self):
self.scroll_y = 1
self.layout.clear_widgets()
self.layout.width = 0
self.layout.height = 0
class MITMs1(Screen):
def __init__(self,**kwargs):
super(MITMs1,self).__init__(**kwargs)
self.iface_name = self.ids['iface_name']
self.device_lbl = self.ids['device_lbl']
self.client_box = self.ids['client_box']
self.nodes = self.ids['nodes']
self.scan_arp_btn = self.ids['scan_arp_btn']
self.save_results_btn = self.ids['save_results_btn']
self.arps = [] #contain ARP's responses
def run_ifconfig(self):
try:
self.scan_arp_btn.disabled = False
self.ifconfig = check_output(['ifconfig', self.iface_name.text])
self.iface, self.IP, self.MAC, self.Bcast, self.Nmask, self.IPv6 = \
(self.ifconfig.split()[i] for i in (0,6,4,7,8,11))
self.device_lbl.text = '[color=00ff00][i][b]My Device[/b][/i][/color] \n\n' +\
'Interface: [color=00ff00][i]{0}[/i][/color] \n\n'.format(self.iface) +\
'IP: [color=00ff00][i]{0}[/i][/color] \n\n'.format(self.IP[5:]) +\
'IPv6: [color=00ff00][i]{0}[/i][/color] \n\n'.format(self.IPv6) +\
'Bcast: [color=00ff00][i]{0}[/i][/color] \n\n'.format(self.Bcast[6:]) +\
'Nmask: [color=00ff00][i]{0}[/i][/color] \n\n'.format(self.Nmask[5:]) +\
'MAC: [color=00ff00][i]{0}[/i][/color] \n\n'.format(self.MAC)
except:
pass
def ARP_scan(self):
network_ip = '192.168.40.'
self.nodes.clear_widgets()
self.arps = []
for i in range(1,255):
scanNode = ArpScan(self.arps, self.nodes , network_ip + str(i) , self.iface)
scanNode.start()
print 'Thread %s'%i
def now(self):
now = time.localtime(time.time())
return time.asctime(now)
def save_results(self):
self.box = BoxLayout(orientation = 'vertical')
self.input_lb = TextInput(text = 'Untitled', multiline = False, on_text_validate = self.save_file)
self.btn_lb = Button(text = 'Save Results', size_hint = (1, None), height = 50, on_release = self.save_file)
self.box.add_widget(self.input_lb)
self.box.add_widget(self.btn_lb)
self.popup = Popup(content = self.box, title = 'Save Scan Results', size_hint = (.7, .7))
self.popup.open()
def save_file(self,obj):
filename = self.input_lb.text
if filename == None: return
f = open(filename,'w')
content = '[*] Lan Scan \n\n' + self.now() + '\n\n%s Hosts Up!'%len(self.arps) + '\n\n'
for arp in self.arps:
content += 'IP : %s\nMAC:%s\n\n'%(arp.psrc,arp.hwsrc)
self.box.clear_widgets()
try:
f.write(content)
self.box.add_widget(Label(text = 'File saved in : %s'%(os.getcwd() + '/' + filename)))
self.box.add_widget(Button(text = 'Close', size_hint = (1, None), height = 50, on_release = self.popup.dismiss))
except:
self.box.add_widget(Label(text = 'Error while writting file : %s'%filename))
self.box.add_widget(Button(text = 'Close', size_hint = (1, None), height = 50, on_release = self.popup.dismiss))
@staticmethod
def change_screen(obj):
sm.current = 'MITMs2'
MITMs1.itf_inform = obj.text
MITMs1.logo = obj.background_normal
@staticmethod
def load_string(obj):
obj.itf_box.clear_widgets()
logo_3d_file = {'Image/Node/gatewayNode.png' : 'Image/3dLogo/gateSpin.zip',
'Image/Node/windowsNode.png' : 'Image/3dLogo/winSpin.zip',
'Image/Node/appleNode.png' : 'Image/3dLogo/appleSpin.zip',
'Image/Node/androidNode.png' : 'Image/3dLogo/andSpin.zip',
'Image/Node/linuxNode.png' : 'Image/3dLogo/linuxSpin.zip',
'Image/Node/unknownNode.png' : 'Image/3dLogo/unkSpin.zip'}
logo_3d = logo_3d_file[MITMs1.logo]
obj.itf_box.add_widget(Image(source = logo_3d, anim_delay = 1/80, pos_hint = {'x': -.4}, size_hint = (1, .2)))
obj.itf_box.add_widget(Label(text = MITMs1.itf_inform, markup = True))
class ScrollableButtonStack(BoxLayout):
def __init__(self, *args, **kwargs):
data = kwargs.get("data", [])
if data: del(kwargs["data"])
kwargs["orientation"] = "horizontal"
super(ScrollableButtonStack, self).__init__(*args, **kwargs)
self.sv = ScrollView(size_hint=(0.9,1))
self.buttonstack = BoxLayout(orientation="vertical", size_hint=(1,None), spacing=2)
self.sv.add_widget(self.buttonstack)
self.add_widget(self.sv)
self.alphaidx = {}
self.alphabet = BoxLayout(orientation="vertical", size_hint=(0.1,1), spacing=0)
for i in string.uppercase:
btn = Button(text=i, size_hint=(1,1.0/len(string.uppercase)), background_color=(0,0,0,1))
self.alphabet.add_widget(btn)
btn.bind(on_touch_move=self.alphatouch)
btn.bind(on_touch_down=self.alphatouch)
self.add_widget(self.alphabet)
self.UNIQUIFIER = 0
self.set_data(data)
def alphatouch(self, btn, pos):
if btn.collide_point(*pos.pos):
uni = self.alphaidx.get(btn.text)
if uni:
Clock.schedule_once(lambda x: self._scroll_to_uniquifier(uni), 0.01)
def set_data(self, data):
self.sv.remove_widget(self.buttonstack)
self.buttonstack.clear_widgets()
self.buttonstack.height = BUTTONHEIGHT * len(data)
self.alphaidx = {}
for i in data:
nd = i.copy()
nd["unique"] = self.UNIQUIFIER
self.UNIQUIFIER += 1
nd["open"] = False
first = i["text"][0].upper()
if first not in self.alphaidx:
self.alphaidx[first] = nd["unique"]
b = ButtonWithData(text=i["text"], size_hint_x=0.8, size_y=BUTTONHEIGHT, data=nd)
self.buttonstack.add_widget(b)
b.bind(on_press=self.toggle_open)
self.sv.add_widget(self.buttonstack)
def _get_button_at_top_uniquifier(self):
print "gbatu"
if not self.buttonstack.children: return None
scrollable_height = self.buttonstack.height - self.height
if scrollable_height < 0:
return self.buttonstack.children[0].data["unique"]
scrolled_px = scrollable_height * (1-self.sv.scroll_y)
widget_idx_at_top = int(round(float(scrolled_px) / BUTTONHEIGHT))
# but buttonstack.children is in reverse order, so
widget_idx_at_top = len(self.buttonstack.children) - widget_idx_at_top - 1
print "saving uniq", self.buttonstack.children[widget_idx_at_top].data["unique"]
return self.buttonstack.children[widget_idx_at_top].data["unique"]
def _scroll_to_uniquifier(self, uni):
print "stu"
if uni is None: return
scrollable_height = self.buttonstack.height - self.height
idx = None
counter = 0
for c in self.buttonstack.children:
if c.data["unique"] == uni:
idx = counter
break
counter += 1
if idx is None:
return
# but buttonstack.children is in reverse order, so
idx = len(self.buttonstack.children) - idx - 1
scroll_position = (idx * BUTTONHEIGHT) / scrollable_height
print "scroll to widget uni", uni, "which is idx", idx, " posn", scroll_position
Clock.schedule_once(lambda x: self.scroll_now_to(scroll_position), 2)
def scroll_now_to(self, scroll_position):
print "scroll now to"
self.sv.scroll_y = 1-scroll_position
def toggle_open(self, button):
print "toggling open", button, button.data
uni = self._get_button_at_top_uniquifier()
if button.data["open"]:
# remove all children of this button
print "Removing children"
to_remove = [x for x in self.buttonstack.children
if x.owner_button
and x.owner_button.data["unique"] == button.data["unique"]]
self.buttonstack.height -= len(to_remove) * BUTTONHEIGHT
for w in to_remove:
self.buttonstack.remove_widget(w)
button.data["open"] = False
else:
print "Collapsing all others"
to_remove = [x for x in self.buttonstack.children
if x.owner_button]
self.buttonstack.height -= len(to_remove) * BUTTONHEIGHT
for w in to_remove:
self.buttonstack.remove_widget(w)
print "Expanding"
insert_idx = 0
count = 0
for w in self.buttonstack.children:
if w.data["unique"] == button.data["unique"]:
insert_idx = count
break
count += 1
self.buttonstack.height += 1 * BUTTONHEIGHT
nd = {
"unique": "load tracks",
}
self.UNIQUIFIER += 1
nbtn = ButtonWithData(text="loading...",
size_hint_x=1, size_y=BUTTONHEIGHT, data=nd, owner_button=button)
self.buttonstack.add_widget(nbtn, index=insert_idx)
self.owner_app.mpc.send(("list_tracks", button.data["unique"]), 'find artist "%s"\n' % button.data["text"])
button.data["open"] = True
self._scroll_to_uniquifier(uni)
def load_tracks(self, tracks):
# remove the loading button, if present, and get its index
loading_button = None
counter = 0
insert_idx = None
for b in self.buttonstack.children:
if b.data["unique"] == "load tracks":
insert_idx = counter
loading_button = b
break
counter += 1
if not loading_button: return
print "removing loading button at idx", insert_idx
owner = loading_button.owner_button
self.buttonstack.remove_widget(loading_button)
for t in tracks:
nd = {
"unique": self.UNIQUIFIER,
}
nd.update(t)
self.UNIQUIFIER += 1
nbtn = ButtonWithData(text=t.get("Title", t.get("file")),
size_hint_x=0.8, pos_hint={'right':1.0}, size_y=BUTTONHEIGHT, data=nd, owner_button=owner)
nbtn.bind(on_press=self.queue_song)
self.buttonstack.add_widget(nbtn, index=insert_idx)
def queue_song(self, button):
print "queueing song", button.data
self.owner_app.mpc.send("add", 'add "%s"\n' % button.data["file"])
self.owner_app.mpc.send("play", "play\n")
class HexTap(App):
def __init__(self, **kwargs):
super(HexTap, self).__init__(**kwargs)
self.difficulty = 1
self.first_run = True
self.current_state = 'mainMenu'
self.content = BoxLayout()
self.main_menu = MainMenu()
self.help_menu = HelpMenu()
self.game_map = None
self.content.add_widget(self.main_menu)
self.music = SoundLoader.load('assets/audio/music.ogg')
self.soundsOption = True
self.musicOption = False
self.hardcoreOption = False
def safe_options_loading(self):
if type(self.soundsOption) == bool or type(self.soundsOption) == int:
pass
elif self.soundsOption == 'True' or '1' in self.soundsOption:
self.soundsOption = True
else:
self.soundsOption = False
if type(self.musicOption) == bool or type(self.musicOption) == int:
pass
elif self.musicOption == 'True' or '1' in self.musicOption:
self.musicOption = True
else:
self.musicOption = False
if type(self.hardcoreOption) == bool or type(self.hardcoreOption) == int:
pass
elif self.hardcoreOption == 'True' or '1' in self.hardcoreOption:
self.hardcoreOption = True
else:
self.hardcoreOption = False
def build(self):
self.use_kivy_settings = False
self.soundsOption = self.config.get('sound', 'soundsOption')
self.musicOption = self.config.get('sound', 'musicOption')
self.hardcoreOption = self.config.get('game', 'hardcoreOption')
self.safe_options_loading()
Clock.schedule_interval(self.update, 1. / 1.5)
return self.content
def show_help(self):
self.content.clear_widgets()
self.content.add_widget(self.help_menu)
def generate_main_menu(self):
self.content.clear_widgets()
self.content.add_widget(self.main_menu)
def new_game(self):
if use_ads:
revmob.show_popup()
self.content.clear_widgets()
self.content.add_widget(Image(source='assets/graphics/ui/loading.png', size=Window.size, allow_stretch=True))
Clock.schedule_once(self.post_splash)
def post_splash(self, dt):
rows, cols = map_sizes[self.difficulty-1]
self.game_map = MapCanvas(cols, rows, self.difficulty, self.hardcoreOption, self.soundsOption,
self.musicOption)
self.content.clear_widgets()
self.content.add_widget(self.game_map)
def update(self, dt):
if self.main_menu.start_game:
self.new_game()
self.main_menu.start_game = False
if self.main_menu.show_help:
self.show_help()
self.main_menu.show_help = False
if self.help_menu.back_to_main:
self.generate_main_menu()
self.help_menu.back_to_main = False
if self.game_map and self.game_map.return_to_menu:
self.generate_main_menu()
self.game_map.return_to_menu = False
if self.musicOption and self.music.state == 'stop':
self.music.play()
elif not self.musicOption and self.music.state == 'play':
self.music.stop()
def build_config(self, config):
try:
config.setdefaults('sound', {
'musicOption': '0',
'soundsOption': '1'
})
config.setdefaults('game', {
'hardcoreOption': '0'
})
except TypeError:
config.setdefaults('sound', {
'musicOption': False,
'soundsOption': True
})
config.setdefaults('game', {
'hardcoreOption': False
})
def build_settings(self, settings):
settings.add_json_panel('hexTap options', self.config, data=settings_json)
def on_config_change(self, config, section, key, value):
if key == 'musicOption':
if type(value) == bool or type(value) == int:
self.musicOption = value
elif value == 'True' or '1' in value:
self.musicOption = True
else:
self.musicOption = False
elif key == 'soundsOption':
if type(value) == bool or type(value) == int:
self.soundsOption = value
elif value == 'True' or '1' in value:
self.soundsOption = True
else:
self.soundsOption = False
elif key == 'hardcoreOption':
if type(value) == bool or type(value) == int:
self.hardcoreOption = value
elif value == 'True' or '1' in value:
self.hardcoreOption = True
else:
self.hardcoreOption = False
def on_pause(self):
return True
def on_resume(self):
pass
class RemoteControlUI(BoxLayout):
"""The main app layout
"""
# Auth properties
login = StringProperty(u'')
password = StringProperty(u'')
host = StringProperty('')
# Represents the last command which was accepted
last_accepted_command = StringProperty('')
# Bound to the "Info" label
info_text = StringProperty('')
# Command execution confirmation flag
need_confirm = BooleanProperty(True)
def __init__(self, **kwargs):
# ID of the command being executed
self._cmd_id = None
# List of the "completed" statuses.
# The first status should be "Done"
self._completed = []
# If True - sends a request to retrieve a command status
self._wait_completion = False
# requested command
self._command = (0, '')
super(RemoteControlUI, self).__init__(
orientation='vertical', spacing=2, padding=3, **kwargs)
# Control buttons panel
pnl_controls = BoxLayout(size_hint_y=None, height=metrics.dp(35))
pnl_controls.add_widget(
Button(text='Refresh', on_release=self._get_commands))
pnl_controls.add_widget(
Button(text='Close', on_release=App.get_running_app().stop))
self.add_widget(pnl_controls)
# Command buttons panel
self._pnl_commands = BoxLayout(orientation='vertical')
self.add_widget(self._pnl_commands)
# Info panel
lbl_info = Label(
text=self.info_text, size_hint_y=None, height=metrics.dp(35))
self.bind(info_text=lbl_info.setter('text'))
self.add_widget(lbl_info)
# ============= HTTP REQUEST ==============
def _get_auth(self):
# Encodes basic authorization data
cred = ('%s:%s' % (self.login, self.password))
return 'Basic %s' %\
base64.b64encode(cred.encode('ascii')).decode('ascii')
def _send_request(self, url, success=None, error=None, params=None):
headers = {
'User-Agent': 'Mozilla/5.0',
'Content-type': 'application/json',
'Authorization': self._get_auth()
}
UrlRequest(
url=self.host + url, timeout=30, req_headers=headers,
req_body=None if params is None else dumps(params),
on_success=success, on_error=error, on_failure=error)
# =========== GET COMMAND LIST ===========
def _get_commands(self, instance=None):
# Implements API-call "Get available command list"
self._progress_start('Trying to get command list')
self._send_request(
'commands_available/', params=[],
success=self._get_commands_result, error=self._get_commands_error)
def _get_commands_result(self, request, response):
# Parses API-call response
try:
self._pnl_commands.clear_widgets()
# Create command buttons
for code, command in sorted(
response['commands'].items(),
key=lambda x: int(x[0])):
btn = Button(
id=code, text=command, on_release=self._btn_command_click)
self._pnl_commands.add_widget(btn)
self._completed = response['completed']
# Save correct host and login in the app configuration
App.get_running_app().config.set('auth', 'login', self.login)
App.get_running_app().config.set('auth', 'host', self.host)
self._progress_complete('Command list received successfully')
except Exception as e:
self._get_commands_error(request, str(e))
def _get_commands_error(self, request, error):
self._progress_complete()
XError(text=str(error)[:256], buttons=['Retry', 'Re-enter', 'Exit'],
on_dismiss=self._get_commands_error_dismiss)
def _get_commands_error_dismiss(self, instance):
if instance.button_pressed == 'Exit':
App.get_running_app().stop()
elif instance.button_pressed == 'Re-enter':
self._login()
elif instance.button_pressed == 'Retry':
self._get_commands()
# ============= SEND COMMAND =============
def _btn_command_click(self, button):
self._command = (button.id, button.text)
if self.need_confirm:
XConfirmation(
text='Send command "%s" ?' % button.text,
on_dismiss=self._send_command)
else:
self._send_command(None)
def _send_command(self, instance):
# Implements API-call "Create command"
if instance and not instance.is_confirmed():
return
self._cmd_id = None
self._wait_completion = True
self._progress_start('Processing command "%s"' % self._command[1])
self._send_request(
'commands/', params={'code': self._command[0]},
success=self._send_command_result, error=self._send_command_error)
def _send_command_result(self, request, response):
# Parses API-call response
try:
if response['status'] not in self._completed:
# Executing in progress
self._cmd_id = response['id']
if self._wait_completion:
Clock.schedule_once(self._get_status, 1)
else:
# Command "completed"
if response['status'] == self._completed[0]:
self.last_accepted_command = response['code_dsp']
self._progress_complete(
'Command "%s" is %s' %
(response['code_dsp'], response['status_dsp']))
except Exception as e:
XError(text=str(e)[:256])
def _send_command_error(self, request, error):
self._progress_complete()
XError(text=str(error)[:256])
# ========== GET COMMAND STATUS ==========
def _get_status(self, pdt=None):
# Implements API-call "Get command status"
if not self._cmd_id:
return
self._send_request(
'commands/%s/' % self._cmd_id, success=self._send_command_result,
error=self._send_command_error)
# ============= LOGIN POPUP ==============
def _login(self):
AuthEx(login=self.login, password=self.password, host=self.host,
autologin=None, pos_hint={'top': 0.99},
on_dismiss=self._login_dismiss)
def _login_dismiss(self, instance):
if instance.is_canceled():
App.get_running_app().stop()
return
self.login = instance.get_value('login')
self.password = instance.get_value('password')
self.host = instance.get_value('host')
self._get_commands()
# ============= PROGRESS BAR ==============
def _progress_start(self, text):
self.popup = XProgress(
title='RemoteControl', text=text, buttons=['Close'],
on_dismiss=self._progress_dismiss)
self.popup.autoprogress()
def _progress_dismiss(self, instance):
self._wait_completion = False
def _progress_complete(self, text=''):
if self.popup is not None:
self.popup.complete(text=text, show_time=0 if text is None else 1)
# =========================================
def on_last_accepted_command(self, instance, value):
self.info_text = 'Last accepted command: %s' % value
App.get_running_app().config.set(
'common', 'last_accepted_command', value)
def start(self):
if not self.login or not self.password or not self.host:
self._login()
else:
self._get_commands()
class KiPyKeyboard( BoxLayout ) :
def __init__( self, handlerfoo, plotfoo ) :
BoxLayout.__init__( self, orientation="vertical" )
inp = BoxLayout( orientation="horizontal" )
inp.padding = 1
self.current = TextInput( text=u"" )
self.current.font_name = FONT_NAME
self.current.font_size = FONT_SIZE
self.current.size_hint = 0.85, 1
inp.add_widget( self.current )
btnExec = Button( text="Exec()" )
btnExec.font_name = FONT_NAME
btnExec.font_size = FONT_SIZE
btnExec.bind( on_press=handlerfoo )
btnPlot = Button( text="Plot!" )
btnPlot.font_name = FONT_NAME
btnPlot.font_size = FONT_SIZE
btnPlot.bind( on_press=plotfoo )
b = BoxLayout( orientation="vertical" )
b.add_widget( btnExec )
b.add_widget( btnPlot )
b.size_hint = 0.25, 1
inp.add_widget( b )
self.static_keys = BoxLayout( orientation="vertical" )
self.loadStaticKeys()
self.numpad = GridLayout( cols=4 )
self.loadNumpad()
self.numpad.size_hint = 0.6, 1
self.symbols = GridLayout( cols=4 )
self.loadSymbols()
self.symbols.size_hint = 0.6, 1
self.foo1 = GridLayout( cols=2 )
self.loadFoo1()
self.foo1.size_hint = 0.4, 1
self.foo2 = GridLayout( cols=2 )
self.loadFoo2()
self.foo2.size_hint = 0.4, 1
self.kb = BoxLayout( orientation="horizontal" )
self.kb.size_hit = 1, 0.33
self.static_keys.size_hit = 1, 0.33
inp.size_hint = 1, 0.6
self.add_widget( inp )
self.add_widget( self.static_keys )
self.add_widget( self.kb )
self.shiftCount = -1
self.onShift()
def loadStaticKeys( self ) :
k1 = "<- space tab \\n ->".split( " " )
k2 = "{ [ ( , ) ] }".split( " " )
k3 = "evalf ans print undo clear shift".split( " " )
k4 = "+ - * / ** =".split( " " ) + [ u"√" ]
default_keys = ( k1, k2, k3, k4 )
for keySet in default_keys :
k = BoxLayout( orientation="horizontal" )
loadButtonsFromString( k, keySet, self.onBtnPress )
self.static_keys.add_widget( k )
def loadNumpad( self ) :
keySet = "1 2 3 4 5 6 7 8 9 0 . I E".split( " " ) + [ u"π", "10**", "E**" ]
loadButtonsFromString( self.numpad, keySet, self.onBtnPress )
def loadSymbols( self ) :
keySet = "x y z t T w a b c d f g k . I E".split( " " )
loadButtonsFromString( self.symbols, keySet, self.onBtnPress )
def loadFoo1( self ) :
keySet = "cos sin tan Ln Log diff".split( " " )
loadButtonsFromString( self.foo1, keySet, self.onBtnPress )
def loadFoo2( self ) :
keySet = "aCos aSin aTan aTan2 Lim".split( " " ) + [ u"∫" ]
loadButtonsFromString( self.foo2, keySet, self.onBtnPress )
def onShift( self ) :
self.shiftCount += 1
if self.shiftCount == 2 : self.shiftCount = 0
self.kb.clear_widgets()
if self.shiftCount == 0 :
self.kb.add_widget( self.foo1 )
self.kb.add_widget( self.numpad )
elif self.shiftCount == 1 :
self.kb.add_widget( self.foo2 )
self.kb.add_widget( self.symbols )
def onBtnPress( self, instance ) :
command = instance.text
toInsert = ""
if command == u"√" : toInsert = "sqrt( ans )"
elif command == u"∫" : toInsert = "integrate( ans, x )"
elif command == "diff" : toInsert = "diff( ans, x )"
elif command == "cos" : toInsert = "cos( ans )"
elif command == "aCos" : toInsert = "acos( ans )"
elif command == "sin" : toInsert = "sin( ans )"
elif command == "aSin" : toInsert = "asin( ans )"
elif command == "tan" : toInsert = "tan( ans )"
elif command == "aTan" : toInsert = "atan( ans )"
elif command == "aTan2" : toInsert = "atan2( ans )"
elif command == "coTan" : toInsert = "cot( ans )"
elif command == "Lim" : toInsert = "limit( ans, x, n )"
elif command == "Log" : toInsert = "log( ans )"
elif command == "Ln" : toInsert = "ln( ans )"
elif command == "evalf" : toInsert = "evalf()"
elif command == u"π" : toInsert = "pi"
elif command == "clear" : self.current.text = u""
elif command == "space" : toInsert = " "
elif command == "shift" : self.onShift()
elif command == "\\n" : toInsert = "\n"
elif command == "tab" : toInsert = " "
elif command == "\\t" : toInsert = " "
elif command == "print" : toInsert = "pprint( ans )"
elif command == "<-" : self.current.do_cursor_movement( 'cursor_left' )
elif command == "->" : self.current.do_cursor_movement( 'cursor_right' )
elif command == "undo" : self.current.do_undo()
#all the rest...
else :
toInsert = command
self.current.insert_text( toInsert )
def flush( self ) :
self.current.text = ""
class MakeTable(BoxLayout):
def appeandtotable(self, output, server, table):
for line in output.splitlines():
# print(type(line))
line = line.decode("utf-8")
if line.startswith(' ica-cgp#'):
for i in range(30, 1, -1):
line = line.replace(" " * i, "|")
if line[-1:] == "|":
line = line + server
else:
line = line + "|" + server
cells = line.split("|")
# print(line)
table.append(cells)
# Launches a dialog box for confirming you want to kill a session.
def confirmkillsession(self, instance):
data = instance.__name__
ConfirmPopup(self.killsession,
text='Do You Want To Kill This Session?',
title="Kill Session?",
data=data)
# Kills a windows user session based on the ID
def killsession(self, session):
data = session.split("|")
command = ("LOGOFF {} /server:{}").format(data[0], data[1])
# print(command)
os.system(command)
self.__init__()
# Refreshes the list of users
def refreshsession(self, instance):
instance.text = "Refreshing"
df = self.filldata(self.txtservers.text)
self.databox.clear_widgets()
for index, row in df.iterrows():
if row['SERVER'] is not None:
grid = GridLayout()
grid.cols = 3
btnkill = Button(text="Kill Session: {}".format(row['ID']))
btnkill.__name__ = "{}|{}".format(row['ID'], row['SERVER'])
btnkill.bind(on_press=self.confirmkillsession)
grid.add_widget(btnkill)
lbluser = Label(text=row['USERNAME'])
grid.add_widget(lbluser)
lblserver = Label(text=row['SERVER'])
grid.add_widget(lblserver)
self.databox.add_widget(grid)
instance.text = "Refresh"
print("Refresh")
# Gets the data from a windows QWINSTA command
def filldata(self, svrs):
if len(svrs) > 0:
print(svrs)
servers = svrs.split(" ")
table = []
for server in servers:
try:
output = subprocess.check_output(
"QWINSTA /server:{}".format(server), shell=False)
self.appeandtotable(output, server, table)
except:
print("Server: {} - Does Not Exists".format(server))
if len(table) > 0:
df = pandas.DataFrame(table)
new_header = [
"SESSIONAME", "USERNAME", "ID", "STATE", "TYPE", "SERVER"
]
df.columns = new_header # set the header row as the df header
df = df.sort_values(['USERNAME', "ID", 'SERVER'])
# print(df)
return df
else:
df = pandas.DataFrame()
return df
else:
df = pandas.DataFrame()
return df
# Application Init
def __init__(self, **kwargs):
super(MakeTable, self).__init__(**kwargs)
self.clear_widgets()
self.orientation = 'vertical'
header = BoxLayout()
header.orientation = 'vertical'
servergrid = GridLayout()
servergrid.cols = 3
lblservers = Label(text="Servers: ")
servergrid.add_widget(lblservers)
self.txtservers = TextInput(text='', multiline=True)
servergrid.add_widget(self.txtservers)
header.add_widget(servergrid)
# Loads server names from a file if it exists
fname = "servers.txt"
if os.path.isfile(fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
self.txtservers.text = " ".join(content)
else:
print("No Servers File Found")
btnrefresh = Button(text="Refresh")
btnrefresh.id = "btnRefresh"
btnrefresh.bind(on_press=self.refreshsession)
header.add_widget(btnrefresh)
self.add_widget(header)
self.databox = BoxLayout()
self.databox.clear_widgets()
self.databox.orientation = 'vertical'
self.add_widget(self.databox)
self.refreshsession(self)
class GameScreenView( BoxLayout ):
game = None
startingButton = None
leftPane = None
rightPane = None
def __init__(self, **kwargs):
super().__init__(cols=2,**kwargs)
self.leftPane = BoxLayout()
self.rightPane = BoxLayout(orientation='vertical')
self.add_widget(self.leftPane)
self.add_widget(self.rightPane)
def draw(self):
self.game = self.parent.game
self.size = self.parent.size
self.drawShipPlacementArea()
self.drawShipPort()
def addWidgetToGameScreenViewLeft(self, widgetToAdd):
self.leftPane.add_widget( widgetToAdd )
def addWidgetToGameScreenViewRight(self, widgetToAdd):
self.rightPane.add_widget( widgetToAdd )
def removeWidgetFromGameScreenView(self, widgetToRemove):
if widgetToRemove in self.rightPane.children:
self.rightPane.remove_widget( widgetToRemove )
if widgetToRemove in self.leftPane.children:
self.leftPane.remove_widget( widgetToRemove )
def drawShipPlacementArea(self):
self.game.shipPlacementArea = GridArea()
self.game.activeArea = self.game.shipPlacementArea
self.addWidgetToGameScreenViewLeft( self.game.shipPlacementArea )
self.game.shipPlacementArea.draw(1)
def drawOwnShipGridArea(self):
self.game.ownShipGridArea = GridArea()
self.addWidgetToGameScreenViewRight( self.game.ownShipGridArea )
self.game.ownShipGridArea.draw(2)
def drawEnemyShipGridArea(self):
self.game.enemyShipGridArea = GridArea()
self.addWidgetToGameScreenViewLeft( self.game.enemyShipGridArea )
self.game.enemyShipGridArea.draw(1)
def drawShipPort(self):
self.game.shipPort = ShipPort(game=self.game)
self.addWidgetToGameScreenViewRight( self.game.shipPort )
self.game.shipPort.draw()
def drawStartingButton(self):
self.startingButton = Button(text='ALUSTA MÄNGU!')
self.startingButton.bind(on_press=self.game.startBattle)
self.addWidgetToGameScreenViewRight( self.startingButton )
def drawGameOverText(self, youWon):
self.rightPane.clear_widgets()
print(youWon)
if youWon == True:
text = 'MÄNG LÄBI !!! VÕITSID !'
else:
text = "MÄNG LÄBI !!! Kaotasid.... :'("
self.addWidgetToGameScreenViewRight( Label(font_size='40sp',text=text) )
def removeShipPort(self):
self.removeWidgetFromGameScreenView( self.game.shipPort )
class DatePicker(BoxLayout):
def __init__(self, *args, **kwargs):
super(DatePicker, self).__init__(**kwargs)
self.date = date.today()
self.orientation = "vertical"
self.month_names = ('Январь',
'Февраль',
'Март',
'Апрель',
'Май',
'Июнь',
'Июль',
'Август',
'Сентябрь',
'Октябрь',
'Ноябрь',
'Декабрь')
if"month_names" in kwargs:
self.month_names = kwargs['month_names']
self.header = BoxLayout(orientation='horizontal',
size_hint=(1, 0.2))
self.body = GridLayout(cols=7)
self.add_widget(self.header)
self.add_widget(self.body)
self.populate_body()
self.populate_header()
def populate_header(self, *args, **kwargs):
self.header.clear_widgets()
previous_month = Button(text="<")
previous_month.bind(on_press=partial(self.move_previous_month))
next_month = Button(text=">")
next_month.bind(on_press=partial(self.move_next_month))
month_year_text = self.month_names[self.date.month - 1] + ' ' + str(self.date.year)
current_month = Label(text=month_year_text, size_hint=(2, 1))
self.header.add_widget(previous_month)
self.header.add_widget(current_month)
self.header.add_widget(next_month)
def populate_body(self, *args, **kwargs):
self.body.clear_widgets()
date_cursor = date(self.date.year, self.date.month, 1)
for filler in range(date_cursor.isoweekday() - 1):
self.body.add_widget(Label(text=""))
while date_cursor.month == self.date.month:
date_label = Button(text=str(date_cursor.day))
date_label.bind(on_press=partial(self.set_date,
day=date_cursor.day))
if self.date.day == date_cursor.day:
date_label.background_normal, \
date_label.background_down = date_label.background_down, date_label.background_normal
self.body.add_widget(date_label)
date_cursor += timedelta(days=1)
def set_date(self, *args, **kwargs):
self.date = date(self.date.year, self.date.month, kwargs['day'])
self.populate_body()
self.populate_header()
def move_next_month(self, *args, **kwargs):
if self.date.month == 12:
self.date = date(self.date.year + 1, 1, self.date.day)
else:
self.date = date(self.date.year, self.date.month + 1,
min(self.date.day, calendar.monthrange(self.date.year, self.date.month + 1)[1]))
self.populate_header()
self.populate_body()
def move_previous_month(self, *args, **kwargs):
if self.date.month == 1:
self.date = date(self.date.year - 1, 12, self.date.day)
else:
self.date = date(self.date.year, self.date.month - 1,
min(self.date.day, calendar.monthrange(self.date.year, self.date.month - 1)[1]))
self.populate_header()
self.populate_body()
class Downloads(BoxLayout):
def __init__(self, **kwargs):
super(Downloads, self).__init__(**kwargs)
user_interface.ui.ids.documentCounter.text = str(len(download_identifiers))
del download_buttons[:]
if len(download_identifiers) != 0:
self.layout = BoxLayout(orientation='vertical')
for i in range(0, len(download_identifiers)):
layout1 = BoxLayout()
label = Label(text=download_identifiers[i])
button = Button(text="remove")
button.bind(on_press=self.remove)
download_buttons.append(button)
layout1.add_widget(label)
layout1.add_widget(button)
self.layout.add_widget(layout1)
download_btn = Button(text="download")
download_btn.bind(on_press=self.download)
self.layout.add_widget(download_btn)
self.add_widget(self.layout)
def download(self, instance):
prs = Presentation('template.pptx')
# Left, top, width, height
for i in range(0, len(download_identifiers)):
if i == 0 or i % 2 == 1:
slide = prs.slides[-1]
else:
slide = prs.slides.add_slide(prs.slide_layouts[1])
# Details
if i % 2 == 1:
tx_box1 = slide.shapes.add_textbox(Inches(5.2), Inches(5.5), Inches(4.5), Inches(2))
else:
tx_box1 = slide.shapes.add_textbox(Inches(0.5), Inches(5.5), Inches(4.5), Inches(2))
tf1 = tx_box1.text_frame
tf1.word_wrap = True
run = tf1.paragraphs[0].add_run()
run.text = download_details[i]
run.font.size = Pt(14)
# Stats
if i % 2 == 1:
tx_box2 = slide.shapes.add_textbox(Inches(5.2), Inches(4.2), Inches(4.5), Inches(2))
else:
tx_box2 = slide.shapes.add_textbox(Inches(0.5), Inches(4.2), Inches(4.5), Inches(2))
tf2 = tx_box2.text_frame
tf2.word_wrap = True
run = tf2.paragraphs[0].add_run()
run.text = download_stats[i]
run.font.size = Pt(14)
# Graph
if i % 2 == 1:
slide.shapes.add_picture(download_images[i], Inches(4.8), Inches(1.2), height=Inches(3.0), width=Inches(5.0))
else:
slide.shapes.add_picture(download_images[i], Inches(0.1), Inches(1.2), height=Inches(3.0), width=Inches(5.0))
date = datetime.datetime.now().strftime("%m-%d-%Y")
prs.save(PATH[:-8] + "\\output\\" + date + '.pptx')
del download_identifiers[:]
del download_images[:]
del download_details[:]
del download_stats[:]
self.update()
# update the downloads shown
def update(self):
self.layout.clear_widgets()
user_interface.ui.ids.documentCounter.text = str(len(download_identifiers))
if len(download_identifiers) != 0:
for i in range(0, len(download_identifiers)):
layout1 = BoxLayout()
label = Label(text=download_identifiers[i])
button = Button(text="remove")
button.bind(on_press=self.remove)
download_buttons.append(button)
layout1.add_widget(label)
layout1.add_widget(button)
self.layout.add_widget(layout1)
download_btn = Button(text="download")
download_btn.bind(on_press=self.download)
self.layout.add_widget(download_btn)
# remove the specific download shown
def remove(self, instance):
for i in range(0, len(download_identifiers)):
if download_buttons[i] == instance:
del download_identifiers[i]
del download_details[i]
del download_stats[i]
del download_images[i]
del download_buttons[:]
break
self.update()
class PongGame(Widget):
ball = ObjectProperty(None)
player1 = ObjectProperty(None)
player2 = ObjectProperty(None)
who_wins = StringProperty("")
is_menu = StringProperty("No menu")
#def __init__(self, **kwargs):
# super(PongGame, self).__init__(**kwargs)
# self.menu = None
def serve_ball(self, vel = (4, 0)):
self.ball.center = self.center
self.ball.velocity = vel
def the_menu(self):
self.ball.velocity = 0, 0
self.menu = BoxLayout(orientation = "vertical", center_x = self.center_x, center_y = self.center_y)
lbl = Label(text = "menu")
self.menu.add_widget(lbl)
btn1 = Button(text = "Restart", on_press = self.the_resume)
btn1.bind(on_press = self.the_resume)
btn2 = Button(text = "Exit", on_press = self.get_out)
self.menu.add_widget(btn1)
self.menu.add_widget(btn2)
self.add_widget(self.menu)
def the_resume(self, instance):
self.who_wins = ""
self.player2.score = 0
self.player1.score = 0
self.menu.clear_widgets() #this is not working
self.remove_widget(self.menu) #Neither is this
self.is_menu = "No menu"
if self.who_wins == "Player 2 wins":
vel = (-4, 0)
else:
vel = (4, 0)
self.serve_ball(vel)
def get_out(self, instance):
exit()
def update(self, dt):
self.ball.move()
self.player1.bounce_ball(self.ball)
self.player2.bounce_ball(self.ball)
if (self.ball.y < 0) or (self.ball.top > self.height):
self.ball.velocity_y *= -1
if self.ball.x < self.x:
self.player2.score += 1
self.serve_ball(vel = (4, 0))
if self.ball.x > self.width:
self.player1.score += 1
self.serve_ball(vel = (-4, 0))
if self.who_wins == "":
if self.player2.score >= 1:
self.who_wins = "Player 2 wins"
elif self.player1.score >= 10:
self.who_wins = "Player 1 wins"
elif self.is_menu == "No menu":
self.is_menu = "menu"
self.the_menu()
def on_touch_move(self, touch):
if touch.x < self.width / 3:
self.player1.center_y = touch.y
if touch.x > self.width - self.width / 3:
self.player2.center_y = touch.y
class TimetableScreen(Screen):
def __init__(self, **kwargs):
result = super(TimetableScreen, self).__init__(**kwargs)
layout = BoxLayout(orientation='vertical')
backButton = Button(text='<<<', size_hint=(1, 0.1))
scroll = ScrollView(size_hint=(1,1))
self._contentSpace = BoxLayout(orientation='vertical')
scroll.add_widget(self._contentSpace)
backButton.bind(on_press=self.goBack)
layout.add_widget(backButton)
layout.add_widget(scroll)
self.add_widget(layout)
self.bind(on_enter=self.displayContent)
return result
def goBack(self, invoker):
self.manager.current="Menu"
def downloadContent(self):
# First we need to find correct content according to settings
url = 'http://www.glstn.sk/rozvrh/' + School.timetables[School.classes.index(Settings.schoolClass)]
htmlRequest = requests.get(url)
htmlRequest.encoding = 'windows-1250'
return htmlRequest.text
def parseContent(self, htmlText):
findRegex = re.compile(ur'["][*].*[*](?:[\r\n]*[^"]*)*["]', re.UNICODE)
# 1. part: Between stars [*]
# Capture day and hour (optionaly range of hours in format digit-digit) that are separated by :
# 2. part:
# Resolve if this is one subject or list. This is done by searching for = sign
# 3. part
# Capture last name of teacher
singleRegex = re.compile('[*]\s*(\w*)\s*:\s*(\d)-{0,1}(\d){0,1}\s*[*][\r\n]{1,2}.*=\s*(?:[\w.]+\s+)*(\w+)', re.UNICODE)
# This is run after singleRegex matched, because the information doesn't contain subject
# It should be run from last match position of singleRegex and search for first occurence
# as that will be correct subject for that timetable item
singleSubjectRegex = re.compile('class=["]Predmet["]\s*title=["]([^"=\s]*)[^"]*["]', re.UNICODE)
# Same as above but searches for classroom
singleClassRegex = re.compile('class=["]Ucebna["]\s*title=["]([^"=\s]*)[^"]*["]', re.UNICODE)
# 1. part:
# Same as before
# 2. part:
# Skip all empty lines before 3. part
# 3. part:
# Capture all non-empty lines
listRegex = re.compile('[*]\s*(\w*)\s*:\s*(\d)-{0,1}(\d){0,1}\s*[*](?:[\r\n]{1,2}\s*)*((?:.+[\r\n]{0,2})+)', re.UNICODE)
# 1. part:
# Skip subject group and capture subject in 2nd column, teacher in 3rd column and clasroom in 4th column
listLineRegex = re.compile('[^\s]*\s*([^\s]*)\s*([^\s]*)\s*([^\s]*)', re.UNICODE)
# Now match each item with singleRegex. If failed, try listRegex. If failed, the timetable place is empty
day = ''
startHour = 0
endHour = 0
subject = ''
classroom = ''
teacher = ''
content = []
for item in findRegex.finditer(htmlText):
# Remove quotes from result
itemText = item.group()[1:-1].strip()
singleResult = singleRegex.match(itemText)
if singleResult:
day = singleResult.group(1)
startHour = int(singleResult.group(2))
endHour = int(singleResult.group(3)) if singleResult.group(3) else None
teacher = singleResult.group(4)
subjectResult = singleSubjectRegex.search(htmlText, item.end())
classResult = singleClassRegex.search(htmlText, subjectResult.end())
subject = subjectResult.group(1)
classroom = classResult.group(1)
content.append(TimetableItem(day, startHour, endHour, subject, classroom, teacher))
else:
listResult = listRegex.match(itemText)
if listResult:
day = listResult.group(1)
startHour = int(listResult.group(2))
endHour = int(listResult.group(3)) if listResult.group(3) else None
for line in listResult.group(4).splitlines():
lineResult = listLineRegex.match(line.strip())
subject = lineResult.group(1).strip()
teacher = lineResult.group(2)
classroom = lineResult.group(3)
content.append(TimetableItem(day, startHour, endHour, subject, classroom, teacher))
return content
def prepareContent(self):
htmlText = self.downloadContent()
return self.parseContent(htmlText)
def filterBy(self, content, rule):
filteredContent = []
for item in content:
if rule(item):
filteredContent.append(item)
return filteredContent
def prepareHeader(self):
hlayout = BoxLayout(orientation='horizontal', size_hint_y=0.1)
for i in range(10):
hlayout.add_widget(Button(text=unicode(i), background_color=(0.1,0.8,0.3,1), disabled=True))
return hlayout
def prepareHour(self, content, hour):
vlayout = BoxLayout(orientation='vertical')
itemsInHour = self.filterBy(content, lambda x: x.hourStart == hour)
for x in itemsInHour:
vlayout.add_widget(x.kivy_short(self.displayFull))
return vlayout
def prepareDay(self, content, day):
hlayout = BoxLayout(orientation='horizontal')
itemsInDay = self.filterBy(content, lambda x: x.day == day)
for i in range(10):
hlayout.add_widget(self.prepareHour(itemsInDay, i))
return hlayout
def displayContent(self, invoker):
self._contentSpace.clear_widgets()
self._contentSpace.size_hint=(1, 1)
self._contentSpace.size=(0,0)
try:
content = self.prepareContent()
self._contentSpace.add_widget(self.prepareHeader())
for i in range(5):
self._contentSpace.add_widget(self.prepareDay(content, School.days[i]))
self._contentSpace.size_hint=(None, None)
self._contentSpace.size=(500,1500)
except Exception, e:
self._contentSpace.add_widget(Label(text='An error occured.'))
MessagePopup('Error', traceback.format_exc(e))
class Level(Screen):
def __init__(self,**kwargs):
super(Level, self).__init__(**kwargs)
self.register_event_type('on_pass')
self.name="level"
main_layout=BoxLayout(orientation='vertical')
labels=BoxLayout(orientation="horizontal",size_hint=(1,.1))
labels.add_widget(Label(text="Valid",background_color=(0,1,0,1)))
labels.add_widget(Label(text="Invalid",background_color=(1,0,0,1)))
history=BoxLayout(orientation="horizontal",spacing=100)
self.enter_label=Label(text="Enter your sequence:",size_hint=(1,.2))
self.valid_history=CaterpillarList()
self.invalid_history=CaterpillarList()
history.add_widget(self.valid_history)
history.add_widget(self.invalid_history)
self.buttons=BoxLayout(orientation="vertical")
self.exam=Exam()
self.exam.bind(on_answer=self.chain_entered)
self.exam.bind(on_finish=self.finish)
self.input_chain=InputCaterpillar()
self.input_chain.bind(on_input=self.chain_entered)
self.exam_button=Button(text="I know the rule and ready for test!")
self.exam_button.bind(on_press=self.to_exam_mode)
main_layout.add_widget(labels)
main_layout.add_widget(history)
self.to_game_mode()
main_layout.add_widget(self.buttons)
self.add_widget(main_layout)
def start_game(self,func):
self.func=func
self.input_chain.func=self.func
self.valids,self.invalids=get_valid_invalid(func)
valids_sample=get_n(7,self.valids)
invalids_sample=get_n(7,self.invalids)
self.valid_history.reset()
self.invalid_history.reset()
for e in valids_sample:
self.valid_history.add(e)
for e in invalids_sample:
self.invalid_history.add(e)
self.to_game_mode()
def chain_entered(self,instance,chain):
if self.func(chain):
self.valid_history.add(chain)
else:
self.invalid_history.add(chain)
def finish(self,instance,passed):
self.to_game_mode()
if passed:
self.dispatch('on_pass')
def on_pass(self,*args):
pass
def to_exam_mode(self,*args):
self.buttons.clear_widgets()
self.exam.start_exam(self.valids,
self.invalids,
self.valid_history.caterpillars,
self.invalid_history.caterpillars)
self.buttons.add_widget(self.exam)
def to_game_mode(self,*args):
self.buttons.clear_widgets()
self.buttons.add_widget(self.enter_label)
self.buttons.add_widget(self.input_chain)
self.buttons.add_widget(self.exam_button)
class XBase(XPopup):
"""XBase class. See module documentation for more information.
"""
auto_open = BooleanProperty(True)
'''This property determines if the pop-up is automatically
opened when the instance was created. Otherwise use :meth:`XBase.open`
:attr:`auto_open` is a :class:`~kivy.properties.BooleanProperty` and
defaults to True.
'''
buttons = ListProperty()
'''List of button names. Can be used when using custom button sets.
:attr:`buttons` is a :class:`~kivy.properties.ListProperty` and defaults to
[].
'''
button_pressed = StringProperty('')
'''Name of button which has been pressed.
:attr:`button_pressed` is a :class:`~kivy.properties.StringProperty` and
defaults to '', read-only.
'''
size_hint_x = NumericProperty(.6, allownone=True)
size_hint_y = NumericProperty(.3, allownone=True)
auto_dismiss = BooleanProperty(False)
'''Overrides properties from :class:`~kivy.uix.popup.Popup`
'''
min_width = NumericProperty(metrics.dp(300), allownone=True)
min_height = NumericProperty(metrics.dp(150), allownone=True)
fit_to_window = BooleanProperty(True)
'''Overrides properties from :class:`XPopup`
'''
BUTTON_OK = 'OK'
BUTTON_CANCEL = 'Cancel'
BUTTON_YES = 'Yes'
BUTTON_NO = 'No'
BUTTON_CLOSE = 'Close'
'''Basic button names
'''
def __init__(self, **kwargs):
# preventing change content of the popup
kwargs.pop('content', None)
self._pnl_buttons = None
super(XBase, self).__init__(**kwargs)
layout = BoxLayout(orientation="vertical")
layout.add_widget(self._get_body())
self._pnl_buttons = BoxLayout(size_hint_y=None)
layout.add_widget(self._pnl_buttons)
self.add_widget(layout)
# creating buttons panel
self.property('buttons').dispatch(self)
if self.auto_open:
self.open()
def _on_click(self, instance):
self.button_pressed = instance.id
self.dismiss()
def _get_body(self):
"""Returns the content of the popup. You need to implement
this in your subclass.
"""
raise NotImplementedError
def on_buttons(self, instance, buttons):
if self._pnl_buttons is None:
return
self._pnl_buttons.clear_widgets()
if len(buttons) == 0:
self._pnl_buttons.height = 0
return
self._pnl_buttons.height = metrics.dp(30)
for button in buttons:
self._pnl_buttons.add_widget(
ButtonEx(text=button, id=button, on_release=self._on_click))
def is_canceled(self):
"""Check the `cancel` event
:return: True, if the button 'Cancel' has been pressed
"""
return self.button_pressed == self.BUTTON_CANCEL
