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()
