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 _configure(self): from time import strftime from kivy.config import Config log_dir = Config.get("kivy", "log_dir") log_name = Config.get("kivy", "log_name") _dir = kivy.kivy_home_dir if len(log_dir) and log_dir[0] == "/": _dir = log_dir else: _dir = os.path.join(_dir, log_dir) if not os.path.exists(_dir): os.mkdir(_dir) self.purge_logs(_dir) pattern = log_name.replace("%_", "@@NUMBER@@") pattern = os.path.join(_dir, strftime(pattern)) n = 0 while True: filename = pattern.replace("@@NUMBER@@", str(n)) if not os.path.exists(filename): break n += 1 if n > 10000: # prevent maybe flooding ? raise Exception("Too many logfile, remove them") FileHandler.filename = filename FileHandler.fd = open(filename, "w") Logger.info("Logger: Record log in %s" % filename)
def build(self): config = self.config # Input if config.getboolean("input", "tuio"): try: KivyConfig.get("input", "tuiotouchscreen") except (NoSectionError, NoOptionError): KivyConfig.set('input', 'tuiotouchscreen', 'tuio,0.0.0.0:3333') KivyConfig.write() if config.getboolean("input", "touch"): # Enable mouse interface kv_filename = 'gameoflife-nontuio.kv' else: kv_filename = 'gameoflife-tuio.kv' # Game self.speed = config.getint("game", "speed") self.iterations_per_turn = config.getint("game", "iterations_per_turn") self.top_score = config.getint("game", "top_score") self.minimum_pieces = config.getint("game", "minimum_pieces") # Root widget self.root = Builder.load_file(kv_filename) self.root.app = self # Grid self.root.grid.rows = config.getint("grid", "rows") self.root.grid.cols = config.getint("grid", "cols") self.root.grid.cell_size = config.getint("grid", "cell_size")
def _configure(self, *largs, **kwargs): from time import strftime from kivy.config import Config log_dir = Config.get('kivy', 'log_dir') log_name = Config.get('kivy', 'log_name') _dir = kivy.kivy_home_dir if log_dir and os.path.isabs(log_dir): _dir = log_dir else: _dir = os.path.join(_dir, log_dir) if not os.path.exists(_dir): os.makedirs(_dir) self.purge_logs(_dir) pattern = log_name.replace('%_', '@@NUMBER@@') pattern = os.path.join(_dir, strftime(pattern)) n = 0 while True: filename = pattern.replace('@@NUMBER@@', str(n)) if not os.path.exists(filename): break n += 1 if n > 10000: # prevent maybe flooding ? raise Exception('Too many logfile, remove them') if FileHandler.filename == filename and FileHandler.fd is not None: return FileHandler.filename = filename if FileHandler.fd is not None: FileHandler.fd.close() FileHandler.fd = open(filename, 'w') Logger.info('Logger: Record log in %s' % filename)
def _configure_module(self, name): if 'module' not in self.mods[name]: try: self.import_module(name) except ImportError: return # convert configuration like: # -m mjpegserver:port=8080,fps=8 # and pass it in context.config token config = dict() args = Config.get('modules', name) if args != '': values = Config.get('modules', name).split(',') for value in values: x = value.split('=', 1) if len(x) == 1: config[x[0]] = True else: config[x[0]] = x[1] self.mods[name]['context'].config = config # call configure if module have one if hasattr(self.mods[name]['module'], 'configure'): self.mods[name]['module'].configure(config)
def _configure(self): from time import strftime from kivy.config import Config log_dir = Config.get('kivy', 'log_dir') log_name = Config.get('kivy', 'log_name') _dir = kivy.kivy_home_dir if len(log_dir) and log_dir[0] == '/': _dir = log_dir else: _dir = os.path.join(_dir, log_dir) if not os.path.exists(_dir): os.mkdir(_dir) self.purge_logs(_dir) pattern = log_name.replace('%_', '@@NUMBER@@') pattern = os.path.join(_dir, strftime(pattern)) n = 0 while True: filename = pattern.replace('@@NUMBER@@', str(n)) if not os.path.exists(filename): break n += 1 if n > 10000: # prevent maybe flooding ? raise Exception('Too many logfile, remove them') FileHandler.filename = filename FileHandler.fd = open(filename, 'w') Logger.info('Logger: Record log in %s' % filename)
def activate_module(self, name, win): '''Activate a module on a window''' if not name in self.mods: Logger.warning('Modules: Module <%s> not found' % name) return if not 'module' in self.mods[name]: try: self.import_module(name) except ImportError: return module = self.mods[name]['module'] if not self.mods[name]['activated']: # convert configuration like: # -m mjpegserver:port=8080,fps=8 # and pass it in context.config token config = dict() args = Config.get('modules', name) if args != '': values = Config.get('modules', name).split(',') for value in values: x = value.split('=', 1) if len(x) == 1: config[x[0]] = True else: config[x[0]] = x[1] msg = 'Modules: Start <%s> with config %s' % (name, str(config)) Logger.debug(msg) self.mods[name]['context'].config = config module.start(win, self.mods[name]['context'])
def _configure_module(self, name): if "module" not in self.mods[name]: try: self.import_module(name) except ImportError: return # convert configuration like: # -m mjpegserver:port=8080,fps=8 # and pass it in context.config token config = dict() args = Config.get("modules", name) if args != "": values = Config.get("modules", name).split(",") for value in values: x = value.split("=", 1) if len(x) == 1: config[x[0]] = True else: config[x[0]] = x[1] self.mods[name]["context"].config = config # call configure if module have one if hasattr(self.mods[name]["module"], "configure"): self.mods[name]["module"].configure(config)
def build(self): #Set window's size print(Config.get('graphics', 'width')) print(Config.get('graphics', 'height')) #Start the game game = Game3() Clock.schedule_interval(game.update, 1.0 / 60.0) Clock.schedule_interval(game.increment_clock, 1.0) return game
def __init__(self, **kwargs): super(KeyboardTest, self).__init__(**kwargs) #self._add_numeric() # Please see below self._add_keyboards() self._keyboard = None #TODO: Remove or document? Logger.info("main.py: keyboard_mode=" + Config.get("kivy", "keyboard_mode")) Config.set("kivy", "keyboard_mode", "dock") Config.write() Logger.info("main.py: 2. keyboard_mode=" + Config.get("kivy", "keyboard_mode"))
def configure_keyboards(self): # Configure how to provide keyboards (virtual or not) # register system keyboard to listening keys from window sk = self._system_keyboard self.bind( on_key_down=sk._on_window_key_down, on_key_up=sk._on_window_key_up, on_textinput=sk._on_window_textinput) # use the device's real keyboard self.use_syskeyboard = True # use the device's real keyboard self.allow_vkeyboard = False # one single vkeyboard shared between all widgets self.single_vkeyboard = True # the single vkeyboard is always sitting at the same position self.docked_vkeyboard = False # now read the configuration mode = Config.get('kivy', 'keyboard_mode') if mode not in ('', 'system', 'dock', 'multi', 'systemanddock', 'systemandmulti'): Logger.critical('Window: unknown keyboard mode %r' % mode) # adapt mode according to the configuration if mode == 'system': self.use_syskeyboard = True self.allow_vkeyboard = False self.single_vkeyboard = True self.docked_vkeyboard = False elif mode == 'dock': self.use_syskeyboard = False self.allow_vkeyboard = True self.single_vkeyboard = True self.docked_vkeyboard = True elif mode == 'multi': self.use_syskeyboard = False self.allow_vkeyboard = True self.single_vkeyboard = False self.docked_vkeyboard = False elif mode == 'systemanddock': self.use_syskeyboard = True self.allow_vkeyboard = True self.single_vkeyboard = True self.docked_vkeyboard = True elif mode == 'systemandmulti': self.use_syskeyboard = True self.allow_vkeyboard = True self.single_vkeyboard = False self.docked_vkeyboard = False Logger.info( 'Window: virtual keyboard %sallowed, %s, %s' % ( '' if self.allow_vkeyboard else 'not ', 'single mode' if self.single_vkeyboard else 'multiuser mode', 'docked' if self.docked_vkeyboard else 'not docked'))
def _set_shape(self, shape_image, mode='default', cutoff=False, color_key=None): modes = ('default', 'binalpha', 'reversebinalpha', 'colorkey') color_key = color_key or (0, 0, 0, 1) if mode not in modes: Logger.warning( 'Window: shape mode can be only ' '{}'.format(', '.join(modes)) ) return if not isinstance(color_key, (tuple, list)): return if len(color_key) not in (3, 4): return if len(color_key) == 3: color_key = (color_key[0], color_key[1], color_key[2], 1) Logger.warning( 'Window: Shape color_key must be only tuple or list' ) return color_key = ( color_key[0] * 255, color_key[1] * 255, color_key[2] * 255, color_key[3] * 255 ) assert cutoff in (1, 0) shape_image = shape_image or Config.get('kivy', 'window_shape') shape_image = resource_find(shape_image) or shape_image self._win.set_shape(shape_image, mode, cutoff, color_key)
def run(self): q = self._queue.appendleft url = self.url req_body = self.req_body req_headers = self.req_headers or {} if ( Config.has_section('network') and 'useragent' in Config.items('network') ): useragent = Config.get('network', 'useragent') req_headers.setdefault('User-Agent', useragent) try: result, resp = self._fetch_url(url, req_body, req_headers, q) if self.decode: result = self.decode_result(result, resp) except Exception as e: q(('error', None, e)) else: q(('success', resp, result)) # using trigger can result in a missed on_success event self._trigger_result() # clean ourself when the queue is empty while len(self._queue): sleep(.1) self._trigger_result() # ok, authorize the GC to clean us. if self in g_requests: g_requests.remove(self)
def __init__(self, **kwargs): self._win = None if 'min_state_time' not in kwargs: self.min_state_time = float( Config.get('graphics', 'min_state_time')) if 'container' not in kwargs: c = self.container = Builder.load_string(_grid_kv) else: c = None if 'allow_sides' not in kwargs: self.allow_sides = False if 'do_scroll_x' not in kwargs: self.do_scroll_x = False 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 super(DropDown, self).__init__(**kwargs) if c is not None: super(DropDown, self).add_widget(c) self.on_container(self, c) Window.bind( on_key_down=self.on_key_down, size=self._reposition) self.fbind('size', self._reposition)
def build(self): #init config self.desktop = bool(Config.get('kivy', 'desktop')) #init gui self.mainform = RootLayout() #init logger self.mainform.logstream = self.mainform.console_log.initstream() self.mainform.logstreamhandler = logging.StreamHandler(self.mainform.logstream) self.mainform.logstreamhandler.setFormatter(logging.Formatter("%(asctime)s.%(msecs)d [%(name)s#%(levelname)s]: %(message)s","%H:%M:%S")) self.mainform.logstreamhandler.setLevel(logging.INFO) self.mainform.consoleloghandler = logging.StreamHandler(sys.stdout) self.mainform.consoleloghandler.setFormatter(logging.Formatter("%(asctime)s [%(name)s#%(levelname)s]: %(message)s")) self.mainform.consoleloghandler.setLevel(logging.DEBUG) self.mainform.log = logging.getLogger('Pilot') self.mainform.log.setLevel(logging.DEBUG) self.mainform.log.addHandler(self.mainform.logstreamhandler) self.mainform.log.addHandler(self.mainform.consoleloghandler) self.mainform.log.info (u"kPilotGui Running on Python " + sys.version) #init backend pilot.init(self.mainform.log) #delayed init for backend-dependent construction self.mainform.delayed_init() #init sheduler Clock.schedule_interval(self.mainform.logupdate, .1) # Clock.schedule_interval(pilot.udpreader, .05) return self.mainform
def configure_keyboards(self): # Configure how to provide keyboards (virtual or not) # register system keyboard to listening keys from window sk = self._system_keyboard self.bind(on_key_down=sk._on_window_key_down, on_key_up=sk._on_window_key_up) # use the device's real keyboard self.use_syskeyboard = True # use the device's real keyboard self.allow_vkeyboard = False # one single vkeyboard shared between all widgets self.single_vkeyboard = True # the single vkeyboard is always sitting at the same position self.docked_vkeyboard = False # now read the configuration mode = Config.get("kivy", "keyboard_mode") if mode not in ("", "system", "dock", "multi", "systemanddock", "systemandmulti"): Logger.critical("Window: unknown keyboard mode %r" % mode) # adapt mode according to the configuration if mode == "system": self.use_syskeyboard = True self.allow_vkeyboard = False self.single_vkeyboard = True self.docked_vkeyboard = False elif mode == "dock": self.use_syskeyboard = False self.allow_vkeyboard = True self.single_vkeyboard = True self.docked_vkeyboard = True elif mode == "multi": self.use_syskeyboard = False self.allow_vkeyboard = True self.single_vkeyboard = False self.docked_vkeyboard = False elif mode == "systemanddock": self.use_syskeyboard = True self.allow_vkeyboard = True self.single_vkeyboard = True self.docked_vkeyboard = True elif mode == "systemandmulti": self.use_syskeyboard = True self.allow_vkeyboard = True self.single_vkeyboard = False self.docked_vkeyboard = False Logger.info( "Window: virtual keyboard %sallowed, %s, %s" % ( "" if self.allow_vkeyboard else "not ", "single mode" if self.single_vkeyboard else "multiuser mode", "docked" if self.docked_vkeyboard else "not docked", ) )
def create_window(self, *largs): if self._fake_fullscreen: if not self.borderless: self.fullscreen = self._fake_fullscreen = False elif not self.fullscreen or self.fullscreen == 'auto': self.borderless = self._fake_fullscreen = False if self.fullscreen == 'fake': self.borderless = self._fake_fullscreen = True Logger.warning("The 'fake' fullscreen option has been " "deprecated, use Window.borderless or the " "borderless Config option instead.") if not self.initialized: if self.position == 'auto': pos = None, None elif self.position == 'custom': pos = self.left, self.top # setup ! w, h = self._size resizable = Config.getboolean('graphics', 'resizable') gl_size = self._win.setup_window(pos[0], pos[1], w, h, self.borderless, self.fullscreen, resizable) # never stay with a None pos, application using w.center # will be fired. self._pos = (0, 0) else: w, h = self._size self._win.resize_window(w, h) self._win.set_border_state(self.borderless) self._win.set_fullscreen_mode(self.fullscreen) super(WindowSDL, self).create_window() # auto add input provider Logger.info('Window: auto add sdl input provider') from kivy.base import EventLoop SDL2MotionEventProvider.win = self EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', '')) # set window icon before calling set_mode try: filename_icon = self.icon or Config.get('kivy', 'window_icon') if filename_icon == '': logo_size = 32 if platform == 'macosx': logo_size = 512 elif platform == 'win': logo_size = 64 filename_icon = 'kivy-icon-{}.png'.format(logo_size) filename_icon = resource_find( join(kivy_data_dir, 'logo', filename_icon)) self.set_icon(filename_icon) except: Logger.exception('Window: cannot set icon')
def __init__(self, **kwargs): self.register_event_type('on_press') self.register_event_type('on_release') if 'min_state_time' not in kwargs: self.min_state_time = float(Config.get('graphics', 'min_state_time')) super(ButtonBehavior, self).__init__(**kwargs) self.__state_event = None self.__touch_time = None self.fbind('state', self.cancel_event)
def __init__(self, freq, verbose=False): Config.adddefaultsection('debug') Config.setdefault('debug', 'timeit', '0') if int(Config.get('debug', 'timeit')) == 0: self.freq = 0 else: self.freq = freq self.ncalls = 0 self.verbose = verbose
def __init__(self, **kwargs): self.dwell_color = [eval(n) for n in Config.get('dwell', 'dwell_color').split(',')] self.dwell_width = Config.getfloat('dwell', 'dwell_width') self.dwell_time = Config.getfloat('dwell', 'dwell_time') self.dwell_jitter_distance_ignore = Config.getfloat('dwell', 'dwell_jitter_distance_ignore') self.dwell_initial_wait_period = Config.getfloat('dwell', 'dwell_initial_wait_period') # Add-on hack at the last moment, need the touch info from the dwell self.dwell_touch = None self.double_tap_touch = None super(DwellBase, self).__init__(**kwargs)
def __init__(self): ret = super(Game, self).__init__() Config.adddefaultsection('records') Config.setdefault('records', 'top_points', '0') self.sounds = dict() self.sounds['firing'] = SoundLoader.load("sounds/firing.ogg") self.sounds['enemy_death'] = SoundLoader.load("sounds/enemy_death.ogg") self.sounds['game_over'] = SoundLoader.load("sounds/game_over.ogg") self.top_points = int(Config.get('records', 'top_points')) self.points = 0 self.reset_state() return ret
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 create_window(self, *largs): use_fake = self.fullscreen == 'fake' use_fullscreen = False if self.fullscreen in ('auto', True): use_fullscreen = self.fullscreen if not self.initialized: if self.position == 'auto': pos = None, None elif self.position == 'custom': pos = self.left, self.top # setup ! w, h = self._size gl_size = self._win.setup_window(pos[0], pos[1], w, h, use_fake, use_fullscreen) # never stay with a None pos, application using w.center # will be fired. self._pos = (0, 0) else: w, h = self._size self._win.resize_window(w, h) super(WindowSDL, self).create_window() # auto add input provider Logger.info('Window: auto add sdl input provider') from kivy.base import EventLoop SDL2MotionEventProvider.win = self EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', '')) # set window icon before calling set_mode try: filename_icon = self.icon or Config.get('kivy', 'window_icon') if filename_icon == '': logo_size = 32 if platform == 'macosx': logo_size = 512 elif platform == 'win': logo_size = 64 filename_icon = 'kivy-icon-{}.png'.format(logo_size) filename_icon = resource_find( join(kivy_data_dir, 'logo', filename_icon)) self.set_icon(filename_icon) except: Logger.exception('Window: cannot set icon')
def __init__(self, **kwargs): # XXX move to style.kv kwargs.setdefault("size_hint", (None, None)) kwargs.setdefault("scale_min", 0.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, have_special=self._trigger_update_layout_mode, layout_path=self._trigger_load_layouts, layout=self._trigger_load_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 configure_keyboards(self): # Configure how to provide keyboards (virtual or not) # register system keyboard to listening keys from window sk = self._system_keyboard self.bind(on_key_down=sk._on_window_key_down, on_key_up=sk._on_window_key_up) # use the device's real keyboard self.allow_vkeyboard = False # one single vkeyboard shared between all widgets self.single_vkeyboard = True # the single vkeyboard is always sitting at the same position self.docked_vkeyboard = False # now read the configuration mode = Config.get('kivy', 'keyboard_mode') if mode not in ('', 'system', 'dock', 'multi'): Logger.critical('Window: unknown keyboard mode %r' % mode) # adapt mode according to the configuration if mode == 'system': self.allow_vkeyboard = False self.single_vkeyboard = True self.docked_vkeyboard = False elif mode == 'dock': self.allow_vkeyboard = True self.single_vkeyboard = True self.docked_vkeyboard = True elif mode == 'multi': self.allow_vkeyboard = True self.single_vkeyboard = False self.docked_vkeyboard = False Logger.info( 'Window: virtual keyboard %sallowed, %s, %s' % ('' if self.allow_vkeyboard else 'not ', 'single mode' if self.single_vkeyboard else 'multiuser mode', 'docked' if self.docked_vkeyboard else 'not docked'))
def arrancar_servicio(self): # Si el servicio ya estaba arrancado cuando la aplicación arranca, # volver a arrancarlo no tiene efecto, así que la lista de # alarmas del servicio sigue siendo la de la primera vez Logger.debug('%s: arrancar_servicio %s' % (APP, datetime.now())) self.parar_servicio() arg = {'pasadas': self.horario.pasadas, 'alarmas': self.alarmas, 'log_level': Config.get('kivy', 'log_level')} arg = dumps(arg) if platform == 'android': Logger.debug('%s: self.service = android.AndroidService(\ \'Planilla\', \'Alarmas activas\')\')' % APP) self.service = android.AndroidService( 'Planilla', 'Alarmas activas') Logger.debug('%s: self.service.start(arg)' % APP) self.service.start(arg) Logger.debug("%s: Arrancando servicio" % APP)
def on_pre_enter(self, *args): """ Detect the current keyboard mode and set the text of the main label accordingly. """ self.keyboard_mode = Config.get("kivy", "keyboard_mode") self.mode_spinner.text = "'{0}'".format(self.keyboard_mode) p1 = "Current keyboard mode: '{0}'\n\n".format(self.keyboard_mode) if self.keyboard_mode in ['dock', 'system', 'systemanddock']: p2 = "You have the right setting to use this demo.\n\n" else: p2 = "You need the keyboard mode to 'dock', 'system' or '"\ "'systemanddock'(below)\n in order to "\ "use custom onscreen keyboards.\n\n" p3 = "[b][color=#ff0000]Warning:[/color][/b] This is a system-wide " \ "setting and will affect all Kivy apps. If you change the\n" \ " keyboard mode, please use this app" \ " to reset this value to it's original one." self.center_label.text = "".join([p1, p2, p3])
def __init__(self, **kwargs): self.pageNumber = 1 self.picktypes = menu.keys() #self.soustypes = sous_menu.get(kwargs['types']).keys() self.view = Config.get('user', 'view') super(ListDiscover, self).__init__(**kwargs) #grille de poster #self.grid = self.grid_l self.menu = kwargs['menu'] self.types = kwargs['types'] app = App.get_running_app() self.ids.discover_label.text = app._(kwargs['menu']) EXlog((self.menu, self.types)) #poster self.ids.grid_id.clear_widgets() self.add()
def create_window(self, *largs): use_fake = self.fullscreen == 'fake' use_fullscreen = False if self.fullscreen in ('auto', True): use_fullscreen = self.fullscreen if not self.initialized: # never stay with a None pos, application using w.center will be fired. self._pos = (0, 0) # setup ! w, h = self._size gl_size = self._win.setup_window(w, h, use_fake, use_fullscreen) else: w, h = self._size self._win.resize_window(w, h) super(WindowSDL, self).create_window() # auto add input provider Logger.info('Window: auto add sdl input provider') from kivy.base import EventLoop SDL2MotionEventProvider.win = self EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', '')) # set window icon before calling set_mode try: filename_icon = self.icon or Config.get('kivy', 'window_icon') if filename_icon == '': logo_size = 32 if platform == 'macosx': logo_size = 512 elif platform == 'win': logo_size = 64 filename_icon = 'kivy-icon-{}.png'.format(logo_size) filename_icon = resource_find( join(kivy_data_dir, 'logo', filename_icon)) self.set_icon(filename_icon) except: Logger.exception('Window: cannot set icon')
def __init__(self, **kwargs): self._win = None if 'min_state_time' not in kwargs: self.min_state_time = float( Config.get('graphics', 'min_state_time')) if 'container' not in kwargs: c = self.container = Builder.load_string(_grid_kv) else: c = None if 'do_scroll_x' not in kwargs: self.do_scroll_x = False 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 super(DropDown, self).__init__(**kwargs) if c is not None: super(DropDown, self).add_widget(c) self.on_container(self, c) Window.bind(on_key_down=self.on_key_down, size=self._reposition) self.fbind('size', self._reposition)
def _setup_locale(): """ Setting up localization :return: translation method """ try: locale_file = Config.get('xpopup', 'locale_file') except: from os.path import abspath, dirname, join locale_file = join(dirname(abspath(__file__)), 'xpopup.mo') try: with open(locale_file, "rb") as f: xpopup_locale = gettext.GNUTranslations(f) Logger.info('Localization file loaded (%s).' % locale_file) except Exception as e: Logger.warning('%s: %s. Switch to the defaults.' % (e.__class__.__name__, str(e))) xpopup_locale = gettext.NullTranslations() if PY2: return xpopup_locale.ugettext else: return xpopup_locale.gettext
def arrancar_servicio(self): # Si el servicio ya estaba arrancado cuando la aplicación arranca, # volver a arrancarlo no tiene efecto, así que la lista de # alarmas del servicio sigue siendo la de la primera vez Logger.debug('%s: arrancar_servicio %s' % (APP, datetime.now())) self.parar_servicio() arg = { 'pasadas': self.horario.pasadas, 'alarmas': self.alarmas, 'log_level': Config.get('kivy', 'log_level') } arg = dumps(arg) if platform == 'android': Logger.debug('%s: self.service = android.AndroidService(\ \'Planilla\', \'Alarmas activas\')\')' % APP) self.service = android.AndroidService('Planilla', 'Alarmas activas') Logger.debug('%s: self.service.start(arg)' % APP) self.service.start(arg) Logger.debug("%s: Arrancando servicio" % APP)
def _load_sound_cfg(self, cfgName): path = "" try: path = os.path.join(self.directory, Config.get("media_sounds", cfgName)) except ValueError: Logger.error(f"SoundBoard: Missing sound configuration {cfgName}") raise if not os.path.exists(path): Logger.error( f"SoundBoard: Invalid path to sound Path = {path} Configuration = {cfgName}" ) raise ValueError(f"Invalid path {path}") Logger.info( f"SoundBoard: attempting to load sound {cfgName} from path {path}") sound = self.loader.load(path) if not sound: Logger.error( f"SoundBoard: Failed to load sound {path} from {cfgName}") raise ValueError(f"Failed to load sound {path} from {cfgName}") Logger.info(f"SoundBoard: Loaded {cfgName} from path {path}") return sound
def build(self): self.light_control_client = LightController(Config.get( "light_controls", "ip_address"), 81, debug=True) if Config.getboolean("light_controls", "device_enabled"): self.light_control_client.start() self.weather_service = WeatherService() self.weather_service.start() self.sm = CustomScreenManager() self.main_screen = MainScreen(name="main") self.sm.add_widget(self.main_screen) self.settings_screen = SettingsScreen(name="settings") self.sm.add_widget(self.settings_screen) self.idle_screen = IdleScreen(name="idle") self.sm.add_widget(self.idle_screen) return self.sm
class NavigationController(BoxLayout): ''' Custom layout you can use to manage navigation in your app. This is inspired by iOS navigation system, but much easier... You should put a NavigationController as root widget for your app, internally uses a stack to manage navigation ( accessible by using the 'stack' property ). You can pop\push views by using 'pop' and 'push' methods. ''' root_widget = ObjectProperty(None) ''' The current widget is stored here. ''' stack = ListProperty([]) ''' Stack used to navigate between various screens\widgets. ''' background_color = ListProperty([.93, .93, .93, 1]) ''' Solid background color. ''' animation_duracy = NumericProperty(.25) ''' Push & pop animation duracy, default 0.25 seconds. ''' push_mode = OptionProperty('right', options=['left', 'right']) ''' Left or right, will push/pop views from/to the given direction. ''' disable_widget = BooleanProperty(False) ''' If true, root widget will be disabled during animations. This will hide animations! ''' #Navigation bar title = StringProperty('Navigation control!') ''' Navigation bar title. ''' nav_height = NumericProperty(dp(56)) ''' Navigation bar height. ''' # nav_color = ListProperty( [ .54, .765, .86, 1] ) nav_color = ListProperty([.1, .11, .11, 1]) ''' Navigation bar color. ''' shadow_alpha = NumericProperty(.065) ''' Alpha channel for navigation bar shadow. ''' font_name = StringProperty(None) ''' Navigation bar font name. ''' font_size = NumericProperty(dp(22)) ''' Navigation bar font size. ''' text_color = ListProperty([1, 1, 1, 1]) ''' Navigation bar text color. ''' floating_panel = ObjectProperty(None) ''' FloatingLayout you can use for any pourpose. ''' splash_image = StringProperty(alphapng) ''' Image used as splash screen. ''' #Private stuffs... _push_cache = ListProperty([]) _actionprev = ObjectProperty(None) _actiontext = ObjectProperty(None) _content = ObjectProperty(None) _width = NumericProperty(float(Config.get('graphics', 'width'))) def __init__(self, **kargs): super(NavigationController, self).__init__(**kargs) self._keyboard_show = False self._keyboard_just_show = False self._has_root = False self._last_args = {'title': '', 'animation': None} self._animation = None self._bind_keyboard() def pop(self, *args): ''' Use this to go back to the last view. Will eventually throw EmptyNavigationStack. ''' # pdb.set_trace() if self._animation is None: if len(self.stack) > 0: try: self.root_widget.on_pop(self) except: pass self._save_temp_view(0, self.root_widget) self._run_pop_animation() else: raise EmptyNavigationStack() def push(self, view, **kargs): ''' Will append the last view to the list and show the new one. Keyword arguments : title Navigation bar title, default ''. ''' if self._animation is None: if not 'title' in kargs.keys(): kargs['title'] = '' self._last_kargs = kargs x = -1 if self.push_mode == 'left' else 1 self._save_temp_view(x, view) self._run_push_animation() #================================================================================ # Private stuff of various use... #================================================================================ def _bind_keyboard(self): EventLoop.window.bind(on_keyboard=self._on_keyboard_show) EventLoop.window.bind(on_key_down=self._on_keyboard_down) def _on_keyboard_show(self, *args): self._keyboard_show = True def _on_keyboard_down(self, window, key, *args): if key == 27: if self._keyboard_show: self._keyboard_show = False EventLoop.window.release_all_keyboards() else: self.pop() return True return False def _run_push_animation(self): try: self._temp_view.disabled = self.disable_widget duracy = self.animation_duracy if self._has_root else 0 self._animation = Animation(x=0, duration=duracy) self._animation.bind(on_complete=self._push_temp_view) self._animation.start(self._temp_view) except: pass #Exception as e : print(e) def _run_pop_animation(self): try: self._temp_view.disabled = self.disable_widget x = self._temp_view.width * (-1 if self.push_mode == 'left' else 1) self._animation = Animation(x=x, duration=self.animation_duracy) self._animation.bind(on_complete=self._pop_temp_view) self._animation.start(self._temp_view) except: pass #Exception as e : print(e) def _push_temp_view(self, *args): self._temp_view.disabled = False if self._has_root: self.content.remove_widget(self.root_widget) self.stack.append([self.root_widget, self._last_kargs]) self.root_widget = self._temp_view self._clear_temp_view() self.content.add_widget(self.root_widget) self._has_root = True self._update_nav() self._animation = None try: self.root_widget.on_push(self) except: pass def _pop_temp_view(self, *args): self._temp_view.disabled = False self.content.remove_widget(self.root_widget) self.root_widget, self._last_kargs = self.stack.pop() if len(self.stack) > 0: self._last_kargs = self.stack[-1][1] self.content.add_widget(self.root_widget) self._update_nav() self._animation = None def _clear_temp_view(self, *args): try: self.floating_panel.remove_widget(self._temp_view) except: pass self._temp_view = None def _save_temp_view(self, p, view): self._temp_view = view try: self._temp_view.pos = [self._width * p, 0] self.floating_panel.add_widget(self._temp_view) except: pass def _update_nav(self): self.title = self._last_kargs['title'] has_previous = len(self.stack) > 1 self.actionprev.text = ' < ' if has_previous else '' #self.actionprev.icon = icon_back_32 if has_previous else '' self.actionprev.disabled = not has_previous
class WindowPygame(WindowBase): def create_window(self, *largs): # ensure the mouse is still not up after window creation, otherwise, we # have some weird bugs self.dispatch('on_mouse_up', 0, 0, 'all', []) # force display to show (available only for fullscreen) displayidx = Config.getint('graphics', 'display') if not 'SDL_VIDEO_FULLSCREEN_HEAD' in environ and displayidx != -1: environ['SDL_VIDEO_FULLSCREEN_HEAD'] = '%d' % displayidx # init some opengl, same as before. self.flags = pygame.HWSURFACE | pygame.OPENGL | \ pygame.DOUBLEBUF # right now, activate resizable window only on linux. # on window / macosx, the opengl context is lost, and we need to # reconstruct everything. Check #168 for a state of the work. if platform() in ('linux', 'macosx', 'win') and \ Config.getint('graphics', 'resizable'): self.flags |= pygame.RESIZABLE try: pygame.display.init() except pygame.error, e: raise CoreCriticalException(e.message) multisamples = Config.getint('graphics', 'multisamples') if multisamples > 0: pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 1) pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES, multisamples) pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 16) pygame.display.gl_set_attribute(pygame.GL_STENCIL_SIZE, 1) pygame.display.set_caption(self.title) if self.position == 'auto': self._pos = None elif self.position == 'custom': self._pos = self.left, self.top else: raise ValueError('position token in configuration accept only ' '"auto" or "custom"') if self.fullscreen == 'fake': Logger.debug('WinPygame: Set window to fake fullscreen mode') self.flags |= pygame.NOFRAME # if no position set, in fake mode, we always need to set the # position. so replace 0, 0. if self._pos is None: self._pos = (0, 0) environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % self._pos elif self.fullscreen in ('auto', True): Logger.debug('WinPygame: Set window to fullscreen mode') self.flags |= pygame.FULLSCREEN elif self._pos is not None: environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % self._pos # never stay with a None pos, application using w.center will be fired. self._pos = (0, 0) # prepare keyboard repeat_delay = int(Config.get('kivy', 'keyboard_repeat_delay')) repeat_rate = float(Config.get('kivy', 'keyboard_repeat_rate')) pygame.key.set_repeat(repeat_delay, int(1000. / repeat_rate)) # set window icon before calling set_mode try: #filename_icon = Config.get('kivy', 'window_icon') filename_icon = self.icon or Config.get('kivy', 'window_icon') if filename_icon == '': logo_size = 512 if platform() == 'macosx' else 32 filename_icon = join(kivy_home_dir, 'icon', 'kivy-icon-%d.png' % logo_size) self.set_icon(filename_icon) except: Logger.exception('Window: cannot set icon') # try to use mode with multisamples try: self._pygame_set_mode() except pygame.error, e: if multisamples: Logger.warning('WinPygame: Video: failed (multisamples=%d)' % multisamples) Logger.warning('WinPygame: trying without antialiasing') pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 0) pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES, 0) multisamples = 0 try: self._pygame_set_mode() except pygame.error, e: raise CoreCriticalException(e.message)
def __init__(self, board, **kwargs): print("Tableau d'arguments de Board : {}".format(kwargs)) self.board = board super(Board, self).__init__(**kwargs) self.size = (Config.get('graphics', 'width'), Config.get('graphics', 'height'))
mkdir(kivy_home_dir) if not exists(kivy_usermodules_dir): mkdir(kivy_usermodules_dir) if not exists(kivy_userexts_dir): mkdir(kivy_userexts_dir) if not exists(icon_dir): try: shutil.copytree(join(kivy_data_dir, 'logo'), icon_dir) except shutil.Error, e: Logger.exception('Error when copying logo directory') # configuration from kivy.config import Config # Set level of logger level = LOG_LEVELS.get(Config.get('kivy', 'log_level')) Logger.setLevel(level=level) Logger.setLevel(level=LOG_LEVELS.get('debug')) # Can be overrided in command line if 'KIVY_UNITTEST' not in environ: # save sys argv, otherwize, gstreamer use it and display help.. sys_argv = sys.argv sys.argv = sys.argv[:1] try: opts, args = getopt(sys_argv[1:], 'hp:fkawFem:sr:dc:', [ 'help', 'fullscreen', 'windowed', 'fps', 'event', 'module=', 'save', 'fake-fullscreen', 'auto-fullscreen', 'display=', 'size=', 'rotate=', 'config=', 'debug'
def create_window(self, *largs): if self._fake_fullscreen: if not self.borderless: self.fullscreen = self._fake_fullscreen = False elif not self.fullscreen or self.fullscreen == 'auto': self.borderless = self._fake_fullscreen = False if self.fullscreen == 'fake': self.borderless = self._fake_fullscreen = True Logger.warning("The 'fake' fullscreen option has been " "deprecated, use Window.borderless or the " "borderless Config option instead.") if not self.initialized: if self.position == 'auto': pos = None, None elif self.position == 'custom': pos = self.left, self.top # ensure we have an event filter self._win.set_event_filter(self._event_filter) # setup window w, h = self.system_size resizable = Config.getboolean('graphics', 'resizable') state = (Config.get('graphics', 'window_state') if self._is_desktop else None) self.system_size = _size = self._win.setup_window( pos[0], pos[1], w, h, self.borderless, self.fullscreen, resizable, state, self.get_gl_backend_name()) # calculate density sz = self._win._get_gl_size()[0] self._density = density = sz / _size[0] if self._is_desktop and self.size[0] != _size[0]: self.dpi = density * 96. # never stay with a None pos, application using w.center # will be fired. self._pos = (0, 0) self._set_minimum_size() self._set_allow_screensaver() if state == 'hidden': self._focus = False else: w, h = self.system_size self._win.resize_window(w, h) self._win.set_border_state(self.borderless) self._win.set_fullscreen_mode(self.fullscreen) super(WindowSDL, self).create_window() # set mouse visibility self._set_cursor_state(self.show_cursor) if self.initialized: return # auto add input provider Logger.info('Window: auto add sdl2 input provider') from kivy.base import EventLoop SDL2MotionEventProvider.win = self EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', '')) # set window icon before calling set_mode try: filename_icon = self.icon or Config.get('kivy', 'window_icon') if filename_icon == '': logo_size = 32 if platform == 'macosx': logo_size = 512 elif platform == 'win': logo_size = 64 filename_icon = 'kivy-icon-{}.png'.format(logo_size) filename_icon = resource_find( join(kivy_data_dir, 'logo', filename_icon)) self.set_icon(filename_icon) except: Logger.exception('Window: cannot set icon')
def __init__(self, **kwargs): kwargs.setdefault('force', False) # don't init window 2 times, # except if force is specified if WindowBase.__instance is not None and not kwargs.get('force'): return self.initialized = False self._is_desktop = Config.getboolean('kivy', 'desktop') # create a trigger for update/create the window when one of window # property changes self.trigger_create_window = Clock.create_trigger( self.create_window, -1) # Create a trigger for updating the keyboard height self.trigger_keyboard_height = Clock.create_trigger( self._upd_kbd_height, .5) # set the default window parameter according to the configuration if 'borderless' not in kwargs: kwargs['borderless'] = Config.getboolean('graphics', 'borderless') if 'fullscreen' not in kwargs: fullscreen = Config.get('graphics', 'fullscreen') if fullscreen not in ('auto', 'fake'): fullscreen = fullscreen.lower() in ('true', '1', 'yes', 'yup') kwargs['fullscreen'] = fullscreen if 'width' not in kwargs: kwargs['width'] = Config.getint('graphics', 'width') if 'height' not in kwargs: kwargs['height'] = Config.getint('graphics', 'height') if 'rotation' not in kwargs: kwargs['rotation'] = Config.getint('graphics', 'rotation') if 'position' not in kwargs: kwargs['position'] = Config.getdefault('graphics', 'position', 'auto') if 'top' in kwargs: kwargs['position'] = 'custom' kwargs['top'] = kwargs['top'] else: kwargs['top'] = Config.getint('graphics', 'top') if 'left' in kwargs: kwargs['position'] = 'custom' kwargs['left'] = kwargs['left'] else: kwargs['left'] = Config.getint('graphics', 'left') kwargs['_size'] = (kwargs.pop('width'), kwargs.pop('height')) super(WindowBase, self).__init__(**kwargs) # bind all the properties that need to recreate the window self._bind_create_window() self.bind(size=self.trigger_keyboard_height, rotation=self.trigger_keyboard_height) self.bind(softinput_mode=lambda *dt: self.update_viewport(), keyboard_height=lambda *dt: self.update_viewport()) # init privates self._system_keyboard = Keyboard(window=self) self._keyboards = {'system': self._system_keyboard} self._vkeyboard_cls = None self.children = [] self.parent = self # before creating the window import kivy.core.gl # NOQA # configure the window self.create_window() # attach modules + listener event EventLoop.set_window(self) Modules.register_window(self) EventLoop.add_event_listener(self) # manage keyboard(s) self.configure_keyboards() # assign the default context of the widget creation if not hasattr(self, '_context'): self._context = get_current_context() # mark as initialized self.initialized = True
def __init__(self): self.ignore_list = strtotuple(Config.get('postproc', 'ignore'))
def __init__(self): self.jitterdist = Config.getfloat('postproc', 'jitter_distance') ignore_devices = Config.get('postproc', 'jitter_ignore_devices') self.ignore_devices = ignore_devices.split(',') self.last_touches = {}
# Set the window size on a new computer and make launch the readme if at the first launch. from win32api import GetSystemMetrics from os import environ, startfile, getcwd environ['KIVY_HOME'] = '../save' from kivy.config import Config first_open = Config.get('kivy', 'first_open') from logging import info if first_open == 'True': info('Detected first opening. Launching readme.md') path = getcwd() startfile(path + '/../README.md') Config.set('graphics', 'width', int(GetSystemMetrics(0) * 2 / 3)) Config.set('graphics', 'height', int(GetSystemMetrics(1) * 2 / 3)) Config.set('kivy', 'first_open', False) Config.write() # Regular imports from io import BytesIO from kivy.app import App from kivy.clock import Clock from kivy.animation import Animation from kivy.properties import NumericProperty, BooleanProperty from kivy.uix.popup import Popup from kivy.uix.relativelayout import RelativeLayout from src.database import get_table, use, get_columns from kivy.core.image import Image as CoreImage from wordcloud import WordCloud # To hook into styling; Look in .kv class PermissionPopup(Popup):
def __init__(self, **kwargs): super().__init__(**kwargs) Config.get('kivy', 'keyboard_mode'), Config.get('kivy', 'keyboard_layout')
if __name__ == '__main__': root = FloatLayout() # create a button to release everything def release_all_keyboard(*l): Window.release_all_keyboards() btn = Button(text='Release\nall\nkeyboards', size_hint=(None, None), halign='center') btn.bind(on_release=release_all_keyboard) root.add_widget(btn) # show current configuration lbl = 'Configuration keyboard_mode is %r, keyboard_layout is %r' % ( Config.get('kivy', 'keyboard_mode'), Config.get('kivy', 'keyboard_layout')) label = Label(text=lbl, size_hint_y=None, height=50, pos_hint={'top': 1}) root.add_widget(label) s = Scatter(size_hint=(None, None), pos=(300, 300)) s.add_widget(TextInput(size_hint=(None, None), size=(100, 50))) root.add_widget(s) s = Scatter(size_hint=(None, None), pos=(400, 300), rotation=45) s.add_widget(TextInput(size_hint=(None, None), size=(100, 50))) root.add_widget(s) runTouchApp(root)
def __init__(self, **kwargs): kwargs.setdefault('force', False) # don't init window 2 times, # except if force is specified if WindowBase.__instance is not None and not kwargs.get('force'): return self.initialized = False # create a trigger for update/create the window when one of window # property changes self.trigger_create_window = Clock.create_trigger( self.create_window, -1) # set the default window parameter according to the configuration if 'fullscreen' not in kwargs: fullscreen = Config.get('graphics', 'fullscreen') if fullscreen not in ('auto', 'fake'): fullscreen = fullscreen.lower() in ('true', '1', 'yes', 'yup') kwargs['fullscreen'] = fullscreen if 'width' not in kwargs: kwargs['width'] = Config.getint('graphics', 'width') if 'height' not in kwargs: kwargs['height'] = Config.getint('graphics', 'height') if 'rotation' not in kwargs: kwargs['rotation'] = Config.getint('graphics', 'rotation') if 'position' not in kwargs: kwargs['position'] = Config.getdefault('graphics', 'position', 'auto') if 'top' in kwargs: kwargs['position'] = 'custom' kwargs['top'] = kwargs['top'] else: kwargs['top'] = Config.getint('graphics', 'top') if 'left' in kwargs: kwargs['position'] = 'custom' kwargs['left'] = kwargs['left'] else: kwargs['left'] = Config.getint('graphics', 'left') kwargs['_size'] = (kwargs.pop('width'), kwargs.pop('height')) super(WindowBase, self).__init__(**kwargs) # bind all the properties that need to recreate the window for prop in ( 'fullscreen', 'position', 'top', 'left', '_size', 'system_size'): self.bind(**{prop: self.trigger_create_window}) # init privates self._system_keyboard = Keyboard(window=self) self._keyboards = {'system': self._system_keyboard} self._vkeyboard_cls = None self.children = [] self.parent = self # before creating the window import kivy.core.gl # configure the window self.create_window() # attach modules + listener event EventLoop.set_window(self) Modules.register_window(self) EventLoop.add_event_listener(self) # manage keyboard(s) self.configure_keyboards() # mark as initialized self.initialized = True
info = win32api.GetMonitorInfo(monitor[0]) (x, t, r, y) = info['Work'] monitor_positions.insert(0, (x, t, r, y)) else: raise Exception("Running on unsupported Platform!") (x, y, r, t) = monitor_positions[0] sw, sh = r - x, t - y Config.set('graphics', 'position', 'custom') Config.set('graphics', 'left', int(x + sw / 2 - sw * 0.09)) Config.set('graphics', 'top', int(y + sh / 2 - sh * 0.14)) Config.set('graphics', 'borderless', 0) from configparser import NoOptionError try: if width != int(Config.get('graphics', 'screen_width')) or height != int( Config.get('graphics', 'screen_height')): Config.set('graphics', 'screen_width', width) Config.set('graphics', 'screen_height', height) except NoOptionError: Config.set('graphics', 'screen_width', width) Config.set('graphics', 'screen_height', height) Config.set('graphics', 'width', int(width * 0.18)) Config.set('graphics', 'minimum_width', int(width * 0.18)) Config.set('graphics', 'height', int(height * 0.28)) Config.set('graphics', 'minimum_height', int(height * 0.28)) Config.set('graphics', 'fullscreen', 0) Config.set('graphics', 'borderless', 0) play_game = False
def _load_urllib(self, filename, kwargs): '''(internal) Loading a network file. First download it, save it to a temporary file, and pass it to _load_local().''' if PY2: import urllib2 as urllib_request def gettype(info): return info.gettype() else: import urllib.request as urllib_request def gettype(info): return info.get_content_type() proto = filename.split(':', 1)[0] if proto == 'smb': try: # note: it's important to load SMBHandler every time # otherwise the data is occasionally not loaded from smb.SMBHandler import SMBHandler except ImportError: Logger.warning( 'Loader: can not load PySMB: make sure it is installed') return import tempfile data = fd = _out_osfd = None try: _out_filename = '' if proto == 'smb': # read from samba shares fd = urllib_request.build_opener(SMBHandler).open(filename) else: # read from internet request = urllib_request.Request(filename) if ( Config.has_section('network') and 'useragent' in Config.items('network') ): useragent = Config.get('network', 'useragent') if useragent: request.add_header('User-Agent', useragent) opener = urllib_request.build_opener() fd = opener.open(request) if '#.' in filename: # allow extension override from URL fragment suffix = '.' + filename.split('#.')[-1] else: ctype = gettype(fd.info()) suffix = mimetypes.guess_extension(ctype) if not suffix: # strip query string and split on path parts = filename.split('?')[0].split('/')[1:] while len(parts) > 1 and not parts[0]: # strip out blanks from '//' parts = parts[1:] if len(parts) > 1 and '.' in parts[-1]: # we don't want '.com', '.net', etc. as the extension suffix = '.' + parts[-1].split('.')[-1] _out_osfd, _out_filename = tempfile.mkstemp( prefix='kivyloader', suffix=suffix) idata = fd.read() fd.close() fd = None # write to local filename write(_out_osfd, idata) close(_out_osfd) _out_osfd = None # load data data = self._load_local(_out_filename, kwargs) # FIXME create a clean API for that for imdata in data._data: imdata.source = filename except Exception as ex: Logger.exception('Loader: Failed to load image <%s>' % filename) # close file when remote file not found or download error try: if _out_osfd: close(_out_osfd) except OSError: pass # update client for c_filename, client in self._client[:]: if filename != c_filename: continue # got one client to update client.image = self.error_image client.dispatch('on_error', error=ex) self._client.remove((c_filename, client)) return self.error_image finally: if fd: fd.close() if _out_osfd: close(_out_osfd) if _out_filename != '': unlink(_out_filename) return data
mkdir(kivy_home_dir) if not exists(kivy_usermodules_dir): mkdir(kivy_usermodules_dir) if not exists(kivy_userexts_dir): mkdir(kivy_userexts_dir) if not exists(icon_dir): try: shutil.copytree(join(kivy_data_dir, 'logo'), icon_dir) except: Logger.exception('Error when copying logo directory') # configuration from kivy.config import Config # Set level of logger level = LOG_LEVELS.get(Config.get('kivy', 'log_level')) Logger.setLevel(level=level) Logger.setLevel(level=LOG_LEVELS.get('debug')) # Can be overrided in command line if 'KIVY_UNITTEST' not in environ and 'KIVY_PACKAGING' not in environ: # save sys argv, otherwize, gstreamer use it and display help.. sys_argv = sys.argv sys.argv = sys.argv[:1] try: opts, args = getopt(sys_argv[1:], 'hp:fkawFem:sr:dc:', [ 'help', 'fullscreen', 'windowed', 'fps', 'event', 'module=', 'save', 'fake-fullscreen', 'auto-fullscreen', 'display=', 'size=', 'rotate=', 'config=', 'debug', 'dpi='])
future version. ''' __all__ = ('FocusBehavior', ) from kivy.properties import OptionProperty, ObjectProperty, BooleanProperty, \ AliasProperty from kivy.config import Config from kivy.base import EventLoop # When we are generating documentation, Config doesn't exist _is_desktop = False _keyboard_mode = 'system' if Config: _is_desktop = Config.getboolean('kivy', 'desktop') _keyboard_mode = Config.get('kivy', 'keyboard_mode') class FocusBehavior(object): '''Provides keyboard focus behavior. When combined with other FocusBehavior widgets it allows one to cycle focus among them by pressing tab. Please see the :mod:`focus behavior module documentation <kivy.uix.behaviors.focus>` for more information. .. versionadded:: 1.9.0 ''' _requested_keyboard = False _keyboard = ObjectProperty(None, allownone=True)
SYSTEM_IDS = [ 'accio', 'aguamenti', 'expecto patronum', 'diffindo', 'episkey', 'expelliarmus', 'impedimenta', 'protego', 'revelio', 'tergeo', 'lumos', 'veritaserum', 'muffliato', 'alohomora', 'test' ] GOOGLE_SPREADSHEET_ID = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' # set app icon from kivy.config import Config from os.path import dirname, join CURDIR = dirname(__file__) icon_path = join(CURDIR, 'icons', 'simpleicon.png') Config.set('kivy', 'window_icon', icon_path) LOG_DIR = Config.get('kivy', 'log_dir') LOG_NAME = Config.get('kivy', 'log_name') CONFIG_FILE = join(CURDIR, 'kivycam.ini')
from ast import literal_eval from functools import partial from copy import copy from kivy import kivy_data_dir from kivy.config import Config from kivy.utils import platform from kivy.graphics.texture import Texture from kivy.core import core_select_lib from kivy.core.text.text_layout import layout_text, LayoutWord from kivy.resources import resource_find, resource_add_path from kivy.compat import PY2 from kivy.setupconfig import USE_SDL2, USE_PANGOFT2 if 'KIVY_DOC' not in os.environ: _default_font_paths = literal_eval(Config.get('kivy', 'default_font')) DEFAULT_FONT = _default_font_paths.pop(0) else: DEFAULT_FONT = None FONT_REGULAR = 0 FONT_ITALIC = 1 FONT_BOLD = 2 FONT_BOLDITALIC = 3 whitespace_pat = re.compile('( +)') class LabelBase(object): '''Core text label. This is the abstract class used by different backends to render text.
def _load_urllib(self, filename, kwargs): '''(internal) Loading a network file. First download it, save it to a temporary file, and pass it to _load_local().''' if PY2: import urllib2 as urllib_request def gettype(info): return info.gettype() else: import urllib.request as urllib_request def gettype(info): return info.get_content_type() proto = filename.split(':', 1)[0] if proto == 'smb': try: # note: it's important to load SMBHandler every time # otherwise the data is occasionally not loaded from smb.SMBHandler import SMBHandler except ImportError: Logger.warning( 'Loader: can not load PySMB: make sure it is installed') return import tempfile data = fd = _out_osfd = None try: _out_filename = '' if proto == 'smb': # read from samba shares fd = urllib_request.build_opener(SMBHandler).open(filename) else: # read from internet request = urllib_request.Request(filename) if (Config.has_section('network') and 'useragent' in Config.items('network')): useragent = Config.get('network', 'useragent') if useragent: request.add_header('User-Agent', useragent) opener = urllib_request.build_opener() fd = opener.open(request) if '#.' in filename: # allow extension override from URL fragment suffix = '.' + filename.split('#.')[-1] else: ctype = gettype(fd.info()) suffix = mimetypes.guess_extension(ctype) suffix = LoaderBase.EXT_ALIAS.get(suffix, suffix) if not suffix: # strip query string and split on path parts = filename.split('?')[0].split('/')[1:] while len(parts) > 1 and not parts[0]: # strip out blanks from '//' parts = parts[1:] if len(parts) > 1 and '.' in parts[-1]: # we don't want '.com', '.net', etc. as the extension suffix = '.' + parts[-1].split('.')[-1] _out_osfd, _out_filename = tempfile.mkstemp(prefix='kivyloader', suffix=suffix) idata = fd.read() fd.close() fd = None # write to local filename write(_out_osfd, idata) close(_out_osfd) _out_osfd = None # load data data = self._load_local(_out_filename, kwargs) # FIXME create a clean API for that for imdata in data._data: imdata.source = filename except Exception as ex: Logger.exception('Loader: Failed to load image <%s>' % filename) # close file when remote file not found or download error try: if _out_osfd: close(_out_osfd) except OSError: pass # update client for c_filename, client in self._client[:]: if filename != c_filename: continue # got one client to update client.image = self.error_image client.dispatch('on_error', error=ex) self._client.remove((c_filename, client)) return self.error_image finally: if fd: fd.close() if _out_osfd: close(_out_osfd) if _out_filename != '': unlink(_out_filename) return data
from kivy.uix.boxlayout import BoxLayout from kivy.uix.dropdown import DropDown from kivy.uix.widget import Widget from kivy.uix.button import Button from kivy.uix.togglebutton import ToggleButton from kivy.uix.checkbox import CheckBox from kivy.config import Config from kivy.properties import ObjectProperty, NumericProperty, \ BooleanProperty, StringProperty, ListProperty, OptionProperty from kivy.uix.spinner import Spinner from kivy.lang import Builder from functools import partial window_icon = '' if Config: window_icon = Config.get('kivy', 'window_icon') class ActionBarException(Exception): '''ActionBarException class ''' pass class ActionItem(object): '''ActionItem class, an abstract class for all ActionBar widgets. To create a custom widget for an ActionBar, inherit from this class. See module documentation for more information. ''' minimum_width = NumericProperty('90sp')
def create_window(self, *largs): # ensure the mouse is still not up after window creation, otherwise, we # have some weird bugs self.dispatch('on_mouse_up', 0, 0, 'all', []) # force display to show (available only for fullscreen) displayidx = Config.getint('graphics', 'display') if 'SDL_VIDEO_FULLSCREEN_HEAD' not in environ and displayidx != -1: environ['SDL_VIDEO_FULLSCREEN_HEAD'] = '%d' % displayidx # init some opengl, same as before. self.flags = pygame.HWSURFACE | pygame.OPENGL | pygame.DOUBLEBUF # right now, activate resizable window only on linux. # on window / macosx, the opengl context is lost, and we need to # reconstruct everything. Check #168 for a state of the work. if platform in ('linux', 'macosx', 'win') and \ Config.getboolean('graphics', 'resizable'): self.flags |= pygame.RESIZABLE try: pygame.display.init() except pygame.error as e: raise CoreCriticalException(e.message) multisamples = Config.getint('graphics', 'multisamples') if multisamples > 0: pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 1) pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES, multisamples) pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 16) pygame.display.gl_set_attribute(pygame.GL_STENCIL_SIZE, 1) pygame.display.set_caption(self.title) if self.position == 'auto': self._pos = None elif self.position == 'custom': self._pos = self.left, self.top else: raise ValueError('position token in configuration accept only ' '"auto" or "custom"') if self._fake_fullscreen: if not self.borderless: self.fullscreen = self._fake_fullscreen = False elif not self.fullscreen or self.fullscreen == 'auto': self.borderless = self._fake_fullscreen = False if self.fullscreen == 'fake': self.borderless = self._fake_fullscreen = True Logger.warning("The 'fake' fullscreen option has been " "deprecated, use Window.borderless or the " "borderless Config option instead.") if self.fullscreen == 'fake' or self.borderless: Logger.debug('WinPygame: Set window to borderless mode.') self.flags |= pygame.NOFRAME # If no position set in borderless mode, we always need # to set the position. So use 0, 0. if self._pos is None: self._pos = (0, 0) environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % self._pos elif self.fullscreen in ('auto', True): Logger.debug('WinPygame: Set window to fullscreen mode') self.flags |= pygame.FULLSCREEN elif self._pos is not None: environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % self._pos # never stay with a None pos, application using w.center will be fired. self._pos = (0, 0) # prepare keyboard repeat_delay = int(Config.get('kivy', 'keyboard_repeat_delay')) repeat_rate = float(Config.get('kivy', 'keyboard_repeat_rate')) pygame.key.set_repeat(repeat_delay, int(1000. / repeat_rate)) # set window icon before calling set_mode try: filename_icon = self.icon or Config.get('kivy', 'window_icon') if filename_icon == '': logo_size = 32 if platform == 'macosx': logo_size = 512 elif platform == 'win': logo_size = 64 filename_icon = 'kivy-icon-{}.png'.format(logo_size) filename_icon = resource_find( join(kivy_data_dir, 'logo', filename_icon)) self.set_icon(filename_icon) except: Logger.exception('Window: cannot set icon') # try to use mode with multisamples try: self._pygame_set_mode() except pygame.error as e: if multisamples: Logger.warning('WinPygame: Video: failed (multisamples=%d)' % multisamples) Logger.warning('WinPygame: trying without antialiasing') pygame.display.gl_set_attribute( pygame.GL_MULTISAMPLEBUFFERS, 0) pygame.display.gl_set_attribute( pygame.GL_MULTISAMPLESAMPLES, 0) multisamples = 0 try: self._pygame_set_mode() except pygame.error as e: raise CoreCriticalException(e.message) else: raise CoreCriticalException(e.message) if pygame.RESIZABLE & self.flags: self._pygame_set_mode() info = pygame.display.Info() self._size = (info.current_w, info.current_h) # self.dispatch('on_resize', *self._size) # in order to debug futur issue with pygame/display, let's show # more debug output. Logger.debug('Window: Display driver ' + pygame.display.get_driver()) Logger.debug('Window: Actual window size: %dx%d', info.current_w, info.current_h) if platform != 'android': # unsupported platform, such as android that doesn't support # gl_get_attribute. Logger.debug( 'Window: Actual color bits r%d g%d b%d a%d', pygame.display.gl_get_attribute(pygame.GL_RED_SIZE), pygame.display.gl_get_attribute(pygame.GL_GREEN_SIZE), pygame.display.gl_get_attribute(pygame.GL_BLUE_SIZE), pygame.display.gl_get_attribute(pygame.GL_ALPHA_SIZE)) Logger.debug( 'Window: Actual depth bits: %d', pygame.display.gl_get_attribute(pygame.GL_DEPTH_SIZE)) Logger.debug( 'Window: Actual stencil bits: %d', pygame.display.gl_get_attribute(pygame.GL_STENCIL_SIZE)) Logger.debug( 'Window: Actual multisampling samples: %d', pygame.display.gl_get_attribute(pygame.GL_MULTISAMPLESAMPLES)) super(WindowPygame, self).create_window() # set mouse visibility self._set_cursor_state(self.show_cursor) # if we are on android platform, automatically create hooks if android: from kivy.support import install_android install_android()
def create_window(self, *largs): # ensure the mouse is still not up after window creation, otherwise, we # have some weird bugs self.dispatch('on_mouse_up', 0, 0, 'all', []) # force display to show (available only for fullscreen) displayidx = Config.getint('graphics', 'display') if not 'SDL_VIDEO_FULLSCREEN_HEAD' in environ and displayidx != -1: environ['SDL_VIDEO_FULLSCREEN_HEAD'] = '%d' % displayidx # init some opengl, same as before. self.flags = pygame.HWSURFACE | pygame.OPENGL | pygame.DOUBLEBUF # right now, activate resizable window only on linux. # on window / macosx, the opengl context is lost, and we need to # reconstruct everything. Check #168 for a state of the work. if platform in ('linux', 'macosx', 'win') and \ Config.getint('graphics', 'resizable'): self.flags |= pygame.RESIZABLE try: pygame.display.init() except pygame.error as e: raise CoreCriticalException(e.message) multisamples = Config.getint('graphics', 'multisamples') if multisamples > 0: pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 1) pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES, multisamples) pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 16) pygame.display.gl_set_attribute(pygame.GL_STENCIL_SIZE, 1) pygame.display.set_caption(self.title) if self.position == 'auto': self._pos = None elif self.position == 'custom': self._pos = self.left, self.top else: raise ValueError('position token in configuration accept only ' '"auto" or "custom"') if self.fullscreen == 'fake': Logger.debug('WinPygame: Set window to fake fullscreen mode') self.flags |= pygame.NOFRAME # if no position set, in fake mode, we always need to set the # position. so replace 0, 0. if self._pos is None: self._pos = (0, 0) environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % self._pos elif self.fullscreen in ('auto', True): Logger.debug('WinPygame: Set window to fullscreen mode') self.flags |= pygame.FULLSCREEN elif self._pos is not None: environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % self._pos # never stay with a None pos, application using w.center will be fired. self._pos = (0, 0) # prepare keyboard repeat_delay = int(Config.get('kivy', 'keyboard_repeat_delay')) repeat_rate = float(Config.get('kivy', 'keyboard_repeat_rate')) pygame.key.set_repeat(repeat_delay, int(1000. / repeat_rate)) # set window icon before calling set_mode try: filename_icon = self.icon or Config.get('kivy', 'window_icon') if filename_icon == '': logo_size = 32 if platform == 'macosx': logo_size = 512 elif platform == 'win': logo_size = 64 filename_icon = 'kivy-icon-{}.png'.format(logo_size) filename_icon = resource_find( join(kivy_data_dir, 'logo', filename_icon)) self.set_icon(filename_icon) except: Logger.exception('Window: cannot set icon') # try to use mode with multisamples try: self._pygame_set_mode() except pygame.error as e: if multisamples: Logger.warning('WinPygame: Video: failed (multisamples=%d)' % multisamples) Logger.warning('WinPygame: trying without antialiasing') pygame.display.gl_set_attribute( pygame.GL_MULTISAMPLEBUFFERS, 0) pygame.display.gl_set_attribute( pygame.GL_MULTISAMPLESAMPLES, 0) multisamples = 0 try: self._pygame_set_mode() except pygame.error as e: raise CoreCriticalException(e.message) else: raise CoreCriticalException(e.message) info = pygame.display.Info() self._size = (info.current_w, info.current_h) #self.dispatch('on_resize', *self._size) # in order to debug futur issue with pygame/display, let's show # more debug output. Logger.debug('Window: Display driver ' + pygame.display.get_driver()) Logger.debug('Window: Actual window size: %dx%d', info.current_w, info.current_h) if platform != 'android': # unsupported platform, such as android that doesn't support # gl_get_attribute. Logger.debug( 'Window: Actual color bits r%d g%d b%d a%d', pygame.display.gl_get_attribute(pygame.GL_RED_SIZE), pygame.display.gl_get_attribute(pygame.GL_GREEN_SIZE), pygame.display.gl_get_attribute(pygame.GL_BLUE_SIZE), pygame.display.gl_get_attribute(pygame.GL_ALPHA_SIZE)) Logger.debug( 'Window: Actual depth bits: %d', pygame.display.gl_get_attribute(pygame.GL_DEPTH_SIZE)) Logger.debug( 'Window: Actual stencil bits: %d', pygame.display.gl_get_attribute(pygame.GL_STENCIL_SIZE)) Logger.debug( 'Window: Actual multisampling samples: %d', pygame.display.gl_get_attribute(pygame.GL_MULTISAMPLESAMPLES)) super(WindowPygame, self).create_window() # set mouse visibility pygame.mouse.set_visible( Config.getboolean('graphics', 'show_cursor')) # if we are on android platform, automaticly create hooks if android: from kivy.support import install_android install_android()
from kivy.uix.popup import Popup from kivy.uix.screenmanager import ScreenManager from kivy.uix.textinput import TextInput from subprocess import Popen, PIPE from waeup.identifier.config import ( get_json_settings, get_default_settings, get_conffile_location, ) from waeup.identifier.webservice import ( store_fingerprint, get_url, get_fingerprints, ) # Enable virtualkeyboard if Config is not None: # when building sphinx docs, `Config` is None. How come? if not Config.get('kivy', 'keyboard_mode'): Config.set('kivy', 'keyboard_mode', 'systemandmulti') #: The set of chars allowed in filenames we handle. #: Last char must not be slash. VALID_FILENAME = re.compile('^[a-zA-Z0-9/\._\-]+$') #: A valid student id looks like this #: Two or three uppercase ASCIIs followed by at least five digits RE_STUDENT_ID = re.compile('^[A-Z]{1,3}[0-9]{5,}$') #: How often do we look for new data while executing commands? POLL_INTERVAL = 0.1
from kivy.config import Config Config.set('graphics', 'shaped', 1) from kivy.resources import resource_find default_shape = Config.get('kivy', 'window_shape') alpha_shape = resource_find('data/logo/kivy-icon-512.png') from kivy.app import App from kivy.lang import Builder from kivy.core.window import Window from kivy.uix.boxlayout import BoxLayout from kivy.properties import ( BooleanProperty, StringProperty, ListProperty, ) Builder.load_string(''' #:import win kivy.core.window.Window <Root>: orientation: 'vertical' BoxLayout: Button: text: 'default_shape' on_release: app.shape_image = app.default_shape Button: text: 'alpha_shape' on_release: app.shape_image = app.alpha_shape BoxLayout:
''' @wraps(func) def delayed_func(*args, **kwargs): def callback_func(dt): func(*args, **kwargs) Clock.schedule_once(callback_func, 0) return delayed_func if 'KIVY_DOC_INCLUDE' in environ: #: Instance of :class:`ClockBaseBehavior`. Clock = None else: _classes = { 'default': ClockBase, 'interrupt': ClockBaseInterrupt, 'free_all': ClockBaseFreeInterruptAll, 'free_only': ClockBaseFreeInterruptOnly } _clk = environ.get('KIVY_CLOCK', Config.get('kivy', 'kivy_clock')) if _clk not in _classes: raise Exception( '{} is not a valid kivy clock. Valid clocks are {}'.format( _clk, sorted(_classes.keys()))) Clock = register_context('Clock', _classes[_clk]) '''The kivy Clock instance. See module documentation for details. '''