def run_test(self, app, *args):
Clock.schedule_interval(self.pause, 0.000001)
self.helper_setup(app)
self.helper_test_empty_account(app)
self.helper_test_back_home_empty_account(app)
self.helper_test_create_first_account(app)
self.helper_test_create_account_form(app)
self.helper_test_on_send_click(app)
self.helper_test_address_alias(app)
self.helper_test_delete_account(app)
self.helper_test_delete_account_none_selected(app)
self.helper_test_delete_account_twice(app)
self.helper_test_dismiss_dialog_twice(app)
self.helper_test_controller_fetch_balance(app)
self.helper_test_delete_last_account(app)
# Comment out if you are editing the test, it'll leave the
# Window opened.
app.stop()
# same named function as the filename(!)
python类schedule_interval()的实例源码
def build(self):
self.client = False
self.connect(3)
Clock.schedule_interval(self.connect, 3)
Clock.schedule_interval(self.update, .1)
self.enabled = False
self.mode = 'compass'
self.heading_command = 0
self.heading = 0
self._anim = None
self.texture = Image(source='compass.png').texture
self.control = AutopilotControl()
return self.control
def build(self):
self.root = NotificationDemo(self)
if platform == 'android':
try:
self.service = autoclass(
'org.test.npexample.ServiceMyservice')
mActivity = autoclass(
'org.kivy.android.PythonActivity').mActivity
argument = ''
self.service.start(mActivity, argument)
except:
self.service = AndroidService(
'Sevice example', 'service is running')
self.service.start('Hello From Service')
else:
Window.system_size = cm(7), cm(12)
self.client.on_connect = self.on_connect
self.client.on_disconnect = self.on_disconnect
Clock.schedule_once(self.try_connecting, 0)
Clock.schedule_interval(self.handle_msg, 0.1)
# def skipp(*a):
# self.root.ids.sm.current = 'main'
# Clock.schedule_once(skipp, 0.5)
return self.root
def __init__(self,group,user):
super(Showmap,self).__init__()
self.user = user
self.group = group
self.usersloc = {} #user location for future zoom-in
self.grouplab.text = 'Group '+str(group)
self.gpar, self.mlist = self.load_points() # load map parameters
self.mapview.lat = float(self.gpar['clat'])
self.mapview.lon = float(self.gpar['clon'])
self.lat = float(self.gpar['clat'])
self.lon = float(self.gpar['clon'])
self.mapview.zoom = int(self.gpar['zoom'])
self.load_msg() # load message
self.user_values = ['Points Center']
for i in self.mlist:
self.mapview.add_marker(MMarker(i,self.user,False))
self.user_values.append(i['name'])
self.usersloc[i['name']]=(float(i['lat']),float(i['lon']))
Clock.schedule_interval(self.callback, mapdelay) #refreshing data callback
def load_audio_file(self, path):
from kivy.core.audio import SoundLoader
sound = SoundLoader.load(path)
self._sound = sound
if sound:
update_bar_schedule = Clock.schedule_interval(self.update_bar, 1)
self._update_bar_schedule = update_bar_schedule
self.ids.p_bar.max = sound.length
sound.volume = self.ids.volume_slider.value
sound.play()
else:
print('Cannot play the file %s.' % path)
error_msg = 'Cannot play the file %s.' % (path) if path else 'No file selected.'
popup = Popup(title='Audio Error.',
content=Label(text= error_msg),
size_hint = (0.3, 0.3))
popup.open()
def __init__(self, data_dir, name, do_date=False, do_hour=False, **kwargs):
super(DBInterface, self).__init__(**kwargs)
self.ensure_dir(data_dir)
if do_date:
if do_hour:
date = self.convert_time_to_json_ymdh(self.get_time())
else:
date = self.convert_time_to_json_ymd(self.get_time())
json_name = data_dir + name + '-' + date + '.json'
reset_json_name = (
data_dir + name + '-' + date + '-reset_timers.json')
else:
json_name = data_dir + name + '.json'
reset_json_name = data_dir + name + '-reset_timers.json'
self.data = data = JsonStore(json_name)
self.reset_timers = reset_timers = JsonStore(reset_json_name)
self.sync = Clock.create_trigger(self.trigger_sync)
self.check_reset(0.)
Clock.schedule_interval(self.check_reset, 60.)
def filter_ok(self, *args):
if self.loaded == 'Yes':
self.selectedtypes = []
for i in range(len(self._log_analyzer.supported_types)):
if self.filter_rows[i].active:
self.selectedtypes += [
list(self._log_analyzer.supported_types)[i]]
if not self.selectedtypes == []:
self.data_view = [
x for x in self.data_view if x["TypeID"] in self.selectedtypes]
self.SetUpGrid(self.data_view, len(self.data_view), 'init')
Clock.unschedule(self.check_scroll_limit)
Clock.schedule_interval(self.check_scroll_limit, 0.11)
self.dismiss_filter_popup()
else:
self.dismiss_filter_popup()
def build(self):
global app
app = self
# background sound
# start the background music
# self.music = SoundLoader.load('sound/8bitattempt.ogg')
# self.music.bind(on_stop=self.sound_replay)
# self.music.play()
# sound
self.sound['swing'] = SoundLoader.load('sound/battle/swing.ogg')
self.sound['coin'] = SoundLoader.load('sound/inventory/chainmail1.ogg')
self.title = 'One RPG'
self.game = TurnBattle()
self.game.init()
# self.game.load_enermy()
# Clock.schedule_interval(self.game.update, 1.0 / 60.0)
return self.game
def third_screen(self):
"""
Pull filament Screen:
Display instructions to user -- Pull out filament
Display button that will open fourth screen
"""
# roboprinter.printer_instance._printer.jog('e', -130.00)
c = Filament_Wizard_3_5(self.fourth_screen)
back_destination = roboprinter.robo_screen()
this_screen = self.sm._generate_backbutton_screen(name=self.name+'[2]', title=roboprinter.lang.pack['Filament_Wizard']['Title_25'], back_destination=back_destination, content=c)
#end the event before starting it again
if self.extrude_event != None:
self.end_extrude_event()
self.extrude_event = Clock.schedule_interval(self.retract, 1)
# back_button deletes Second Screen, as back destination is first screen
# second_screen = self.sm.get_screen(self.name+'[1]')
# delete_second = partial(self.sm.remove_widget, second_screen)
# this_screen.ids.back_button.bind(on_press=delete_second)
def fifth_screen(self, *args):
"""
Final screen / Confirm successful load:
Extrude filament
Display instruction to user -- Press okay when you see plastic extruding
Display button that will move_to_main() AND stop extruding filament
"""
if self.load_or_change == 'CHANGE':
_title = roboprinter.lang.pack['Filament_Wizard']['Title_45']
back_dest = self.name+'[3]'
else:
_title = roboprinter.lang.pack['Filament_Wizard']['Title_34']
back_dest = self.name+'[3]'
c = Filament_Wizard_5_5(self.end_wizard)
back_destination = roboprinter.robo_screen()
self.sm._generate_backbutton_screen(name=self.name+'[4]', title=_title, back_destination=back_destination, content=c)
#end the event before starting it again
if self.extrude_event != None:
self.end_extrude_event()
self.extrude_event = Clock.schedule_interval(self.extrude, 1)
def __init__(self, keyboard_callback = None, default_text = '', name = 'keyboard_screen', title=lang.pack['Files']['Keyboard']['Default_Title'], back_destination=None,**kwargs):
super(KeyboardInput, self).__init__(**kwargs)
self.default_text = default_text
self.back_destination = back_destination
self.first_press = False
if self.back_destination == None:
self.back_destination = roboprinter.robo_screen()
roboprinter.back_screen(name=name,
title=title,
back_destination=self.back_destination,
content=self)
self.current_screen = roboprinter.robo_screen()
self._keyboard = None
self._set_keyboard('keyboards/abc.json')
if keyboard_callback != None:
self.keyboard_callback = keyboard_callback
self.keyboard_watch = Clock.schedule_interval(self.monitor_screen_change, 0.2)
def copy_file(self, fsrc, fdst, progress_callback=None, complete_callback = None, length=16*1024, **kwargs):
self.copied = 0
self.file_size = 0
self.length = length
self.p_callback = progress_callback
self.c_callback = complete_callback
if not os.path.isfile(fsrc):
Logger.info("Will not copy")
return False
else:
self.file_size = float(os.path.getsize(fsrc))
#make the new file
self.src_obj = open(fsrc, 'rb')
self.dst_obj = open(fdst, 'wb')
#Do the copy as fast as possible without blocking the UI thread
Clock.schedule_interval(self.copy_object, 0)
return True
#doing it this way with a clock object does not block the UI
def __init__(self, selected_tool= "TOOL1" ,**kwargs):
super(TemperatureControl, self).__init__(**kwargs)
acceptable_toolheads = {"TOOL1": 'tool0',
"TOOL2": 'tool1',
"BED": 'bed',
"tool0": 'tool0',
"tool1": 'tool1',
"bed": 'bed'}
if selected_tool in acceptable_toolheads:
self.selected_tool = acceptable_toolheads[selected_tool]
else:
Logger.info("TOOL CANNOT BE SELECTED: " + selected_tool)
self.selected_tool = 'tool0'
Clock.schedule_interval(self.update, .1)
def confirmation(self, action, language=None,lang_option = None, **kwargs):
if action and language != None:
self.old_language = lang.current_lang
lang.reload_language(lang_option)
roboprinter.printer_instance._settings.set(['Language'], lang_option)
roboprinter.printer_instance._settings.save()
layout = Language_Confirmation_Screen(language)
title = lang.pack['Switch_Lang']['Confirmation']['Title'] + language
name = 'confirm_language'
back_destination = roboprinter.robo_screen()
roboprinter.back_screen(
name=name,
title=title,
back_destination=back_destination,
content=layout
)
Clock.schedule_interval(self.Monitor_Screen, 0.2)
else:
self.select_language()
def __init__(self, language, callback, lang_option):
#temporarily switch to new language
self.old_language = lang.current_lang
self.switch_language(lang_option)
self.title = lang.pack['Switch_Lang']['Choose']['Switch_to'] + language + lang.pack['Switch_Lang']['Choose']['Question']
self.body_text = lang.pack['Switch_Lang']['Choose']['Are_You_Sure']
self.option1_text = lang.pack['Switch_Lang']['Choose']['Yes_option']
self.option2_text = lang.pack['Switch_Lang']['Choose']['No_option']
self.option1_function = self.yes
self.option2_function = self.no
self.callback = callback
self.language = language
self.lang_option = lang_option
self.pressed_yes = False
super(Switch_Language, self).__init__(self.title, self.body_text, self.option1_text, self.option2_text, self.option1_function, self.option2_function)
Clock.schedule_interval(self.Monitor_Screen, 0.2)
def generate_wifi_list_screen(self):
self.wifi_grid = GridLayout(cols=1, padding=0, spacing=0)
self.placeholder = WifiLoadingList()
self.wifi_grid.add_widget(self.placeholder)
self.rsm._generate_backbutton_screen(
name=self.name,
title=roboprinter.lang.pack['WiFi']['Select_Network'],
back_destination=self.back_destination,
content=self.wifi_grid,
cta=self._refresh_wifi_list,
icon='Icons/Manual_Control/refresh_icon.png')
thread.start_new_thread(self._append_wifi_list, ())
Clock.schedule_interval(self._wifi_callback, 1 / 30.)
return
def generate_connecting_screen(self, obj, *args):
# remove keyboard from screen
self.wifi_status = 'nothing'
Window.release_all_keyboards()
# wifi credentials
if obj.id == 'encrypted':
psk = obj.ids.password.text
else:
psk = ''
ssid = obj.ssid
self.wifi_data = {'ssid': ssid, 'psk': psk, 'force': True}
# layout for connecting screen
s = Screen(name=self.name+'[2]')
c = WifiConnecting(ssid=ssid)
s.add_widget(c)
self.rsm.add_widget(s)
self.rsm.current = s.name
self.temp_screen = s
thread.start_new_thread(self.connectWifi_thread, ())
Clock.schedule_interval(self.connectWifi_callback, 1)
#self.generate_confirmation_screen(s)
def turn_off_splash(self, dt):
temp1 = self.grab_target_and_actual('tool0')
self.extruder_one_max_temp = temp1['target']
self.extruder_one_temp = temp1['actual']
temp2 = self.grab_target_and_actual('tool1')
self.extruder_two_max_temp = temp2['target']
self.extruder_two_temp = temp2['actual']
bed = self.grab_target_and_actual('bed')
self.bed_max_temp = bed['target']
self.bed_temp = bed['actual']
#turn off the splash screen
if self.extruder_one_temp != 0 and self.startup == False:
#Logger.info("Turning Off the Splash Screen!")
self.detirmine_layout()
#check for updates
self.check_updates()
#check for updates every hour
Clock.schedule_interval(self.update_clock, 3600)
self.startup = True
return False
def connected(self):
self.state = 'connected'
self.trigger_event('connected')
self.debug('Connected to server')
self.time = MeteorTime(self.meteor)
Clock.schedule_interval(self.time.update, 0.5)
self.collections = 0
self.collections_ready = 0
for collection in ['settings', 'stages', 'minions',
'media', 'mediaplaylists',
'songs', 'songarrangements', 'songsections',
'presentations', 'presentationslides']:
self.collections += 1
self.meteor.subscribe(collection, callback=self.subscription_ready)
def third_screen(self):
"""
Pull filament Screen:
Display instructions to user -- Pull out filament
Display button that will open fourth screen
"""
# roboprinter.printer_instance._printer.jog('e', -130.00)
c = Filament_Wizard_3_5(self.fourth_screen)
back_destination = roboprinter.robo_screen()
this_screen = self.sm._generate_backbutton_screen(name=self.name+'[2]', title=roboprinter.lang.pack['Filament_Wizard']['Title_25'], back_destination=back_destination, content=c)
#end the event before starting it again
if self.extrude_event != None:
self.end_extrude_event()
#extrude a little bit before retracting
roboprinter.printer_instance._printer.extrude(20.0)
self.extrude_event = Clock.schedule_interval(self.retract, 1)
# back_button deletes Second Screen, as back destination is first screen
# second_screen = self.sm.get_screen(self.name+'[1]')
# delete_second = partial(self.sm.remove_widget, second_screen)
# this_screen.ids.back_button.bind(on_press=delete_second)
def fifth_screen(self, *args):
"""
Final screen / Confirm successful load:
Extrude filament
Display instruction to user -- Press okay when you see plastic extruding
Display button that will move_to_main() AND stop extruding filament
"""
if self.load_or_change == 'CHANGE':
_title = roboprinter.lang.pack['Filament_Wizard']['Title_45']
back_dest = self.name+'[3]'
else:
_title = roboprinter.lang.pack['Filament_Wizard']['Title_34']
back_dest = self.name+'[3]'
c = Filament_Wizard_5_5(self.end_wizard)
back_destination = roboprinter.robo_screen()
self.sm._generate_backbutton_screen(name=self.name+'[4]', title=_title, back_destination=back_destination, content=c)
#end the event before starting it again
if self.extrude_event != None:
self.end_extrude_event()
self.extrude_event = Clock.schedule_interval(self.extrude, 1)
def __init__(self, keyboard_callback = None, default_text = '', name = 'keyboard_screen', title=lang.pack['Files']['Keyboard']['Default_Title'], back_destination=None,**kwargs):
super(KeyboardInput, self).__init__(**kwargs)
self.default_text = default_text
self.back_destination = back_destination
self.first_press = False
if self.back_destination == None:
self.back_destination = roboprinter.robo_screen()
roboprinter.back_screen(name=name,
title=title,
back_destination=self.back_destination,
content=self)
self.current_screen = roboprinter.robo_screen()
self._keyboard = None
self._set_keyboard('keyboards/abc.json')
if keyboard_callback != None:
self.keyboard_callback = keyboard_callback
self.keyboard_watch = Clock.schedule_interval(self.monitor_screen_change, 0.2)
def __init__(self, **kwargs):
super(UtilitiesContent, self).__init__()
#add Icons
self.wiz = Robo_Icons('Icons/White_Utilities/Wizards.png', roboprinter.lang.pack['RoboIcons']['Wizards'] , 'WIZARDS')
self.rc = Robo_Icons('Icons/White_Utilities/Print tuning_White.png', roboprinter.lang.pack['RoboIcons']['Print_Tuning'], 'PRINT_TUNING')
self.net = Robo_Icons('Icons/White_Utilities/Networking.png', roboprinter.lang.pack['RoboIcons']['Network'], 'NETWORK')
self.upd = Robo_Icons('Icons/White_Utilities/Updates.png', roboprinter.lang.pack['RoboIcons']['Update'], 'UPDATES')
self.sys = Robo_Icons('Icons/System_Icons/Shutdown 2.png', roboprinter.lang.pack['RoboIcons']['System'], 'SYSTEM')
self.opt = Robo_Icons('Icons/White_Utilities/Options.png', roboprinter.lang.pack['RoboIcons']['Options'], 'OPTIONS')
icons = [self.rc, self.wiz, self.net, self.upd, self.opt, self.sys]
layout = Scroll_Box_Icons(icons)
self.clear_widgets()
self.add_widget(layout)
self.state = 'NOT_PRINTING'
self.last_state = None
Clock.schedule_interval(self.monitor_layout, 1)
def __init__(self, selected_tool= "TOOL1" ,**kwargs):
super(TemperatureControl, self).__init__(**kwargs)
acceptable_toolheads = {"TOOL1": 'tool0',
"TOOL2": 'tool1',
"BED": 'bed',
"tool0": 'tool0',
"tool1": 'tool1',
"bed": 'bed'}
if selected_tool in acceptable_toolheads:
self.selected_tool = acceptable_toolheads[selected_tool]
else:
Logger.info("TOOL CANNOT BE SELECTED: " + selected_tool)
self.selected_tool = 'tool0'
Clock.schedule_interval(self.update, .1)
def __init__(self, language, callback, lang_option):
#temporarily switch to new language
self.old_language = lang.current_lang
self.switch_language(lang_option)
self.title = lang.pack['Switch_Lang']['Choose']['Switch_to'] + language + lang.pack['Switch_Lang']['Choose']['Question']
self.body_text = lang.pack['Switch_Lang']['Choose']['Are_You_Sure']
self.option1_text = lang.pack['Switch_Lang']['Choose']['Yes_option']
self.option2_text = lang.pack['Switch_Lang']['Choose']['No_option']
self.option1_function = self.yes
self.option2_function = self.no
self.callback = callback
self.language = language
self.lang_option = lang_option
self.pressed_yes = False
super(Switch_Language, self).__init__(self.title, self.body_text, self.option1_text, self.option2_text, self.option1_function, self.option2_function)
Clock.schedule_interval(self.Monitor_Screen, 0.2)
def generate_wifi_list_screen(self):
self.wifi_grid = GridLayout(cols=1, padding=0, spacing=0)
self.placeholder = WifiLoadingList()
self.wifi_grid.add_widget(self.placeholder)
self.rsm._generate_backbutton_screen(
name=self.name,
title=roboprinter.lang.pack['WiFi']['Select_Network'],
back_destination=self.back_destination,
content=self.wifi_grid,
cta=self._refresh_wifi_list,
icon='Icons/Manual_Control/refresh_icon.png')
thread.start_new_thread(self._append_wifi_list, ())
Clock.schedule_interval(self._wifi_callback, 1 / 30.)
return
def generate_connecting_screen(self, obj, *args):
# remove keyboard from screen
self.wifi_status = 'nothing'
Window.release_all_keyboards()
# wifi credentials
if obj.id == 'encrypted':
psk = obj.ids.password.text
else:
psk = ''
ssid = obj.ssid
self.wifi_data = {'ssid': ssid, 'psk': psk, 'force': True}
# layout for connecting screen
s = Screen(name=self.name+'[2]')
c = WifiConnecting(ssid=ssid)
s.add_widget(c)
self.rsm.add_widget(s)
self.rsm.current = s.name
self.temp_screen = s
thread.start_new_thread(self.connectWifi_thread, ())
Clock.schedule_interval(self.connectWifi_callback, 1)
#self.generate_confirmation_screen(s)
def __init__(self, file_data, **kwargs):
super(PrintFile, self).__init__(**kwargs)
self.queued_data = False
self.found_meta_data = False
self.exit = False
self.file = file_data
self.file_path = self.file['path']
self.file_name = self.file['name']
self.status = self.is_ready_to_print()
Clock.schedule_interval(self.update, .2)
self.current_z_offset = str("{0:.1f}".format(float(pconsole.home_offset['Z'])))
cura_meta = self.check_saved_data()
self.print_layer_height = '--'
self.print_layers = '--'
self.infill = '--'
self.hours = 0
self.minutes = 0
self.seconds = 0
self.populate_meta_data(cura_meta)
def __init__(self, title_text, body_text, button_text, bed_disconnect=False, start_refresh=False, **kwargs):
self.clock_monitor = None
self.changed_text = False
self.reconnect_choice = button_text
self.bed_disconnect = bed_disconnect
self.start_refresh = start_refresh
if self.bed_disconnect:
if self.bed_checker != None:
self.bed_checker.cancel()
self.bed_checker = None
Clock.schedule_interval(self.check_for_screen_change, 0.2)
session_saver.register_event_updater("Refresh_screen", self.on_event)
super(Refresh_Screen, self).__init__(title_text, body_text, self.reset, button_text)
#Immediately start the refresh function as if someone had pressed the button
if self.start_refresh:
self.reset()
def __init__(self,**kwargs):
self.baseimg = os.path.abspath(os.path.join(os.path.dirname('__file__'),'animation','effects','enbar_noback.png'))
self.hpimg = os.path.abspath(os.path.join(os.path.dirname('__file__'),'animation','effects','hbar.png'))
self.mpimg = os.path.abspath(os.path.join(os.path.dirname('__file__'),'animation','effects','mpbar.png'))
super(ZippyGame,self).__init__(**kwargs)
tempscale = Window.height / 256.
self.map = BaseMap(os.path.abspath(os.path.join(os.path.dirname('__file__'),'Maps','prototype1','16px-680x800-metal.tmx')),
Window.size,tempscale)
spawn = self.map.map.layers['start'].find('spawn')[0]
self.zipmeter = ZipMeter()
self.sprite = Player_Sprite((spawn.px,spawn.py),self.map)
self.add_widget(self.map)
self.map.add_widget(self.sprite)
self.add_widget(self.zipmeter)
Clock.schedule_interval(self.update, 1.0/60.0)
