def __init__(self, **kwargs): # XXX move to style.kv if 'size_hint' not in kwargs: if 'size_hint_x' not in kwargs: self.size_hint_x = None if 'size_hint_y' not in kwargs: self.size_hint_y = None if 'size' not in kwargs: if 'width' not in kwargs: self.width = 700 if 'height' not in kwargs: self.height = 200 if 'scale_min' not in kwargs: self.scale_min = .4 if 'scale_max' not in kwargs: self.scale_max = 1.6 if 'docked' not in kwargs: self.docked = False layout_mode = self._trigger_update_layout_mode = Clock.create_trigger( self._update_layout_mode) layouts = self._trigger_load_layouts = Clock.create_trigger( self._load_layouts) layout = self._trigger_load_layout = Clock.create_trigger( self._load_layout) fbind = self.fbind fbind('docked', self.setup_mode) fbind('have_shift', layout_mode) fbind('have_capslock', layout_mode) fbind('have_special', layout_mode) fbind('layout_path', layouts) fbind('layout', layout) super(VKeyboard, self).__init__(**kwargs) # load all the layouts found in the layout_path directory self._load_layouts() # ensure we have default layouts available_layouts = self.available_layouts if not available_layouts: Logger.critical('VKeyboard: unable to load default layouts') # load the default layout from configuration if self.layout is None: self.layout = Config.get('kivy', 'keyboard_layout') else: # ensure the current layout is found on the available layout self._trigger_load_layout() # update layout mode (shift or normal) self._trigger_update_layout_mode() # create a top layer to draw active keys on with self.canvas: self.background_key_layer = Canvas() self.active_keys_layer = Canvas()
def __init__(self, **kwargs): Label.__init__(self) for x in kwargs.items(): setattr(self, x[0], x[1]) if not hasattr(self, "text_color"): self.text_color = (1, 1, 1, 1) if not hasattr(self, "back_color"): self.back_color = (0, int("4a",16)/255, int("64",16)/255, .8) if not hasattr(self, "text"): self.text = "Hello World" if not hasattr(self, "duration"): self.duration = 4 if not hasattr(self, "pad_x"): self.pad_x = 15 if not hasattr(self, "pad_y"): self.pad_y = 5 self.pos = (0,0) self.opacity = 0 self.color = self.text_color self.rect = InstructionGroup() self.rect.add(Color(*self.back_color)) self.rect.add(Rectangle(pos_hint=self.pos_hint, pos=(self.center_x-self.texture_size[0]/2, self.center_y-self.texture_size[1]/2), size=(self.texture_size[0]+10, self.texture_size[1]))) self.canvas.before.add(self.rect) self.bind(texture_size=self.draw_rect) self.anim = {'fade_in':Animation(opacity=1, duration=.4), 'fade_out':Animation(opacity=0)} self.clock_fade_in = Clock.create_trigger(self.fade_in) self.clock_fade_out = Clock.create_trigger(self.fade_out, self.duration)
def __init__(self, **kwargs): # initialize variables self._clipboard = None self.exchanger = None self.info_bubble = None self.qrscanner = None self.nfcscanner = None self.tabs = None super(ElectrumWindow, self).__init__(**kwargs) # Unused # title = _('Electrum App') self.network = kwargs.get("network", None) self.electrum_config = kwargs.get("config", None) self.gui_object = kwargs.get("gui_object", None) # self.config = self.gui_object.config self.contacts = Contacts(self.electrum_config) self.bind(url=self.set_url) # were we sent a url? url = kwargs.get("url", None) if url: self.gui_object.set_url(url) # create triggers so as to minimize updation a max of 2 times a sec self._trigger_update_wallet = Clock.create_trigger(self.update_wallet, 0.5) self._trigger_update_status = Clock.create_trigger(self.update_status, 0.5) self._trigger_notify_transactions = Clock.create_trigger(self.notify_transactions, 5)
def __init__(self, **kwargs): # initialize variables self._clipboard = Clipboard self.info_bubble = None self.nfcscanner = None self.tabs = None self.is_exit = False self.wallet = None super(ElectrumWindow, self).__init__(**kwargs) title = _("Electrum App") self.electrum_config = config = kwargs.get("config", None) self.language = config.get("language", "en") self.network = network = kwargs.get("network", None) self.plugins = kwargs.get("plugins", []) self.gui_object = kwargs.get("gui_object", None) self.daemon = self.gui_object.daemon self.contacts = Contacts(self.electrum_config) self.invoices = InvoiceStore(self.electrum_config) # create triggers so as to minimize updation a max of 2 times a sec self._trigger_update_wallet = Clock.create_trigger(self.update_wallet, 0.5) self._trigger_update_status = Clock.create_trigger(self.update_status, 0.5) # cached dialogs self._settings_dialog = None self._password_dialog = None
def __init__(self, **kwargs): # initialize variables self._clipboard = Clipboard self.info_bubble = None self.qrscanner = None self.nfcscanner = None self.tabs = None self.receive_address = None self.current_invoice = None super(ElectrumWindow, self).__init__(**kwargs) title = _("Electrum App") self.electrum_config = config = kwargs.get("config", None) self.network = network = kwargs.get("network", None) self.plugins = kwargs.get("plugins", []) self.gui_object = kwargs.get("gui_object", None) # self.config = self.gui_object.config self.contacts = Contacts(self.electrum_config) self.invoices = InvoiceStore(self.electrum_config) self.bind(url=self.set_URI) # were we sent a url? url = self.electrum_config.get("url", None) if url: self.set_URI(url) # create triggers so as to minimize updation a max of 2 times a sec self._trigger_update_wallet = Clock.create_trigger(self.update_wallet, 0.5) self._trigger_update_status = Clock.create_trigger(self.update_status, 0.5) self._trigger_notify_transactions = Clock.create_trigger(self.notify_transactions, 5)
def __init__(self, **kwargs): self.register_event_type('on_press') self.register_event_type('on_release') super(Clickable, self).__init__(**kwargs) self._press_ = Clock.create_trigger(self.trigger_press, self.press_timeout) self._release_ = Clock.create_trigger(self.trigger_release, self.release_timeout)
def build(self): self.provider = None self.sensors_values = [] self.gps_values = ['', '', 0, 0] self.trigger_sensor_update_values = \ Clock.create_trigger(self.sensor_update_values, 0) self.trigger_gps_update_values = \ Clock.create_trigger(self.gps_update_values, 0) # search categories self.categories = ['gps-location'] for key in sensortypes: self.categories.append('sensor-{}'.format(key)) # create main ui root = MainUI() # fill the dropdown with all the categories for cat in self.categories: btn = ToggleButton(text=cat, size_hint_y=None, height='44sp', group='sensors') btn.bind(on_release=self.select_category) root.dropdown.add_widget(btn) return root
def __init__(self, **kwargs): super(Graph, self).__init__(**kwargs) self._mesh = Mesh(mode='lines') self._mesh_rect = Mesh(mode='line_strip') val = 0.25 self.canvas.add(Color(1 * val, 1 * val, 1 * val)) self.canvas.add(self._mesh) self.canvas.add(Color(1, 1, 1)) self.canvas.add(self._mesh_rect) mesh = self._mesh_rect mesh.vertices = [0] * (5 * 4) mesh.indices = [k for k in xrange(5)] self._plot_area = StencilView() self.add_widget(self._plot_area) self._trigger = Clock.create_trigger(self._redraw_all) self._trigger_size = Clock.create_trigger(self._redraw_size) self.bind(center=self._trigger_size, padding=self._trigger_size, font_size=self._trigger_size, plots=self._trigger_size, x_grid=self._trigger_size, y_grid=self._trigger_size, draw_border=self._trigger_size) self.bind(xmin=self._trigger, xmax=self._trigger, xlog=self._trigger, x_ticks_major=self._trigger, x_ticks_minor=self._trigger, xlabel=self._trigger, x_grid_label=self._trigger, ymin=self._trigger, ymax=self._trigger, ylog=self._trigger, y_ticks_major=self._trigger, y_ticks_minor=self._trigger, ylabel=self._trigger, y_grid_label=self._trigger) self._trigger()
def __init__(self, **kwargs): # initialize variables self._clipboard = Clipboard self.info_bubble = None self.nfcscanner = None self.tabs = None self.is_exit = False self.wallet = None super(ElectrumWindow, self).__init__(**kwargs) title = _('Electrum App') self.electrum_config = config = kwargs.get('config', None) self.language = config.get('language', 'en') self.network = network = kwargs.get('network', None) self.plugins = kwargs.get('plugins', []) self.gui_object = kwargs.get('gui_object', None) self.daemon = self.gui_object.daemon self.fx = self.daemon.fx # create triggers so as to minimize updation a max of 2 times a sec self._trigger_update_wallet = Clock.create_trigger(self.update_wallet, .5) self._trigger_update_status = Clock.create_trigger(self.update_status, .5) self._trigger_update_history = Clock.create_trigger(self.update_history, .5) # cached dialogs self._settings_dialog = None self._password_dialog = None
def init_roulettes(self): self._calibrate_month_size_trigger = t = \ Clock.create_trigger(self.calibrate_month_size) self._adjust_day_cycle_trigger = \ Clock.create_trigger(self._adjust_day_cycle, -1) now = datetime.now() kw = {'density': self.density} self.second = second = TimeFormatCyclicRoulette(cycle=60, **kw) second.select_and_center(now.second) self.minute = minute = TimeFormatCyclicRoulette(cycle=60, **kw) minute.select_and_center(now.minute) self.hour = hour = TimeFormatCyclicRoulette(cycle=24, **kw) hour.select_and_center(now.hour) self.year = year = Roulette(**kw) year.select_and_center(now.year) self.month = month = CyclicRoulette(cycle=12, zero_indexed=False, **kw) month.select_and_center(now.month) month_size = monthrange(now.year, now.month)[1] self.day = day = CyclicRoulette(cycle=month_size, zero_indexed=False, on_centered=self._adjust_day_cycle_trigger, **kw) day.select_and_center(now.day) self.month.bind(selected_value=t) self.year.bind(selected_value=t) self.set_roulette_width() self.set_selected_datetime() self._bind_updates() self.add_widgets()
def __init__(self, **kwargs): # initialize variables self._clipboard = None self.info_bubble = None self.qrscanner = None self.nfcscanner = None self.tabs = None super(ElectrumWindow, self).__init__(**kwargs) title = _('Electrum-GMC App') self.electrum_config = config = kwargs.get('config', None) self.network = network = kwargs.get('network', None) self.plugins = kwargs.get('plugins', []) self.gui_object = kwargs.get('gui_object', None) #self.config = self.gui_object.config self.contacts = Contacts(self.electrum_config) self.bind(url=self.set_url) # were we sent a url? url = self.electrum_config.get('url', None) if url: self.set_url(url) # create triggers so as to minimize updation a max of 2 times a sec self._trigger_update_wallet =\ Clock.create_trigger(self.update_wallet, .5) self._trigger_update_status =\ Clock.create_trigger(self.update_status, .5) self._trigger_notify_transactions = \ Clock.create_trigger(self.notify_transactions, 5)
def __init__(self, **kwargs): # initialize variables self._clipboard = Clipboard self.info_bubble = None self.qrscanner = None self.nfcscanner = None self.tabs = None self.is_exit = False super(ElectrumWindow, self).__init__(**kwargs) title = _('Electrum App') self.electrum_config = config = kwargs.get('config', None) self.language = config.get('language', 'en') self.network = network = kwargs.get('network', None) self.plugins = kwargs.get('plugins', []) self.gui_object = kwargs.get('gui_object', None) #self.config = self.gui_object.config self.contacts = Contacts(self.electrum_config) self.invoices = InvoiceStore(self.electrum_config) # create triggers so as to minimize updation a max of 2 times a sec self._trigger_update_wallet =\ Clock.create_trigger(self.update_wallet, .5) self._trigger_update_status =\ Clock.create_trigger(self.update_status, .5) self._trigger_notify_transactions = \ Clock.create_trigger(self.notify_transactions, 5)
def __init__(self, **kwargs): self._trigger_grid = Clock.create_trigger(self.fill_grid, -1) self._trigger_cull = Clock.create_trigger(self.cull_children, -1) super(MainPlane, self).__init__(**kwargs) self.register_event_type("on_scene_enter") self.register_event_type("on_scene_leave") self.all_children = [] self._trigger_grid() self._trigger_cull()
def __init__(self, **kwargs): self.register_event_type("on_motion_over") self.register_event_type("on_motion_out") self.register_event_type("on_drag") self._trigger_populate = Clock.create_trigger(self._do_layout, -1) self._trigger_reset_populate = Clock.create_trigger(self._reset_spopulate, -1) super(DNDListView, self).__init__(**kwargs) self.bind(pos=self._trigger_populate, size=self._trigger_populate, data=self._trigger_reset_populate)
def changed(self, collection, _id, fields, cleared): if not self.ready: return if collection == 'minions' and _id == self._id: self.minion = self.meteor.find_one('minions', selector = {'_id': self._id}); self.update_minion_settings(self.minion) if collection == 'stages' and _id == self.minion['stage']: self.stage = self.meteor.find_one('stages', selector = {'_id': self.minion['stage']}) Clock.create_trigger(self.update_layers)()
def __init__(self, controls=None, **kwargs): for action in self.ACTIONS: self.register_event_type('on_' + action) super(PlaybackControl, self).__init__(**kwargs) self._tick_event = Clock.create_trigger( self._tick_position, timeout=0.25, interval=True) self._refresh_event = Clock.create_trigger( self._refresh_position, timeout=5, interval=True)
def Create_RepeatClock(self, touch, *args): ''' create a clock to detect repeating press ''' if oORCA.fStartRepeatDelay>0: self.fktCallBackRepeat = partial(self.fRepeat, touch) FktTrigger = None if self.bFirstRepeat: FktTrigger=Clock.create_trigger(self.fktCallBackRepeat, oORCA.fStartRepeatDelay) else: if oORCA.oTheScreen.uLastTouchType != "end": FktTrigger=Clock.create_trigger(self.fktCallBackRepeat, oORCA.fContRepeatDelay) if FktTrigger: FktTrigger()
def __init__(self, **kwargs): super(ToolbarView, self).__init__(**kwargs) self.current_status = '' self.register_event_type('on_main_menu') self.register_event_type('on_progress') self.register_event_type('on_data_rx') self.register_event_type('on_tele_status') self.register_event_type('on_status') self.register_event_type('on_activity') self._data_rx_decay = Clock.create_trigger(self._on_data_rx_decay, ToolbarView.TOOLBAR_DATA_RX_DURATION) self._activity_decay = Clock.create_trigger(self._on_activity_decay, ToolbarView.ACTIVITY_MESSAGE_LINGER_DURATION) self._progress_decay = Clock.create_trigger(self._on_progress_decay, ToolbarView.PROGRESS_COMPLETE_LINGER_DURATION) self._gps_decay = Clock.create_trigger(self._on_gps_decay, ToolbarView.STATUS_LINGER_DURATION)
def __init__(self, **kwargs): super(FadeScreen, self).__init__(**kwargs) self.opacity = 0 self.inAndOut = Animation(opacity = 1, duration = 2.5) + Animation( opacity = 0, duration = 2.5) self.In = Animation(opacity = 1, duration = 2.) self.Out = Animation(opacity = 0, duration = 2.) self.trigSplashFade = Clock.create_trigger(self.splashFade) self.refocus = Clock.create_trigger(self.refocus_text) self.trigFadeIn = Clock.create_trigger(self.fadeIn) self.dc = 0 #double check self.string = '' #this string is used to switch between screens
def __init__(self, **kwargs): # initialize variables self._clipboard = Clipboard self.info_bubble = None self.nfcscanner = None self.tabs = None self.is_exit = False self.wallet = None self.pause_time = 0 self.asyncio_loop = asyncio.get_event_loop() App.__init__(self)#, **kwargs) title = _('Vialectrum App') self.electrum_config = config = kwargs.get('config', None) self.language = config.get('language', 'en') self.network = network = kwargs.get('network', None) # type: Network if self.network: self.num_blocks = self.network.get_local_height() self.num_nodes = len(self.network.get_interfaces()) net_params = self.network.get_parameters() self.server_host = net_params.host self.server_port = net_params.port self.auto_connect = net_params.auto_connect self.oneserver = net_params.oneserver self.proxy_config = net_params.proxy if net_params.proxy else {} self.update_proxy_str(self.proxy_config) self.plugins = kwargs.get('plugins', []) self.gui_object = kwargs.get('gui_object', None) self.daemon = self.gui_object.daemon self.fx = self.daemon.fx self.use_rbf = config.get('use_rbf', True) self.use_change = config.get('use_change', True) self.use_unconfirmed = not config.get('confirmed_only', False) # create triggers so as to minimize updating a max of 2 times a sec self._trigger_update_wallet = Clock.create_trigger(self.update_wallet, .5) self._trigger_update_status = Clock.create_trigger(self.update_status, .5) self._trigger_update_history = Clock.create_trigger(self.update_history, .5) self._trigger_update_interfaces = Clock.create_trigger(self.update_interfaces, .5) self._periodic_update_status_during_sync = Clock.schedule_interval(self.update_wallet_synchronizing_progress, .5) # cached dialogs self._settings_dialog = None self._password_dialog = None self.fee_status = self.electrum_config.get_fee_status()
def __init__(self, **kwargs): # XXX move to style.kv kwargs.setdefault('size_hint', (None, None)) kwargs.setdefault('scale_min', .4) kwargs.setdefault('scale_max', 1.6) kwargs.setdefault('size', (700, 200)) kwargs.setdefault('docked', False) self._trigger_update_layout_mode = Clock.create_trigger( self._update_layout_mode) self._trigger_load_layouts = Clock.create_trigger( self._load_layouts) self._trigger_load_layout = Clock.create_trigger( self._load_layout) self.bind( docked=self.setup_mode, have_shift=self._trigger_update_layout_mode, have_capslock=self._trigger_update_layout_mode, layout_path=self._trigger_load_layouts, layout=self._trigger_load_layout) self.register_event_type('on_key_down') self.register_event_type('on_key_up') super(VKeyboard, self).__init__(**kwargs) # load all the layouts found in the layout_path directory self._load_layouts() # ensure we have default layouts available_layouts = self.available_layouts if not available_layouts: Logger.critical('VKeyboard: unable to load default layouts') # load the default layout from configuration if self.layout is None: self.layout = Config.get('kivy', 'keyboard_layout') else: # ensure the current layout is found on the available layout self._trigger_load_layout() # update layout mode (shift or normal) self._trigger_update_layout_mode() # create a top layer to draw active keys on with self.canvas: self.background_key_layer = Canvas() self.active_keys_layer = Canvas() # prepare layout widget self.refresh_keys_hint() self.refresh_keys()
def __init__(self, **kwargs): super(ToolbarView, self).__init__(**kwargs) self.current_status = '' self.register_event_type('on_main_menu') self.register_event_type('on_progress') self.register_event_type('on_rc_tx') self.register_event_type('on_rc_rx') self.register_event_type('on_tele_status') self.register_event_type('on_status') self.register_event_type('on_activity') self._rcTxDecay = Clock.create_trigger(self.on_rc_tx_decay, TOOLBAR_LED_DURATION) self._rcRxDecay = Clock.create_trigger(self.on_rc_rx_decay, TOOLBAR_LED_DURATION) self._activityDecay = Clock.create_trigger(self.on_activity_decay, ACTIVITY_MESSAGE_LINGER_DURATION) self._progressDecay = Clock.create_trigger(self.on_progress_decay, PROGRESS_COMPLETE_LINGER_DURATION)
def __init__(self, **kwargs): super(CreateAccountDialog, self).__init__(**kwargs) self.action = kwargs.get('action') _trigger_size_dialog = Clock.create_trigger(self._size_dialog) Window.bind(size=_trigger_size_dialog, rotation=_trigger_size_dialog) _trigger_size_dialog()
def __init__(self, **kwargs): self.register_event_type('on_subprocess_done') super(KivyConsole, self).__init__(**kwargs) # initialisations self.txtinput_command_line_refocus = False self.txtinput_run_command_refocus = False self.win = None self.scheduled = False self.command_history = [] self.command_history_pos = 0 self.command_status = 'closed' if sys.version_info >= (3, 0): self.cur_dir = os.getcwd() else: self.cur_dir = os.getcwdu() self.stdout = std_in_out(self, 'stdout') self.stdin = std_in_out(self, 'stdin') # self.stderror = stderror(self) # delayed initialisation Clock.schedule_once(self._initialize) self_change_txtcache = self._change_txtcache _trig = Clock.create_trigger(self_change_txtcache) self.bind(textcache=_trig) self._hostname = 'unknown' try: if hasattr(os, 'uname'): self._hostname = os.uname()[1] else: self._hostname = os.environ.get('COMPUTERNAME', 'unknown') except Exception: pass self._username = os.environ.get('USER', '') if not self._username: self._username = os.environ.get('USERNAME', 'unknown')
def __init__(self, **kwargs): self._color = Color(1, 1, 1, group='LinePlot%d' % id(self)) self._mesh = Mesh(mode='line_strip', group='LinePlot%d' % id(self)) super(MeshLinePlot, self).__init__(**kwargs) self._trigger = Clock.create_trigger(self._redraw) self.bind(_params=self._trigger, points=self._trigger)
def __init__(self, **kwargs): Builder.load_string(FLYIN_PANEL_LAYOUT) super(FlyinPanel, self).__init__(**kwargs) self.hide_decay = Clock.create_trigger(lambda dt: self.hide(), self.SESSION_HIDE_DELAY) Window.bind(mouse_pos=self.on_mouse_pos) Window.bind(on_motion=self.on_motion) Clock.schedule_once(lambda dt: self.show())
def __init__(self, **kwargs): self._trigger_load = Clock.create_trigger(self._load_from_text, -1) self._parser = rst.Parser() self._settings = frontend.OptionParser( components=(rst.Parser, ) ).get_default_values() super(RstDocument, self).__init__(**kwargs)
def __init__(self, **kwargs): self._touch = None self._trigger_update_from_scroll = Clock.create_trigger( self.update_from_scroll, -1) # new in 1.8 .. self.bar_pos_x="bottom" self.bar_pos_y="right" super(ScrollView, self).__init__(**kwargs) if self.effect_x is None and self.effect_cls is not None: self.effect_x = self.effect_cls(target_widget=self._viewport) if self.effect_y is None and self.effect_cls is not None: self.effect_y = self.effect_cls(target_widget=self._viewport) self.bind( width=self._update_effect_x_bounds, height=self._update_effect_y_bounds, viewport_size=self._update_effect_bounds, _viewport=self._update_effect_widget, scroll_x=self._trigger_update_from_scroll, scroll_y=self._trigger_update_from_scroll, pos=self._trigger_update_from_scroll, size=self._trigger_update_from_scroll) self._update_effect_widget() self._update_effect_x_bounds() self._update_effect_y_bounds()
def __init__(self, **kwargs): # Check for an adapter argument. If it doesn't exist, we # check for item_strings in use with SimpleListAdapter # to make a simple list. if 'adapter' not in kwargs: if 'item_strings' not in kwargs: # Could be missing, or it could be that the ListView is # declared in a kv file. If kv is in use, and item_strings is # declared there, then item_strings will not be set until after # __init__(). So, the data=[] set will temporarily serve for # SimpleListAdapter instantiation, with the binding to # item_strings_changed() handling the eventual set of the # item_strings property from the application of kv rules. list_adapter = SimpleListAdapter(data=[], cls=Label) else: list_adapter = SimpleListAdapter(data=kwargs['item_strings'], cls=Label) kwargs['adapter'] = list_adapter super(ListView, self).__init__(**kwargs) self._trigger_populate = Clock.create_trigger(self._spopulate, -1) self.bind(size=self._trigger_populate, pos=self._trigger_populate, item_strings=self.item_strings_changed, adapter=self._trigger_populate) # The bindings setup above sets self._trigger_populate() to fire # when the adapter changes, but we also need this binding for when # adapter.data and other possible triggers change for view updating. # We don't know that these are, so we ask the adapter to set up the # bindings back to the view updating function here. self.adapter.bind_triggers_to_view(self._trigger_populate)
def __init__(self, url, on_success=None, on_error=None, on_progress=None, req_body=None, req_headers=None, chunk_size=8192, timeout=None): super(UrlRequest, self).__init__() self._queue = deque() self._trigger_result = Clock.create_trigger(self._dispatch_result, 0) self.daemon = True self.on_success = on_success self.on_error = on_error self.on_progress = on_progress self._result = None self._error = None self._is_finished = False self._resp_status = None self._resp_headers = None self._resp_length = -1 self._chunk_size = chunk_size self._timeout = timeout #: Url of the request self.url = url #: Request body passed in __init__ self.req_body = req_body #: Request headers passed in __init__ self.req_headers = req_headers self.start()
def __init__(self, wizard, **kwargs): self.auto_dismiss = False super(WizardDialog, self).__init__() self.wizard = wizard self.ids.back.disabled = not wizard.can_go_back() self.app = App.get_running_app() self.run_next = kwargs['run_next'] self._trigger_size_dialog = Clock.create_trigger(self._size_dialog) # note: everything bound here needs to be unbound as otherwise the # objects will be kept around and keep receiving the callbacks Window.bind(size=self._trigger_size_dialog, rotation=self._trigger_size_dialog, on_keyboard=self.on_keyboard) self._trigger_size_dialog() self._on_release = False
async def _watch_touch_events(self): from asynckivy import animate, rest_of_touch_moves, event, MotionEventAlreadyEndedError, cancel_protection def accepts_touch(w, t) -> bool: return w.collide_point(*t.opos) and (not t.is_mouse_scrolling) # 'itertools.cycle()' is no use here because it cannot react to # the property changes. There might be a better way than this, though. def color_iter(w): while True: yield w.border_color2 yield w.border_color1 color_iter = color_iter(self) def change_border_color(dt): self._border_color = next(color_iter) blink_ev = Clock.create_trigger(change_border_color, .1, interval=True) collide_point = self.collide_point dispatch = self.dispatch try: while True: __, touch = await event(self, 'on_touch_down', filter=accepts_touch, stop_dispatching=True) dispatch('on_press') blink_ev() try: async for __ in rest_of_touch_moves(self, touch, stop_dispatching=True): if collide_point(*touch.pos): blink_ev() else: blink_ev.cancel() self._border_color = self.border_color1 except MotionEventAlreadyEndedError: blink_ev.cancel() self._border_color = self.border_color1 continue if collide_point(*touch.pos): async with cancel_protection(): await animate(self, _scaling=.9, d=.05) await animate(self, _scaling=1, d=.05) dispatch('on_release') blink_ev.cancel() self._border_color = self.border_color1 finally: blink_ev.cancel() self._border_color = self.border_color1
def load_game(self, save_slot): #Show 1 & 0 on the first screen self.show_bars() self.update_outer() self.update_inner() #Define a finished "Block" def finished_block(sub_loader, callbacks): if sub_loader.triggers_finished == sub_loader.triggers_total: for callback in callbacks: if callback is not None: callback() def load_block(trigger_index, callbacks): block_triggers = [] block_loader = LOADING_FUNCTIONS[trigger_index] filename = None if trigger_index == SAVE_INDEX: filename = f'{save_slot}' if LOADING_FILES[trigger_index]: filename = LOADING_FILENAMES[trigger_index] filepath = resource_find(filename) if filepath is None: raise Exception(f"Cannot find file: {filename}") with open(filepath, 'r', encoding='utf-8') as file: chunks = file.read().split(LOADING_DELIMITERS[self.curr_values[CURRENT_INDEX] - 1]) self.max_values[self.curr_values[CURRENT_INDEX]] = len(chunks) for chunk in chunks: if chunk.startswith(COMMENT_CHARACTER): continue block_triggers.append(Clock.create_trigger(lambda dt, c=chunk: block_loader(c, self, self.program_type, [self.increase_current, sub_loader.inc_triggers, lambda: sub_loader.start(), lambda: finished_block(sub_loader, callbacks)]))) else: block_triggers.append(Clock.create_trigger(lambda dt: block_loader(self, self.program_type, filename, [self.increase_current, sub_loader.inc_triggers, lambda: sub_loader.start(), lambda: finished_block(sub_loader, callbacks)]))) sub_loader = GameLoader(block_triggers) sub_loader.triggers_total = len(block_triggers) sub_loader.start() triggers = [Clock.create_trigger(lambda dt, xindex=index: load_block(xindex, [self.increase_total, loader.inc_triggers, lambda: loader.start(), lambda: self.done_loading(loader)])) for index in range(len(LOADING_SECTIONS))] loader = GameLoader(triggers) loader.triggers_total = len(triggers) loader.start()
class Snake(Widget): def stop(self): exit(1) t = Clock.create_trigger(stop,timeout = 4) xarr=[] yarr=[] def move1(self,data): if self.check(data): return False self.pos = Vector(*self.velocity)+self.pos data["line1"].points = (self.center_x,self.center_y) self.xarr.append(self.pos[0]) self.yarr.append(self.pos[1]) return True def convert(self,data): x_pix,y_pix = data['pix'] divx,divy = data['div'] x,y = self.pos x = floor(float(x)/float(x_pix/divx)) y = floor(float(y)/float(y_pix/divy)) n = (divx)*y + x if n<divx*divy: return int(n) else: print "large value",n,self.pos,x,y return 300 def convert1(self,pos,data): x_pix,y_pix = data['pix'] divx,divy = data['div'] x,y = pos x = floor(float(x)/float(x_pix/divx)) y = floor(float(y)/float(y_pix/divy)) n = (divx)*y + x if n<divx*divy: return int(n) else: print "large value",n,self.pos,x,y return 300 def check(self,data): pos = Vector(*self.velocity)+self.pos if data['occupied'][self.convert1(pos,data)]==1: return(1)
def __init__(self, **kwargs): self._trigger_texture = Clock.create_trigger(self.texture_update, -1) super(Label, self).__init__(**kwargs) # bind all the property for recreating the texture d = ('text', 'font_size', 'font_name', 'bold', 'italic', 'halign', 'valign', 'padding_x', 'padding_y', 'text_size', 'shorten') dkw = {} for x in d: dkw[x] = partial(self._trigger_texture_update, x) self.bind(**dkw) dkw = dict(zip(d, [getattr(self, x) for x in d])) self._label = CoreLabel(**dkw) # force the texture creation self.texture_update()
def __init__(self, **kwargs): self._refresh_flags = dict(self._refresh_flags) self._refresh_trigger = Clock.create_trigger(self.refresh_views, -1) if self._layout_manager is None: self.layout_manager = LinearRecycleLayoutManager() if self._adapter is None: self.adapter = RecycleAdapter() super(RecycleView, self).__init__(**kwargs) if self._container is None: self.container = RecycleViewLayout(size_hint=(None, None)) fbind = self.fbind if _kivy_1_9_1 else self.fast_bind fbind('size', self.ask_refresh_from_data, extent='data_size') fbind('scroll_x', self.ask_refresh_viewport) fbind('scroll_y', self.ask_refresh_viewport) self._refresh_trigger()
def __init__(self, track_manager, rc_api, rc_config, **kwargs): self._initialized = False self._view_builders = OrderedDict() super(DashboardView, self).__init__(**kwargs) self.register_event_type('on_tracks_updated') self._databus = kwargs.get('dataBus') self._settings = kwargs.get('settings') self._track_manager = track_manager self._rc_api = rc_api self._rc_config = rc_config self._alert_widgets = {} self._dismiss_popup_trigger = Clock.create_trigger( self._dismiss_popup, DashboardView._POPUP_DISMISS_TIMEOUT_LONG) self._popup = None self._race_setup_view = None self._selected_track = None self._track_config = None
def __init__(self, **kwargs): self._trigger_texture = Clock.create_trigger(self.texture_update, -1) self.register_event_type('on_ref_press') super(Label, self).__init__(**kwargs) # bind all the property for recreating the texture d = Label._font_properties dkw = {} for x in d: dkw[x] = partial(self._trigger_texture_update, x) self.bind(**dkw) self._label = None self._create_label() # force the texture creation self._trigger_texture()
def __init__(self, url, on_success=None, on_redirect=None, on_failure=None, on_error=None, on_progress=None, req_body=None, req_headers=None, chunk_size=8192, timeout=None, method=None, decode=True, debug=False, file_path=None, ca_file=None, verify=True, proxy_host=None, proxy_port=None, proxy_headers=None): super(UrlRequest, self).__init__() self._queue = deque() self._trigger_result = Clock.create_trigger(self._dispatch_result, 0) self.daemon = True self.on_success = WeakMethod(on_success) if on_success else None self.on_redirect = WeakMethod(on_redirect) if on_redirect else None self.on_failure = WeakMethod(on_failure) if on_failure else None self.on_error = WeakMethod(on_error) if on_error else None self.on_progress = WeakMethod(on_progress) if on_progress else None self.decode = decode self.file_path = file_path self._debug = debug self._result = None self._error = None self._is_finished = False self._resp_status = None self._resp_headers = None self._resp_length = -1 self._chunk_size = chunk_size self._timeout = timeout self._method = method self.ca_file = ca_file self.verify = verify self._proxy_host = proxy_host self._proxy_port = proxy_port self._proxy_headers = proxy_headers #: Url of the request self.url = url #: Request body passed in __init__ self.req_body = req_body #: Request headers passed in __init__ self.req_headers = req_headers # save our request to prevent GC g_requests.append(self) self.start()
def __init__(self, **kwargs): # Check for adapter argument if 'adapter' not in kwargs: list_adapter = SimpleListAdapter(data=[], cls=Label) kwargs['adapter'] = list_adapter super(ChatLog, self).__init__(**kwargs) self._views = [] populate = self._trigger_populate = Clock.create_trigger( self._populate, -1) fbind = self.fbind fbind('adapter', populate) fbind('size', populate) fbind('pos', populate)
def on_scroll_stop(self, touch, check_children=True): self._touch = None if check_children: touch.push() touch.apply_transform_2d(self.to_local) if self.dispatch_children('on_scroll_stop', touch): touch.pop() return True touch.pop() if self._get_uid('svavoid') in touch.ud: return if self._get_uid() not in touch.ud: return False self._touch = None uid = self._get_uid() ud = touch.ud[uid] if self.do_scroll_x and self.effect_x: if not touch.ud.get('in_bar_x', False) and\ self.scroll_type != ['bars']: self.effect_x.stop(touch.x) if self.do_scroll_y and self.effect_y and\ self.scroll_type != ['bars']: if not touch.ud.get('in_bar_y', False): self.effect_y.stop(touch.y) if ud['mode'] == 'unknown': # we must do the click at least.. # only send the click if it was not a click to stop # autoscrolling if not ud['user_stopped']: self.simulate_touch_down(touch) Clock.schedule_once(partial(self._do_touch_up, touch), .2) ev = self._update_effect_bounds_ev if ev is None: ev = self._update_effect_bounds_ev = Clock.create_trigger( self._update_effect_bounds) ev() # if we do mouse scrolling, always accept it if 'button' in touch.profile and touch.button.startswith('scroll'): return True return self._get_uid() in touch.ud
def click_start(self): """ This method is to start the graph plot upon click start button It initialize the attributes for the graph plot """ if not self.on_going: # Check if the tracert is ongoing. To prevent multiple thread on start self.on_going = True self.hop_dict = {0: {'time': 0}} self.plot = None # Variable for checking if plot is added to graph self.traceroute = my_network.my_traceroute( self.ids.host_input.text ) # Issue Tracert in external command line and return generator self.event1 = Clock.create_trigger( self.update_graph, 0.1 ) # Create a trigger event of method update_graph to make a repeated check of graph self.stop_thread = False # Variable for checking the signal to stop the threading self.on_start()
def __init__(self, **kwargs): self._trigger_texture = Clock.create_trigger(self.texture_update, -1) self._trigger_markup_color = partial(self._trigger_texture_update, 'color') super(Label, self).__init__(**kwargs) # bind all the property for recreating the texture d = Label._font_properties fbind = self.fast_bind update = self._trigger_texture_update for x in d: fbind(x, update, x) self._label = None self._create_label() # force the texture creation self._trigger_texture()
def __init__(self, **kwargs): self._trigger_texture = Clock.create_trigger(self.texture_update, -1) super(Label, self).__init__(**kwargs) # bind all the property for recreating the texture d = Label._font_properties fbind = self.fbind update = self._trigger_texture_update fbind('disabled', update, 'disabled') for x in d: fbind(x, update, x) self._label = None self._create_label() # force the texture creation self._trigger_texture()
def update_from_scroll(self, *largs): '''Force the reposition of the content, according to current value of :attr:`scroll_x` and :attr:`scroll_y`. This method is automatically called when one of the :attr:`scroll_x`, :attr:`scroll_y`, :attr:`pos` or :attr:`size` properties change, or if the size of the content changes. ''' if not self._viewport: return vp = self._viewport # update from size_hint if vp.size_hint_x is not None: vp.width = vp.size_hint_x * self.width if vp.size_hint_y is not None: vp.height = vp.size_hint_y * self.height if vp.width > self.width: sw = vp.width - self.width x = self.x - self.scroll_x * sw else: x = self.x if vp.height > self.height: sh = vp.height - self.height y = self.y - self.scroll_y * sh else: y = self.top - vp.height # from 1.8.0, we now use a matrix by default, instead of moving the # widget position behind. We set it here, but it will be a no-op most of # the time. vp.pos = 0, 0 self.g_translate.xy = x, y # New in 1.2.0, show bar when scrolling happens and (changed in 1.9.0) # fade to bar_inactive_color when no scroll is happening. ev = self._bind_inactive_bar_color_ev if ev is None: ev = self._bind_inactive_bar_color_ev = Clock.create_trigger( self._bind_inactive_bar_color, .5) self.funbind('bar_inactive_color', self._change_bar_color) Animation.stop_all(self, '_bar_color') self.fbind('bar_color', self._change_bar_color) self._bar_color = self.bar_color ev()
def __init__(self, **kwargs): super(ProductScreen, self).__init__(**kwargs) self.connectionManager = ObjectProperty(None) self.productScreenService = ProductScreenService() self.id = None self.product_name = ObjectProperty(None) self.product_description = ObjectProperty(None) self.buy_price = ObjectProperty(None) self.sell_price = ObjectProperty(None) self.current_quantity = ObjectProperty(None) self.input_quantity = ObjectProperty(None) self.spinner = ObjectProperty(None) self.scrollView = ObjectProperty(None) self.bind_trigger = Clock.create_trigger(self.bind_model) self.event = None
def __init__(self, **kwargs): _settings = None _databus = None _screen_mgr = None _gaugeView = None _tachView = None _rawchannelView = None _laptimeView = None _comboView = None super(DashboardView, self).__init__(**kwargs) self.register_event_type('on_tracks_updated') self._databus = kwargs.get('dataBus') self._settings = kwargs.get('settings') self._alert_widgets = {} self.init_view() self._dismiss_popup_trigger = Clock.create_trigger( self._dismiss_popup, POPUP_DISMISS_TIMEOUT_LONG) self._popup = None
def __init__(self): self._loading_image = None self._error_image = None self._num_workers = 2 self._max_upload_per_frame = 2 self._paused = False self._resume_cond = threading.Condition() self._q_load = deque() self._q_done = deque() self._client = [] self._running = False self._start_wanted = False self._trigger_update = Clock.create_trigger(self._update) if platform == 'android': import certifi environ.setdefault('SSL_CERT_FILE', certifi.where())
def play(self): if self.player_state == PLAYER_STATE_PLAYING: self.player_state = PLAYER_STATE_PAUSED return elif self.player_state == PLAYER_STATE_PAUSED: self.player_state = PLAYER_STATE_PLAYING return else: if self.midi_file and self.midi_messages: print("loading up midi_messages of len {} and input_queue empty: {}".format(len(self.midi_messages), self.midi_player.input_queue.empty())) for msg in self.midi_messages: self.midi_player.input_queue.put(msg, block=True, timeout=2) self.midi_player.input_queue.put(mido.Message('stop'), block=True, timeout=2) self.meta_poll_trigger = Clock.create_trigger(self.poll_midi_metadata, 1/30) self.meta_poll_trigger() self.player_state = PLAYER_STATE_PLAYING
def __init__(self, **kw): self._trigger_genitems = Clock.create_trigger(self._genitems, -1) self.bind(min=self._trigger_genitems, max=self._trigger_genitems, multiples_of=self._trigger_genitems) super(CircularNumberPicker, self).__init__(**kw) self.selected = self.min self.bind(selected=self.on_selected, pos=self.on_selected, size=self.on_selected) cx = self.center_x + self.padding[0] - self.padding[2] cy = self.center_y + self.padding[3] - self.padding[1] sx, sy = self.pos_for_number(self.selected) epos = [ i - (self.delta_radii * self.number_size_factor) for i in (sx, sy) ] esize = [self.delta_radii * self.number_size_factor * 2] * 2 dsize = [i * .3 for i in esize] dpos = [i + esize[0] / 2. - dsize[0] / 2. for i in epos] csize = [i * .05 for i in esize] cpos = [i - csize[0] / 2. for i in (cx, cy)] dot_alpha = 0 if self.selected % self.multiples_of == 0 else 1 color = list(self.selector_color) with self.canvas: self._selection_color = Color(*(color + [self.selector_alpha])) self._selection_circle = Ellipse(pos=epos, size=esize) self._selection_line = Line(points=[cx, cy, sx, sy], width=dp(1.25)) self._selection_dot_color = Color(*(color + [dot_alpha])) self._selection_dot = Ellipse(pos=dpos, size=dsize) self._center_color = Color(*self.color) self._center_dot = Ellipse(pos=cpos, size=csize) self.bind(selector_color=lambda ign, u: setattr( self._selection_color, "rgba", u + [self.selector_alpha])) self.bind(selector_color=lambda ign, u: setattr( self._selection_dot_color, "rgb", u)) self.bind(selector_color=lambda ign, u: self.dot_is_none()) self.bind(color=lambda ign, u: setattr(self._center_color, "rgb", u)) Clock.schedule_once(self._genitems) Clock.schedule_once( self.on_selected) # Just to make sure pos/size are set
def get_preferences(self, code, platform): page = OAuthInfoPage() page_name = 'oauth_page' switch_screen(page, page_name) def retry(*args): self.snackbar.dismiss() self.retry_event.cancel() self.get_preferences(code, platform) return def get_and_save_preferences(*args): if req.status_code == 200: self.app.genres = req.response['genres'] self.app.artists = req.response['artists'] Logger.debug(self.app.genres) if self.app.genres: OAuthCompletePage(self.app.genres, self.app.artists) else: msg = (f"Sorry, couldn't guess " f"preferences from {platform.capitalize()}") for button in self.ids.choices_layout.children[0].children: if platform in button.text.lower(): button.disabled = True break self.snackbar = create_snackbar(msg, callback=None) self.app.screen_manager.switch_to(self.parent) self.snackbar.open() else: msg = "Failed to get preferences. Retrying in 3 seconds." self.snackbar = create_snackbar(msg, retry) self.retry_event = Clock.schedule_once(retry, 3) self.snackbar.open() if self.get_preferences_trigger is None: self.get_preferences_trigger = Clock.create_trigger( get_and_save_preferences ) req = self.app.api.get_preferences( code=code, platform=platform, trigger=self.get_preferences_trigger )
def __init__(self, **kwargs): self._touch = None self._trigger_update_from_scroll = Clock.create_trigger( self.update_from_scroll, -1) # create a specific canvas for the viewport from kivy.graphics import PushMatrix, Translate, PopMatrix, Canvas self.canvas_viewport = Canvas() self.canvas = Canvas() with self.canvas_viewport.before: PushMatrix() self.g_translate = Translate(0, 0) with self.canvas_viewport.after: PopMatrix() super(ScrollView, self).__init__(**kwargs) self.register_event_type('on_scroll_start') self.register_event_type('on_scroll_move') self.register_event_type('on_scroll_stop') # now add the viewport canvas to our canvas self.canvas.add(self.canvas_viewport) effect_cls = self.effect_cls if isinstance(effect_cls, string_types): effect_cls = Factory.get(effect_cls) if self.effect_x is None and effect_cls is not None: self.effect_x = effect_cls(target_widget=self._viewport) if self.effect_y is None and effect_cls is not None: self.effect_y = effect_cls(target_widget=self._viewport) self.bind( width=self._update_effect_x_bounds, height=self._update_effect_y_bounds, viewport_size=self._update_effect_bounds, _viewport=self._update_effect_widget, scroll_x=self._trigger_update_from_scroll, scroll_y=self._trigger_update_from_scroll, pos=self._trigger_update_from_scroll, size=self._trigger_update_from_scroll) self._update_effect_widget() self._update_effect_x_bounds() self._update_effect_y_bounds()
def __init__(self, **kwargs): super(hitBang, self).__init__(**kwargs) self.animation = Clock.create_trigger(self.animateHit, 0.25) self.cur_pos = (0.0, 0.0) self.ani = 0 self._shot = ScatterLayout(size=(self.width_shot, self.height_shot), do_rotate=False, do_scale=False, do_translation=False) _img_shot = Image(source=self.file_pin, size=(self.width_shot, self.height_shot), allow_stretch=True) self._shot.add_widget(_img_shot) self.add_widget(self._shot) self.bind(pos=self._update) self.bind(size=self._update)
def __init__(self, **kwargs): self._trigger_layout = Clock.create_trigger(self._do_layout, -1) # root_widget = kwargs.pop("root_widget", FlexTreeViewLabel) super(FlexTreeView, self).__init__(**kwargs) tvlabel = FlexTreeViewLabel(text='Root', is_open=True, level=0) for key, value in self.root_options.items(): setattr(tvlabel, key, value) self._root = self.add_node(tvlabel, None) trigger = self._trigger_layout fbind = self.fbind fbind('pos', trigger) fbind('size', trigger) fbind('indent_level', trigger) fbind('indent_start', trigger) trigger()
def __init__(self, url, on_success=None, on_error=None, on_progress=None, req_body=None, req_headers=None, chunk_size=8192, timeout=None, method=None, debug=False): super(UrlRequest, self).__init__() self._queue = deque() self._trigger_result = Clock.create_trigger(self._dispatch_result, 0) self.daemon = True self.on_success = WeakMethod(on_success) if on_success else None self.on_error = WeakMethod(on_error) if on_error else None self.on_progress = WeakMethod(on_progress) if on_progress else None self._debug = debug self._result = None self._error = None self._is_finished = False self._resp_status = None self._resp_headers = None self._resp_length = -1 self._chunk_size = chunk_size self._timeout = timeout self._method = method #: Url of the request self.url = url #: Request body passed in __init__ self.req_body = req_body #: Request headers passed in __init__ self.req_headers = req_headers # save our request to prevent GC g_requests.append(self) self.start()
def __init__(self, **kwargs): self.canvas_size = kwargs.get("canvas_size", Window.size) super(Layout3D, self).__init__(**kwargs) self._trigger_layout = Clock.create_trigger(self.do_layout, -1) effectwidget.C_SIZE = self.canvas_size with self.canvas.before: Color(1.0, 1.0, 1.0, 1.0) ClearColor(1.0, 1.0, 1.0, 1.0) self.create_canvas() self.bind(look_at=self.canvas3d.setter('look_at')) self.bind(shadow_offset=self.canvas3d.setter('_shadow_offset')) self.bind(shadow_threshold=self.canvas3d.setter('shadow_threshold')) self.bind(shadow_origin=self.canvas3d.setter('_shadow_pos')) self.bind(shadow_target=self.canvas3d.setter('_shadow_target')) self.bind(picking_scale=self.canvas3d.setter('picking_scale')) self.bind(canvas_size=self.canvas3d.setter('canvas_size')) self.effect_widget = BlurEffectWidget( mask_effect=self.canvas3d.picking_fbo, motion_effect=self.canvas3d.motion_blur_fbo) if self._init_request[0]: self.post_processing = not self._init_request[1] self.post_processing = self._init_request[1] self._init_request[0] = True from kivy3dgui.canvas3d import label, label_debug label.parent = None try: self.add_widget(label) self.add_widget(label_debug) except Exception as w: pass self.render_texture = Image(size_hint=(1.0, 1.0), allow_stretch=True, keep_ratio=False) self.add_widget(self.render_texture, 100000) self.render_texture.texture = self.canvas3d.canvas.texture self.bind(pos=self.render_texture.setter('pos')) self.bind(size=self.render_texture.setter('size'))
def __init__(self, **kwargs): self.register_event_type('on_subprocess_done') super(KivyConsole, self).__init__(**kwargs) # initialisations self.txtinput_command_line_refocus = False self.txtinput_run_command_refocus = False self.win = None self.scheduled = False self.command_history = [] self.command_history_pos = 0 self.command_status = 'closed' self.cur_dir = os.getcwdu() self.stdout = std_in_out(self, 'stdout') self.stdin = std_in_out(self, 'stdin') # self.stderror = stderror(self) # delayed initialisation Clock.schedule_once(self._initialize) self_change_txtcache = self._change_txtcache _trig = Clock.create_trigger(self_change_txtcache) self.bind(textcache=_trig)
def __init__( self, func=None, prop_name=None, allow_empty=False, track_obj=None, track_prop='', values_getter=lambda x: x, **kwargs): super(TrackOptionsSpinner, self).__init__(**kwargs) self.func = func self.prop_name = prop_name self.allow_empty = allow_empty self.track_obj = track_obj self.track_prop = track_prop self.values_getter = values_getter self._value_trigger = Clock.create_trigger(self._update_values, -1) if self.update_items_on_press: self.spinner.fbind('on_press', self._value_trigger) else: track_obj.fbind(track_prop, self._value_trigger) func.fbind(prop_name, self._update_text) self.fbind('text', self._update_attr) self._update_text() self._update_values()
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 __init__(self, **kwargs): self._trigger_texture = Clock.create_trigger(self.texture_update, -1) super(Label, self).__init__(**kwargs) # bind all the property for recreating the texture d = Label._font_properties fbind = self.fbind update = self._trigger_texture_update for x in d: fbind(x, update, x) self._label = None self._create_label() fbind('markup', self._bind_for_markup) if self.markup: self._bind_for_markup(self, self.markup) # force the texture creation self._trigger_texture()