Esempio n. 1
1
    def test_widget_root_from_code_with_kv(self):
        from kivy.lang import Builder
        from kivy.factory import Factory
        from kivy.properties import ObjectProperty, StringProperty
        from kivy.uix.floatlayout import FloatLayout
        
        Builder.load_string("""
<MyWidget>:
    Label:
        text: root.title
        
<BaseWidget>:
    CallerWidget:
""")
        
        class CallerWidget(FloatLayout):
            def __init__(self, **kwargs):
                super(CallerWidget, self).__init__(**kwargs)
                self.add_widget(MyWidget(title="Hello World"))
            
        class NestedWidget(FloatLayout):
            title = StringProperty('aa')
            
        class MyWidget(NestedWidget):
            pass
        
        class BaseWidget(FloatLayout):
            pass
        
        Factory.register('MyWidget', cls=MyWidget)
        Factory.register('CallerWidget', cls=CallerWidget)

        r = self.render
        root = BaseWidget()
        r(root)
Esempio n. 2
1
    def build_item(self, item, params, is_rule=False):
        self._push_ids()
        is_template = False

        if is_rule is False:
            if __debug__:
                trace('Builder: build item %s' % item)
            if item.startswith('<'):
                raise ParserError(params['__ctx__'], params['__line__'],
                               'Rules are not accepted inside widgets')
            no_apply = False
            if item[0] == '+':
                item = item[1:]
                no_apply = True

            # we are checking is the widget is a template or not
            # if yes, no child is allowed, and all the properties are used to
            # construct the context for the template.
            cls = Factory.get(item)
            if Factory.is_template(item):
                is_template = True
                self._push_widgets()
            else:
                try:
                    widget = cls(__no_builder=True)
                except Exception, e:
                    raise ParserError(params['__ctx__'], params['__line__'],
                                      str(e))
                if not no_apply:
                    self.listwidget.append(widget)
Esempio n. 3
0
 def build(*args):
     from fields import fieldDict, ShapeField, LinkedField
     from kivy.factory import Factory
     FE = Factory.get('FieldEntry')
     TFE = Factory.get("TmplFieldEntry")
     PFE = Factory.get('LinkedFieldEntry')
     for key in sorted(fieldDict):
         if "skip_designer" in fieldDict[key].__dict__ and fieldDict[key].skip_designer:#test of __dict__ ensure existencfe at the calss level,, not in its basis
             continue
         fe = FE()
         fe.text= key
         fe.target = self
         if issubclass(fieldDict[key], ShapeField):
             if fieldDict[key] == ShapeField:
                 continue
             self.ids.shapes_stack.add_widget(fe)
         elif issubclass(fieldDict[key], LinkedField):
             if fieldDict[key] == LinkedField:
                 continue
             pfe = PFE()
             pfe.target = self
             pfe.text = key
             self.ids.effects_stack.add_widget(pfe)
         else:
             self.ids.fields_stack.add_widget(fe)
     #Now add Template field
     tfe = TFE()
     tfe.target = self
     self.ids.fields_stack.add_widget(tfe)
Esempio n. 4
0
    def init_ui(self):
        ''' Initialize The Ux part of electrum. This function performs the basic
        tasks of setting up the ui.
        '''
        #from weakref import ref

        self.funds_error = False
        # setup UX
        self.screens = {}

        #setup lazy imports for mainscreen
        Factory.register('AnimatedPopup',
                         module='electrum_gui.kivy.uix.dialogs')
        Factory.register('QRCodeWidget',
                         module='electrum_gui.kivy.uix.qrcodewidget')

        # preload widgets. Remove this if you want to load the widgets on demand
        #Cache.append('electrum_widgets', 'AnimatedPopup', Factory.AnimatedPopup())
        #Cache.append('electrum_widgets', 'QRCodeWidget', Factory.QRCodeWidget())

        # load and focus the ui
        self.root.manager = self.root.ids['manager']

        self.history_screen = None
        self.contacts_screen = None
        self.send_screen = None
        self.invoices_screen = None
        self.receive_screen = None
        self.requests_screen = None
        self.address_screen = None
        self.icon = "icons/electrum.png"
        self.tabs = self.root.ids['tabs']
Esempio n. 5
0
    def init_ui(self):
        ''' Initialize The Ux part of electrum. This function performs the basic
        tasks of setting up the ui.
        '''
        from weakref import ref
        set_language(self.electrum_config.get('language'))

        self.funds_error = False
        # setup UX
        self.screens = {}

        #setup lazy imports for mainscreen
        Factory.register('AnimatedPopup',
                         module='electrum_ltc_gui.kivy.uix.dialogs')
        Factory.register('QRCodeWidget',
                         module='electrum_ltc_gui.kivy.uix.qrcodewidget')

        # preload widgets. Remove this if you want to load the widgets on demand
        #Cache.append('electrum_ltc_widgets', 'AnimatedPopup', Factory.AnimatedPopup())
        #Cache.append('electrum_ltc_widgets', 'QRCodeWidget', Factory.QRCodeWidget())

        # load and focus the ui
        self.root.manager = self.root.ids['manager']
        self.recent_activity_card = None
        self.history_screen = None
        self.contacts_screen = None

        self.icon = "icons/electrum-ltc.png"

        # connect callbacks
        if self.network:
            interests = ['update', 'status', 'new_transaction']
            self.network.register_callback(self.on_network, interests)

        self.wallet = None
Esempio n. 6
0
    def find_diff(self,widget):
        '''A utility function to find differences in properties
        between a user-modified widget and a fresh instance of the same class.
        Currently its implemented by Factory building a fresh instance and 
        comparing  but later we should add a function in kivy.properties like getdefaultvalue()
        This returns a dictionary of {property:values}
        '''
        #This dict will hold the comparable properties (We skip Alias, ReferenceList and _)
        comp_dict = {}
        #This dict will ultimately hold the properties which have changed from their defaults
        diff_dict = {}
        module_name = widget.__class__.__module__
        class_name = widget.__class__.__name__
        # TODO : Check if this class is already registered. If so, don't register again.
        Factory.register(class_name, module=module_name)
        factory_caller = getattr(Factory, class_name)
        new_widget = factory_caller()
        #Skipping certain types of properties
        for prop, value in new_widget.properties().iteritems():
            if prop.startswith('_'):
                continue
            if isinstance(value, AliasProperty):
                continue
            if isinstance(value, ReferenceListProperty):
                continue
            comp_dict[prop] = getattr(new_widget, prop)
        #Now compare these properties with the user created one
        for prop,value in comp_dict.iteritems():
            if value != getattr(widget, prop):
                diff_dict[prop] = getattr(widget, prop)
#        if len(diff_dict) != 0:
#            print "Diff in "+ class_name
        return diff_dict
Esempio n. 7
0
    def _clean_old_kv(self, path):
        '''
        Removes widgets and rules already processed to this file
        :param path: file path - the same that in app_widgets
        '''
        for key in dict(self.app_widgets):
            wd = self.app_widgets[key]
            if path != wd.kv_path:
                continue
            wdg = get_app_widget(wd)
            if wdg is None:
                continue
            if wd.is_dynamic:
                del self.app_widgets[key]

            rules = Builder.match(wdg)

            # Cleaning widget rules
            for _rule in rules:
                for _tuple in Builder.rules[:]:
                    if _tuple[1] == _rule:
                        Builder.rules.remove(_tuple)
                        if wd.is_dynamic:
                            Factory.unregister(wd.name.split('@')[0])

            # Cleaning class rules
            for rule in Builder.rules[:]:
                if rule[1].name == '<' + wd.name + '>':
                    Builder.rules.remove(rule)
                    break
Esempio n. 8
0
    def init_ui(self):
        """ Initialize The Ux part of electrum. This function performs the basic
        tasks of setting up the ui.
        """
        from weakref import ref

        self.funds_error = False
        # setup UX
        self.screens = {}

        # setup lazy imports for mainscreen
        Factory.register("AnimatedPopup", module="electrum_gui.kivy.uix.dialogs")
        Factory.register("QRCodeWidget", module="electrum_gui.kivy.uix.qrcodewidget")

        # preload widgets. Remove this if you want to load the widgets on demand
        # Cache.append('electrum_widgets', 'AnimatedPopup', Factory.AnimatedPopup())
        # Cache.append('electrum_widgets', 'QRCodeWidget', Factory.QRCodeWidget())

        # load and focus the ui
        self.root.manager = self.root.ids["manager"]
        self.recent_activity_card = None
        self.history_screen = None
        self.contacts_screen = None

        self.icon = "icons/electrum.png"

        # connect callbacks
        if self.network:
            interests = ["updated", "status", "new_transaction"]
            self.network.register_callback(self.on_network, interests)

        # self.wallet = None
        self.tabs = self.root.ids["tabs"]
Esempio n. 9
0
File: lang.py Progetto: happy56/kivy
    def load_string(self, string, **kwargs):
        """Insert a string into the Language Builder

        :Parameters:
            `rulesonly`: bool, default to False
                If True, the Builder will raise an exception if you have a root
                widget inside the definition.
        """
        kwargs.setdefault("rulesonly", False)
        self._current_filename = fn = kwargs.get("filename", None)
        try:
            # parse the string
            parser = Parser(content=string, filename=fn)

            # merge rules with our rules
            self.rules.extend(parser.rules)
            self._clear_matchcache()

            # add the template found by the parser into ours
            for name, cls, template in parser.templates:
                self.templates[name] = (cls, template, fn)
                Factory.register(name, cls=partial(self.template, name), is_template=True)

            # create root object is exist
            if kwargs["rulesonly"] and parser.root:
                filename = kwargs.get("rulesonly", "<string>")
                raise Exception("The file <%s> contain also non-rules " "directives" % filename)

            if parser.root:
                widget = Factory.get(parser.root.name)()
                self._apply_rule(widget, parser.root, parser.root)
                return widget
        finally:
            self._current_filename = None
Esempio n. 10
0
    def unload_file(self, filename):
        '''Unload all rules associated with a previously imported file.

        .. versionadded:: 1.0.8

        .. warning::

            This will not remove rules or templates already applied/used on
            current widgets. It will only effect the next widgets creation or
            template invocation.
        '''
        # remove rules and templates
        filename = resource_find(filename) or filename
        self.rules = [x for x in self.rules if x[1].ctx.filename != filename]
        self._clear_matchcache()
        templates = {}
        for x, y in self.templates.items():
            if y[2] != filename:
                templates[x] = y
        self.templates = templates

        if filename in self.files:
            self.files.remove(filename)

        # unregister all the dynamic classes
        Factory.unregister_from_filename(filename)
Esempio n. 11
0
File: lang.py Progetto: luuvish/kivy
 def _build_canvas(self, canvas, widget, rule, rootrule):
     global Instruction
     if Instruction is None:
         Instruction = Factory.get('Instruction')
     idmap = copy(self.rulectx[rootrule]['ids'])
     for crule in rule.children:
         name = crule.name
         if name == 'Clear':
             canvas.clear()
             continue
         instr = Factory.get(name)()
         if not isinstance(instr, Instruction):
             raise BuilderException(
                 crule.ctx, crule.line,
                 'You can add only graphics Instruction in canvas.')
         try:
             for prule in crule.properties.itervalues():
                 key = prule.name
                 value = prule.co_value
                 if type(value) is CodeType:
                     value = create_handler(
                         widget, instr, key, value, prule, idmap)
                 setattr(instr, key, value)
         except Exception, e:
             raise BuilderException(prule.ctx, prule.line, str(e))
Esempio n. 12
0
 def _build_canvas(self, canvas, widget, rule, rootrule):
     global Instruction
     if Instruction is None:
         Instruction = Factory.get('Instruction')
     idmap = copy(self.rulectx[rootrule]['ids'])
     for crule in rule.children:
         name = crule.name
         if name == 'Clear':
             canvas.clear()
             continue
         instr = Factory.get(name)()
         if not isinstance(instr, Instruction):
             raise BuilderException(
                 crule.ctx, crule.line,
                 'You can add only graphics Instruction in canvas.')
         try:
             for prule in crule.properties.values():
                 key = prule.name
                 value = prule.co_value
                 if type(value) is CodeType:
                     value, _ = create_handler(
                         widget, instr.proxy_ref,
                         key, value, prule, idmap, True)
                 setattr(instr, key, value)
         except Exception as e:
             tb = sys.exc_info()[2]
             raise BuilderException(
                 prule.ctx, prule.line,
                 '{}: {}'.format(e.__class__.__name__, e), cause=tb)
Esempio n. 13
0
 def cleanup(self):
     """To clean all the children in self.custom_category.
     """
     if self.custom_category:
         self.accordion.remove_widget(self.custom_category)
         Factory.register("BoxLayout", module="kivy.uix.boxlayout")
         self.custom_category = ToolboxCategory(title="App Widgets")
         self._list.append(self.custom_category)
Esempio n. 14
0
 def cleanup(self):
     '''To clean all the children in self.custom_category.
     '''
     if self.custom_category:
         self.accordion.remove_widget(self.custom_category)
         Factory.register('BoxLayout', module='kivy.uix.boxlayout')
         self.custom_category = ToolboxCategory(title='App Widgets')
         self._list.append(self.custom_category)
Esempio n. 15
0
    def load_string(self, string, **kwargs):
        '''Insert a string into the Language Builder and return the root widget
        (if defined) of the kv string.

        :Parameters:
            `rulesonly`: bool, defaults to False
                If True, the Builder will raise an exception if you have a root
                widget inside the definition.
        '''
        kwargs.setdefault('rulesonly', False)
        self._current_filename = fn = kwargs.get('filename', None)

        # put a warning if a file is loaded multiple times
        if fn in self.files:
            Logger.warning(
                'Lang: The file {} is loaded multiples times, '
                'you might have unwanted behaviors.'.format(fn))

        try:
            # parse the string
            parser = Parser(content=string, filename=fn)

            # merge rules with our rules
            self.rules.extend(parser.rules)
            self._clear_matchcache()

            # add the template found by the parser into ours
            for name, cls, template in parser.templates:
                self.templates[name] = (cls, template, fn)
                Factory.register(name,
                                 cls=partial(self.template, name),
                                 is_template=True, warn=True)

            # register all the dynamic classes
            for name, baseclasses in iteritems(parser.dynamic_classes):
                Factory.register(name, baseclasses=baseclasses, filename=fn,
                                 warn=True)

            # create root object is exist
            if kwargs['rulesonly'] and parser.root:
                filename = kwargs.get('rulesonly', '<string>')
                raise Exception('The file <%s> contain also non-rules '
                                'directives' % filename)

            # save the loaded files only if there is a root without
            # template/dynamic classes
            if fn and (parser.templates or
                       parser.dynamic_classes or parser.rules):
                self.files.append(fn)

            if parser.root:
                widget = Factory.get(parser.root.name)()
                self._apply_rule(widget, parser.root, parser.root)
                return widget
        finally:
            self._current_filename = None
Esempio n. 16
0
 def build(self):
     Factory.register('Playground', module='designer.playground')
     Factory.register('Toolbox', module='designer.toolbox')
     Factory.register('StatusBar', module='designer.statusbar')
     Factory.register('PropertyViewer', module='designer.propertyviewer')
     Factory.register('WidgetsTree', module='designer.nodetree')
     self._widget_focused = None
     self.root = Designer()
     self.bind(widget_focused=self.root.propertyviewer.setter('widget'))
     self.focus_widget(self.root.playground.root)
Esempio n. 17
0
    def on_last_selected(self, instance, field):
        tasks = self.ids.tasks
        tasks.clear_widgets()
        #Just make sure that the dos are aligned on the widget
        children = self.current_template.children
        for widget in children:
            widget.selected = widget in self.selections
        if field:
            if field in self.templates:
                self.current_template = field
            else:
                self.current_template = field.parent
                #Re add to make it at the top
                _p = field.parent
                _p.remove_widget(field)
                _p.add_widget(field)
            #Add some button around me
            from kivy.factory import Factory
            from kivy.uix.label import Label
            #Now for the big show
            text = field.name if field.name else field.Type
            from utils.fontello import FontIcon
            icon = FontIcon(icon=text, color=(0,0,0,1), font_size=24, size_hint_x=None, width=40)
            tasks.add_widget(icon)
            if text.lower().endswith('field'):
                text=text[:-5]
            label = Label(text=text, size_hint_x=None, width=100)
            tasks.add_widget(label)

            #Skip this if targetting current template
            if field != self.current_template:
                ftb = Factory.get('FieldTaskButton')
                data = [
                    (self.remove_selection, 'cancel'),
                    (self.duplicate_selection, 'duplicate'),
                ]
                for cb, img in data:
                    _button = ftb()
                    #_button.source = img
                    _button.icon = img
                    _button.bind(on_press=cb)
                    _button.designer = self
                    tasks.add_widget(_button)
                ##self.insertMoveUpDownButton()
                PIMGS = Factory.get('PositionImageSpinner')
                SIMGS = Factory.get('SizeImageSpinner')
                img_spinner = PIMGS()
                img_spinner.bind(text=self.position_selection)
                tasks.add_widget(img_spinner)
                img_spinner = SIMGS()
                img_spinner.bind(text = self.align_selection)
                tasks.add_widget(img_spinner)
                #Now load the specific attributes matrix/tree for field 6> activated by a double tap on the field
                ##self.display_field_attributes(field)
                self.ids.fields.select_node(self.nodes[field])
Esempio n. 18
0
 def show_tx_details(self, item):
     ra_dialog = Cache.get('electrum_widgets', 'RecentActivityDialog')
     if not ra_dialog:
         Factory.register('RecentActivityDialog',
                          module='electrum_gui.kivy.uix.dialogs.carousel_dialog')
         Factory.register('GridView',
                          module='electrum_gui.kivy.uix.gridview')
         ra_dialog = ra_dialog = Factory.RecentActivityDialog()
         Cache.append('electrum_widgets', 'RecentActivityDialog', ra_dialog)
     ra_dialog.item = item
     ra_dialog.open()
Esempio n. 19
0
File: lang.py Progetto: relet/kivy
 def build_template(self, item, params):
     if __debug__:
         trace("Builder: build template for %s" % item)
     if item[0] != "[" or item[-1] != "]":
         raise ParserError(params["__ctx__"], params["__line__"], "Invalid template (must be inside [])")
     item_content = item[1:-1]
     if not "@" in item_content:
         raise ParserError(params["__ctx__"], params["__line__"], "Invalid template name (missing @)")
     template_name, template_root_cls = item_content.split("@")
     self.add_template(template_name, template_root_cls, params)
     Factory.register(template_name, cls=partial(self.template, template_name), is_template=True)
Esempio n. 20
0
 def animate(self, **animProps):
     class_spec = {'cls': self.orig_obj.__class__}
     Factory.register('HighLightObj', **class_spec)
     highlight_obj = Factory.HighLightObj(text=self.orig_obj.text, padding=self.orig_obj.padding, pos=(self.orig_obj.center_x - self.parent.center_x, self.orig_obj.center_y - self.parent.center_y), size=self.orig_obj.size, font_size=self.orig_obj.font_size, **self.kwargs)
     self.parent.add_widget(highlight_obj)
     if 'd' not in animProps:
         animProps['d'] = 1.0
     if 't' not in animProps:
         animProps['t'] = 'out_cubic'
     Animation(**animProps).start(highlight_obj)
     Clock.schedule_once(lambda dt: self.parent.remove_widget(highlight_obj), animProps['d'])
     Factory.unregister('HighLightObj')
Esempio n. 21
0
 def build_template(self, item, params):
     if __debug__:
         trace('Builder: build template for %s' % item)
     if item[0] != '[' or item[-1] != ']':
         raise ParserError(params['__ctx__'], params['__line__'],
             'Invalid template (must be inside [])')
     item_content = item[1:-1]
     if not '@' in item_content:
         raise ParserError(params['__ctx__'], params['__line__'],
             'Invalid template name (missing @)')
     template_name, template_root_cls = item_content.split('@')
     self.add_template(template_name, template_root_cls, params)
     Factory.register(template_name,
                      cls=partial(self.template, template_name),
                      is_template=True)
Esempio n. 22
0
 def on_state(self, target, state):
     self.realise()
     if state == 'down':
         if self.name.lower().endswith('.kv'):
             f = Factory.get('FileItemOptionKV')()
         else:
             f = Factory.get('FileItemOption')()
         f.is_all_folder = self.is_all_folder
         self.add_widget(f)
         from kivy.animation import Animation
         anim = Animation(size_hint_y=0.2, duration=.1)
         anim.start(f)
     else:
     #remove the choice box
         self.remove_widget(self.children[0])
Esempio n. 23
0
    def cleanup(self, stop_watcher=True):
        '''To cleanup everything loaded by previous project.
        '''

        if stop_watcher:
            self.proj_watcher.stop()

        # Remove all class rules and root rules of previous project
        rules = []

        try:
            rules = Builder.match(self.root_rule.widget)
            for _rule in rules:
                for _tuple in Builder.rules[:]:
                    if _tuple[1] == _rule:
                        Builder.rules.remove(_tuple)
        except:
            pass

        for _tuple in Builder.rules[:]:
            for _rule in self.class_rules:
                if "<" + _rule.name + ">" == _tuple[1].name:
                    Builder.rules.remove(_tuple)

        if self.root_rule and not self._is_root_already_in_factory and\
                hasattr(Factory, self.root_rule.name):
            Factory.unregister(self.root_rule.name)

        self._app_file = None
        self._app_class = None
        self._app_module = None
        self._app = None
        # Remove previous project directories
        for _dir in self._dir_list:
            try:
                sys.path.remove(_dir)
            except:
                pass

        self.kv_file_list = []
        self.file_list = []
        self._dir_list = []
        self.class_rules = []
        self.list_comments = []
        self.custom_widgets = []
        self.dict_file_type_and_path = {}
        self.root_rule = None
        self._root_rule = None
Esempio n. 24
0
 def on_effect_cls(self, instance, cls):
     if isinstance(cls, string_types):
         cls = Factory.get(cls)
     self.effect_x = cls(target_widget=self._viewport)
     self.effect_x.bind(scroll=self._update_effect_x)
     self.effect_y = cls(target_widget=self._viewport)
     self.effect_y.bind(scroll=self._update_effect_y)
Esempio n. 25
0
    def create_settings(self):
        '''Create the settings panel. This method will normally
        be called only one time per
        application life-time and the result is cached internally,
        but it may be called again if the cached panel is removed
        by :meth:`destroy_settings`.

        By default, it will build a settings panel according to
        :attr:`settings_cls`, call :meth:`build_settings`, add a Kivy panel if
        :attr:`use_kivy_settings` is True, and bind to
        on_close/on_config_change.

        If you want to plug your own way of doing settings, without the Kivy
        panel or close/config change events, this is the method you want to
        overload.

        .. versionadded:: 1.8.0
        '''
        if self.settings_cls is None:
            from kivy.uix.settings import SettingsWithSpinner
            self.settings_cls = SettingsWithSpinner
        elif isinstance(self.settings_cls, string_types):
            self.settings_cls = Factory.get(self.settings_cls)
        s = self.settings_cls()
        self.build_settings(s)
        if self.use_kivy_settings:
            s.add_kivy_panel()
        s.bind(on_close=self.close_settings,
               on_config_change=self._on_config_change)
        return s
Esempio n. 26
0
    def template(self, *args, **ctx):
        '''Create a specialized template using a specific context.

        .. versionadded:: 1.0.5

        With templates, you can construct custom widgets from a kv lang
        definition by giving them a context. Check :ref:`Template usage
        <template_usage>`.
        '''
        # Prevent naming clash with whatever the user might be putting into the
        # ctx as key.
        name = args[0]
        if name not in self.templates:
            raise Exception('Unknown <%s> template name' % name)
        baseclasses, rule, fn = self.templates[name]
        key = '%s|%s' % (name, baseclasses)
        cls = Cache.get('kv.lang', key)
        if cls is None:
            rootwidgets = []
            for basecls in baseclasses.split('+'):
                rootwidgets.append(Factory.get(basecls))
            cls = type(name, tuple(rootwidgets), {})
            Cache.append('kv.lang', key, cls)
        widget = cls()
        # in previous versions, ``ctx`` is passed as is as ``template_ctx``
        # preventing widgets in it from be collected by the GC. This was
        # especially relevant to AccordionItem's title_template.
        proxy_ctx = {k: get_proxy(v) for k, v in ctx.items()}
        self._apply_rule(widget, rule, rule, template_ctx=proxy_ctx)
        return widget
Esempio n. 27
0
    def template(self, *args, **ctx):
        '''Create a specialized template using a specific context.
        .. versionadded:: 1.0.5

        With template, you can construct custom widget from a kv lang definition
        by giving them a context. Check :ref:`Template usage <template_usage>`.
        '''
        # Prevent naming clash with whatever the user might be putting into the
        # ctx as key.
        name = args[0]
        if not name in self.templates:
            raise Exception('Unknown <%s> template name' % name)
        baseclasses, defs, fn = self.templates[name]
        name, baseclasses
        key = '%s|%s' % (name, baseclasses)
        cls = Cache.get('kv.lang', key)
        if cls is None:
            rootwidgets = []
            for basecls in baseclasses.split('+'):
                rootwidgets.append(Factory.get(basecls))
            cls = ClassType(name, tuple(rootwidgets), {})
            Cache.append('kv.lang', key, cls)
        widget = cls()
        self._push_widgets()
        self._push_ids()
        self.idmap = copy(global_idmap)
        self.idmap['root'] = widget
        self.idmap['ctx'] = QueryDict(ctx)
        self.build_item(widget, defs, is_rule=True)
        self._pop_ids()
        self._pop_widgets()
        return widget
Esempio n. 28
0
File: lang.py Progetto: luuvish/kivy
    def template(self, *args, **ctx):
        '''Create a specialized template using a specific context.
        .. versionadded:: 1.0.5

        With template, you can construct custom widget from a kv lang
        definition by giving them a context. Check :ref:`Template usage
        <template_usage>`.
        '''
        # Prevent naming clash with whatever the user might be putting into the
        # ctx as key.
        name = args[0]
        if name not in self.templates:
            raise Exception('Unknown <%s> template name' % name)
        baseclasses, rule, fn = self.templates[name]
        key = '%s|%s' % (name, baseclasses)
        cls = Cache.get('kv.lang', key)
        if cls is None:
            rootwidgets = []
            for basecls in baseclasses.split('+'):
                rootwidgets.append(Factory.get(basecls))
            cls = ClassType(name, tuple(rootwidgets), {})
            Cache.append('kv.lang', key, cls)
        widget = cls()
        self._apply_rule(widget, rule, rule, template_ctx=ctx)
        return widget
Esempio n. 29
0
    def __init__(self, **kwargs):
        self._touch = None
        self._trigger_update_from_scroll = Clock.create_trigger(
            self.update_from_scroll, -1)
        super(ScrollView, self).__init__(**kwargs)
        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()
Esempio n. 30
0
 def __init__(self, **kwargs):
     super(Container, self).__init__(**kwargs)
     self.previous_text = open(self.kv_file).read()
     parser = Parser(content=self.previous_text)
     widget = Factory.get(parser.root.name)()
     Builder._apply_rule(widget, parser.root, parser.root)
     self.add_widget(widget)
Esempio n. 31
0
def setup():
    from graphics.spaceBuilderMergeGameApp import SpaceBuilderMergeGameApp
    from graphics.customWidgets.screenManagerSwitcher import ScreenManagerSwitcher
    from graphics.preLoadScreenManager import PreLoadScreenManager
    from graphics.spaceBuilderMergeGameScreenManager import SpaceBuilderMergeGameScreenManager
    from graphics.screens.splashScreen1 import SplashScreen1
    from graphics.screens.splashScreen2 import SplashScreen2
    from graphics.screens.loadingScreen import LoadingScreen
    from graphics.screens.baseBuildScreen import BaseBuildScreen
    from graphics.screens.inventoryScreen import InventoryScreen
    from graphics.screens.settingsScreen import SettingsScreen
    from graphics.customWidgets.multiLangLabel import MultiLangLabel
    from graphics.customWidgets.baseLayout import BaseLayout
    from graphics.customWidgets.betterButton import BetterButton, TextBetterButton, FlatBetterButton
    from graphics.customWidgets.buildingButtonsHandler import BuildingButtonsHandler
    from graphics.customWidgets.mergeGUI import MergeGUI

    Factory.register("SpaceBuilderMergeGameApp",
                     cls=SpaceBuilderMergeGameApp,
                     module="graphics.spaceBuilderMergeGameApp")

    Factory.register("SpaceBuilderMergeGameScreenManager",
                     cls=SpaceBuilderMergeGameScreenManager,
                     module="graphics.SpaceBuilderMergeGameScreenManager")

    Factory.register("PreLoadScreenManager",
                     cls=PreLoadScreenManager,
                     module="graphics.preLoadScreenManager")

    Factory.register("SplashScreen1",
                     cls=SplashScreen1,
                     module="graphics.screens.splashScreen")

    Factory.register("SplashScreen2",
                     cls=SplashScreen2,
                     module="graphics.screens.splashScreen")

    Factory.register("LoadingScreen",
                     cls=LoadingScreen,
                     module="graphics.screens.loadingScreen")

    Factory.register("BaseBuildScreen",
                     cls=BaseBuildScreen,
                     module="graphics.screens.baseBuildScreen")

    Factory.register("InventoryScreen",
                     cls=InventoryScreen,
                     module="graphics.screens.inventoryScreen")

    Factory.register("SettingsScreen",
                     cls=SettingsScreen,
                     module="graphics.screens.settingsScreen")

    Factory.register("MultiLangLabel",
                     cls=MultiLangLabel,
                     module="graphics.customWidgets.multiLangLabel")

    Factory.register("BaseLayout",
                     cls=BaseLayout,
                     module="graphics.customWidgets.baseLayout")

    Factory.register("BetterScatter",
                     cls=BetterScatter,
                     module="graphics.customWidgets.betterScatter")

    Factory.register("BetterButton",
                     cls=BetterButton,
                     module="graphics.customWidgets.betterButton")

    Factory.register("TextBetterButton",
                     cls=TextBetterButton,
                     module="graphics.customWidgets.betterButton")

    Factory.register("FlatBetterButton",
                     cls=FlatBetterButton,
                     module="graphics.customWidgets.betterButton")

    Factory.register("BuildingButtonsHandler",
                     cls=BuildingButtonsHandler,
                     module="graphics.customWidgets.buildingButtonsHandler")

    Factory.register("MergeGUI",
                     cls=MergeGUI,
                     module="graphics.customWidgets.mergeItemHolder")

    Factory.register("ResourceMinerManager",
                     cls=ResourceMinerManager,
                     module="graphics.customWidgets.resourceMinerManager")

    Logger.info("All classes have been assigned to Factory")
Esempio n. 32
0
 def show_popup(self):
     self.pop_up = Factory.PopupBox()
     self.pop_up.update_pop_up_text('Running some task...')
     self.pop_up.open()
Esempio n. 33
0
File: main.py Progetto: dpkm95/DSApp
DS_KVS = os.path.join(DS_ROOT,'ds_kvs')
DS_CLASSES = [c[:-3] for c in os.listdir(DS_KVS)

class Root(FloatLayout):
	screen_manager = ObjectProperty(None)	
	child = ObjectProperty(None) 

	def change_kv(self,*largs):
		child = self.screen_manager.current_screen.children[0]
		with open(child.kv_file, 'rb') as file:
			text = file.read().decode('utf8')
		kv_container = self.screen_manager.current_screen
		try:
			parser = Parser(content = txt)
			kv_container.clear_widgets()
			widget = Factory.get(parser.root.name)()
			Builder._apply_rule(widget,parser.root,parser.root)
			kv_container.add_widget(widget)
		except (SyntaxError, ParserException) as e:
			self.show_error(e)
		except Exception as e:
			self.show_error(e)	 

class DS(App):
	pass

Factory.register('Root', cls=Root)
	
if __name__=='__main__':
    DS().run()
Esempio n. 34
0
 def generate_screen(self, job_dict, item_ink_key_dict):
     self.clear_screen()
     self.add_widget(Factory.RunPageLayout(job_dict, item_ink_key_dict))
Esempio n. 35
0
    def unfocus(self):
        '''Unfocus the window
        '''
        self.parent._bk.widget_unfocus(self._id)
        self._have_focus = 0

    def on_widget_paint(self, texture):
        with self.canvas:
            self._g_color = Color(1, 1, 1)
            self._g_rect = Rectangle(texture = texture, size=self.size, pos = self.pos)
            self._g_rect.tex_coords = (0, 1, 1, 1, 1, 0, 0, 0)
        self.canvas.ask_update()


Factory.register('Webbrowser', cls=Webbrowser)


if __name__ == '__main__':

    from kivy.app import App
    class WebbrowserApp(App):
        def build(self):
            wb = Webbrowser(size_hint=(None, None), size=(300, 64),
                            transparency=True)
            with open('bleh.html', 'w') as fd:
                fd.write('<h1><span style="color: #ff0000">Hello</span>'
                         '<span style="color: #00ff00">World</span></h1>')
            wb.open_filename('bleh.html')
            return wb
Esempio n. 36
0
        self._stack_cont_action_view.pop()
        self.clear_widgets()
        if self._stack_cont_action_view == []:
            super(ActionBar, self).add_widget(self.action_view)
        else:
            super(ActionBar, self).add_widget(self._stack_cont_action_view[-1])


if __name__ == "__main__":
    from kivy.base import runTouchApp
    from kivy.uix.floatlayout import FloatLayout
    from kivy.factory import Factory

    # XXX clean the first registration done from '__main__' here.
    # otherwise kivy.uix.actionbar.ActionPrevious != __main__.ActionPrevious
    Factory.unregister('ActionPrevious')

    Builder.load_string('''
<MainWindow>:
    ActionBar:
        pos_hint: {'top':1}
        ActionView:
            use_separator: True
            ActionPrevious:
                title: 'Action Bar'
                with_previous: False
            ActionOverflow:
            ActionButton:
                text: 'Btn0'
                icon: 'atlas://data/images/defaulttheme/audio-volume-high'
            ActionButton:
Esempio n. 37
0
    def test_widget_popup(self, *args):
        EventLoop.ensure_window()
        self._win = EventLoop.window

        self.clean_garbage()

        # build the widget tree & add Window as the main EL
        self.root = self.builder.Builder.load_string(
            KV, filename="InspectorTestCase.KV")
        self.render(self.root)
        self.assertLess(len(self._win.children), 2)

        # checked widget
        popup = self.root.ids.popup
        popup_exp = self.root.ids.popup.text

        # activate inspector with root as ctx
        inspector.start(self._win, self.root)
        self.advance_frames(1)

        # pull the Inspector drawer from bottom,
        # but don't inspect yet!
        ins = self.root.inspector
        ins.inspect_enabled = False
        ins.activated = True
        self.assertTrue(ins.at_bottom)

        # touch button center to open the popup
        touch = UnitTestTouch(*popup.center)
        touch.touch_down()
        touch.touch_up()
        self.advance_frames(1)

        # start inspecting
        ins.inspect_enabled = True
        self.advance_frames(1)

        # inspect FirstModal's button
        touch.touch_down()
        touch.touch_up()
        self.advance_frames(1)

        # open Inspector properties
        ins.show_widget_info()
        self.advance_frames(2)

        # check if the popup is selected
        # stored instance
        self.assertIsInstance(ins.widget, Factory.Button)
        self.assertIsInstance(ins.widget.parent, Factory.FirstModal)
        # check with new Popup instance if the properties match
        temp_popup = Factory.FirstModal()
        temp_popup_exp = temp_popup.ids.firstmodal.text
        self.assertEqual(ins.widget.text, temp_popup_exp)
        # data in properties
        for node in ins.treeview.iterate_all_nodes():
            lkey = getattr(node.ids, 'lkey', None)
            if not lkey:
                continue
            if lkey.text == 'text':
                ltext = node.ids.ltext
                # slice because the string is displayed with quotes
                self.assertEqual(ltext.text[1:-1], temp_popup_exp)
                break
        del temp_popup

        # close popup
        ins.inspect_enabled = False
        touch = UnitTestTouch(0, 0)
        touch.touch_down()
        touch.touch_up()
        self.advance_frames(10)

        # close Inspector
        ins.activated = False
        self.render(self.root)
        self.advance_frames(10)

        # stop Inspector completely
        inspector.stop(self._win, self.root)
        self.assertLess(len(self._win.children), 2)
        self.render(self.root)
Esempio n. 38
0
 def add_output(self, address, amount):
     b = Factory.OutputItem()
     b.address = address
     b.value = self.app.format_amount_and_units(amount)
     self.add_widget(b)
Esempio n. 39
0
 def __init__(self, **kwargs):
     # 起動時に各画面を作成して使い回す
     self.window1 = Factory.Window1()
     self.window2 = Factory.Window2()
     super(MainRoot, self).__init__(**kwargs)
Esempio n. 40
0
from electrum.paymentrequest import PR_UNPAID, PR_PAID, PR_UNKNOWN, PR_EXPIRED

from kivy.app import App
from kivy.core.window import Window
from kivy.logger import Logger
from kivy.utils import platform
from kivy.properties import (OptionProperty, AliasProperty, ObjectProperty,
                             StringProperty, ListProperty, BooleanProperty)
from kivy.cache import Cache
from kivy.clock import Clock
from kivy.factory import Factory
from kivy.metrics import inch, metrics
from kivy.lang import Builder

# lazy imports for factory so that widgets can be used in kv
Factory.register('InstallWizard',
                 module='electrum_gui.kivy.uix.dialogs.installwizard')
Factory.register('InfoBubble', module='electrum_gui.kivy.uix.dialogs')
Factory.register('ELTextInput', module='electrum_gui.kivy.uix.screens')

#from kivy.core.window import Window
#Window.softinput_mode = 'below_target'

# delayed imports: for startup speed on android
notification = app = ref = None
util = False

# register widget cache for keeping memory down timeout to forever to cache
# the data
Cache.register('electrum_widgets', timeout=0)

from kivy.uix.screenmanager import Screen
Esempio n. 41
0
import kivy
#kivy.require('1.10.0') # replace with your current Kivy version

from kivy.uix.behaviors import ButtonBehavior
from kivy.uix.image import Image
from kivy.factory import Factory


class ImageButton(ButtonBehavior, Image):
    pass


Factory.register("ImageButton", cls=ImageButton)
Esempio n. 42
0
            self.runvalid = False
            # if(self.exportvalid == False):
            #   self.exporttext = "Please selected an export location"
            #  self.exportcolor = [1,0,0,1]
            # self.runvalid = False
            # ^ code that was not implemented
        return self.runvalid

    #Go button event
    def gopress(self):
        #checks if download location and a style has been selected
        if(self.runable() == True):
            self.finished = os.path.relpath(self.downloadtext,os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))
            c.go(self.finished,int(self.stylenum))
            self.location = self.downloadtext.split('/')
            self.finishname = self.location[len(self.location)-1]
            self.finishname = self.finishname.split('.')[0]
            self.addfinished(self.finishname)

# runs the application
class MainGUIApp(App):
    def build(self):
        #imports the gui.kv file, so we can have the gui the way it looks
        self.load_kv('gui.kv')
        return MainGUI()

Factory.register('DownloadDialog',cls=DownloadDialog)

#run the application
MGApp = MainGUIApp()
MGApp.run()
Esempio n. 43
0
#Window.softinput_mode = 'below_target'

# delayed imports: for startup speed on android
notification = app = ref = None
util = False

# register widget cache for keeping memory down timeout to forever to cache
# the data
Cache.register('electrum_mac_widgets', timeout=0)

from kivy.uix.screenmanager import Screen
from kivy.uix.tabbedpanel import TabbedPanel
from kivy.uix.label import Label
from kivy.core.clipboard import Clipboard

Factory.register('TabbedCarousel', module='electrum_mac_gui.kivy.uix.screens')

# Register fonts without this you won't be able to use bold/italic...
# inside markup.
from kivy.core.text import Label
Label.register('Roboto',
               'gui/kivy/data/fonts/Roboto.ttf',
               'gui/kivy/data/fonts/Roboto.ttf',
               'gui/kivy/data/fonts/Roboto-Bold.ttf',
               'gui/kivy/data/fonts/Roboto-Bold.ttf')


from electrum_mac.util import base_units


class ElectrumWindow(App):
Esempio n. 44
0
 def build(self):
     self.bind(on_start=self.post_build_init)
     self.sm.add_widget(Factory.LoginScreen())
     self.sm.add_widget(Factory.HomeScreen())
     self.sm.current = "login_screen"
     return self.sm
Esempio n. 45
0
                current_time = component.current_time
                fade_out_start = component.fade_out_start
                time = component.time
                fade_out_time = time - fade_out_start
                if current_time >= time:
                    self.gameworld.remove_entity(entity_id)
                    self.make_entity()
                if current_time < fade_out_start:
                    color_comp.a = lerp(0., 255., 
                        current_time / fade_out_start)
                else:
                    color_comp.a = lerp(255., 0., 
                        (current_time - fade_out_start) / fade_out_time)


Factory.register('FadingSystem', cls=FadingSystem)


class TestGame(Widget):
    def on_kv_post(self, *args):
        self.gameworld.init_gameworld(
            ['color', 'position', 'renderer', 'fade'],
            callback=self.init_game)

    def init_game(self):
        self.setup_states()
        self.load_resources()
        self.set_state()
        self.draw_some_stuff()

    def load_resources(self):
Esempio n. 46
0
        self.border_point = pos
        self.hovered = inside
        if inside:
            self.dispatch('on_enter')
        else:
            self.dispatch('on_leave')

    def on_enter(self):
        pass

    def on_leave(self):
        pass


from kivy.factory import Factory
Factory.register('HoverBehavior', HoverBehavior)


class HoverButton(Button, HoverBehavior):
    def on_enter(self, *args):
        print(self.text)
        print("You are in, through this point", self.border_point)
        Window.set_system_cursor('hand')

    def on_leave(self, *args):
        print("You left through this point", self.border_point)
        Window.set_system_cursor('arrow')


class ButtonApp(App):
    def __init__(self, **kwargs):
Esempio n. 47
0
        """Shake effect animation."""

        Animation.stop_all(self)
        (Animation(translate_x=50, t="out_quad", d=0.02) +
         Animation(translate_x=0, t="out_elastic", d=0.5)).start(self)

    def wobble(self):
        """Wobble effect animation."""

        Animation.stop_all(self)
        ((Animation(scale_y=0.7, t="out_quad", d=0.03)
          & Animation(scale_x=1.4, t="out_quad", d=0.03)) +
         (Animation(scale_y=1, t="out_elastic", d=0.5)
          & Animation(scale_x=1, t="out_elastic", d=0.4))).start(self)

    def twist(self):
        """Twist effect animation."""

        Animation.stop_all(self)
        (Animation(rotate=25, t="out_quad", d=0.05) +
         Animation(rotate=0, t="out_elastic", d=0.5)).start(self)

    def shrink(self):
        """Shrink effect animation."""

        Animation.stop_all(self)
        Animation(scale_x=0.95, scale_y=0.95, t="out_quad", d=0.1).start(self)


Factory.register("MagicBehavior", cls=MagicBehavior)
Esempio n. 48
0
    def load_string(self, string, **kwargs):
        '''Insert a string into the Language Builder and return the root widget
        (if defined) of the kv string.

        :Parameters:
            `rulesonly`: bool, defaults to False
                If True, the Builder will raise an exception if you have a root
                widget inside the definition.
            `filename`: str, defaults to None
                If specified, the filename used to index the kv rules.

        The filename parameter can be used to unload kv strings in the same way
        as you unload kv files. This can be achieved using pseudo file names
        e.g.::

            Build.load_string("""
                <MyRule>:
                    Label:
                        text="Hello"
            """, filename="myrule.kv")

        can be unloaded via::

            Build.unload_file("myrule.kv")

        '''

        kwargs.setdefault('rulesonly', False)
        self._current_filename = fn = kwargs.get('filename', None)

        # put a warning if a file is loaded multiple times
        if fn in self.files:
            Logger.warning('Lang: The file {} is loaded multiples times, '
                           'you might have unwanted behaviors.'.format(fn))

        try:
            # parse the string
            parser = Parser(content=string, filename=fn)

            # merge rules with our rules
            self.rules.extend(parser.rules)
            self._clear_matchcache()

            # add the template found by the parser into ours
            for name, cls, template in parser.templates:
                self.templates[name] = (cls, template, fn)
                Factory.register(name,
                                 cls=partial(self.template, name),
                                 is_template=True,
                                 warn=True)

            # register all the dynamic classes
            for name, baseclasses in parser.dynamic_classes.items():
                Factory.register(name,
                                 baseclasses=baseclasses,
                                 filename=fn,
                                 warn=True)

            # create root object is exist
            if kwargs['rulesonly'] and parser.root:
                filename = kwargs.get('rulesonly', '<string>')
                raise Exception('The file <%s> contain also non-rules '
                                'directives' % filename)

            # save the loaded files only if there is a root without
            # template/dynamic classes
            if fn and (parser.templates or parser.dynamic_classes
                       or parser.rules):
                self.files.append(fn)

            if parser.root:
                widget = Factory.get(parser.root.name)(__no_builder=True)
                rule_children = []
                widget.apply_class_lang_rules(root=widget,
                                              rule_children=rule_children)
                self._apply_rule(widget,
                                 parser.root,
                                 parser.root,
                                 rule_children=rule_children)

                for child in rule_children:
                    child.dispatch('on_kv_post', widget)
                widget.dispatch('on_kv_post', widget)
                return widget
        finally:
            self._current_filename = None
Esempio n. 49
0
 def build(self):
     Window.bind(on_keyboard=self.key_input)
     self.root = Factory.MainLayout()
Esempio n. 50
0
 def generate_ink_key(self, ink_key_dict):
     self.clear_widgets()
     self.add_widget(Factory.InkKeyBoxLayout(ink_key_dict))
Esempio n. 51
0
class FirebaseLoginScreen(Screen, EventDispatcher):
    """Use this widget as a complete module to incorporate Firebase user
    authentication in your app. To use this module, instantiate the login screen
    in the KV language like so:
    FirebaseLoginScreen:
        web_api_key: "your_firebase_web_api_key"
        debug: True # Not necessary, but will print out debug information
        on_login_success:
            # do something here

    In your main App class, set the three following fields to dictate the color
    scheme of the login screens. Example:

    class MainApp(App):
        primary_color: (1, 0, 0, 1)
        secondary_color: (0, 1, 0, 1)
        tertiary_color: (0, 0, 1, 1)
        pass

    NOTES:
    1) You MUST set the web api key or it is impossible for the login screen to
    function properly.
    2) You probably want to wrap the FirebaseLoginScreen in a ScreenManager.
    3) You probably want to switch screens to a Screen in your project once the
    user has logged in (write that code in the on_login_success function shown
    in the example above).
    4) You can set the colors (primary_color, secondary_color, tertiary_color)
    to be whatever you like.
    """

    # Firebase Project meta info - MUST BE CONFIGURED BY DEVELOPER
    web_api_key = StringProperty()  # From Settings tab in Firebase project

    # Firebase Authentication Credentials - what developers want to retrieve
    refresh_token = ""
    localId = ""
    idToken = ""

    # Properties used to send events to update some parts of the UI
    login_success = BooleanProperty(False)  # Called upon successful sign in
    sign_up_msg = StringProperty()
    sign_in_msg = StringProperty()
    email_exists = BooleanProperty(False)
    email_not_found = BooleanProperty(False)

    debug = True
    popup = Factory.LoadingPopup()
    popup.background = folder + "/transparent_image.png"


    def on_login_success(self, *args):
        """Overwrite this method to switch to your app's home screen.
        """
        print("Logged in successfully", args)

    def on_web_api_key(self, *args):
        """When the web api key is set, look for an existing account in local
        memory.
        """
        # Try to load the users info if they've already created an account
        self.refresh_token_file = App.get_running_app().user_data_dir + "/refresh_token.txt"
        if self.debug:
            print("Looking for a refresh token in:", self.refresh_token_file)
        if os.path.exists(self.refresh_token_file):
            self.load_saved_account()

    def sign_up(self, email, password):
        """If you don't want to use Firebase, just overwrite this method and
        do whatever you need to do to sign the user up with their email and
        password.
        """
        if self.debug:
            print("Attempting to create a new account: ", email, password)
        signup_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/signupNewUser?key=" + self.web_api_key
        signup_payload = dumps(
            {"email": email, "password": password, "returnSecureToken": "true"})

        UrlRequest(signup_url, req_body=signup_payload,
                   on_success=self.successful_login,
                   on_failure=self.sign_up_failure,
                   on_error=self.sign_up_error)

    def successful_login(self, urlrequest, log_in_data):
        """Collects info from Firebase upon successfully registering a new user.
        """
        self.hide_loading_screen()
        self.refresh_token = log_in_data['refreshToken']
        self.localId = log_in_data['localId']
        self.idToken = log_in_data['idToken']
        self.save_refresh_token(self.refresh_token)
        self.login_success = True
        if self.debug:
            print("Successfully logged in a user: "******"""Displays an error message to the user if their attempt to log in was
        invalid.
        """
        self.hide_loading_screen()
        self.email_exists = False  # Triggers hiding the sign in button
        print(failure_data)
        msg = failure_data['error']['message'].replace("_", " ").capitalize()
        # Check if the error msg is the same as the last one
        if msg == self.sign_up_msg:
            # Need to modify it somehow to make the error popup display
            msg = " " + msg + " "
        self.sign_up_msg = msg
        if msg == "Email exists":
            self.email_exists = True
        if self.debug:
            print("Couldn't sign the user up: ", failure_data)

    def sign_up_error(self, *args):
        self.hide_loading_screen()
        if self.debug:
            print("Sign up Error: ", args)

    def sign_in(self, email, password):
        """Called when the "Log in" button is pressed.

        Sends the user's email and password in an HTTP request to the Firebase
        Authentication service.
        """
        if self.debug:
            print("Attempting to sign user in: ", email, password)
        sign_in_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/verifyPassword?key=" + self.web_api_key
        sign_in_payload = dumps(
            {"email": email, "password": password, "returnSecureToken": True})

        UrlRequest(sign_in_url, req_body=sign_in_payload,
                   on_success=self.successful_login,
                   on_failure=self.sign_in_failure,
                   on_error=self.sign_in_error)

    def sign_in_failure(self, urlrequest, failure_data):
        """Displays an error message to the user if their attempt to create an
        account was invalid.
        """
        self.hide_loading_screen()
        self.email_not_found = False  # Triggers hiding the sign in button
        print(failure_data)
        msg = failure_data['error']['message'].replace("_", " ").capitalize()
        # Check if the error msg is the same as the last one
        if msg == self.sign_in_msg:
            # Need to modify it somehow to make the error popup display
            msg = " " + msg + " "
        self.sign_in_msg = msg
        if msg == "Email not found":
            self.email_not_found = True
        if self.debug:
            print("Couldn't sign the user in: ", failure_data)

    def sign_in_error(self, *args):
        self.hide_loading_screen()
        if self.debug:
            print("Sign in error", args)

    def reset_password(self, email):
        """Called when the "Reset password" button is pressed.

        Sends an automated email on behalf of your Firebase project to the user
        with a link to reset the password. This email can be customized to say
        whatever you want. Simply change the content of the template by going to
        Authentication (in your Firebase project) -> Templates -> Password reset
        """
        if self.debug:
            print("Attempting to send a password reset email to: ", email)
        reset_pw_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/getOobConfirmationCode?key=" + self.web_api_key
        reset_pw_data = dumps({"email": email, "requestType": "PASSWORD_RESET"})

        UrlRequest(reset_pw_url, req_body=reset_pw_data,
                   on_success=self.successful_reset,
                   on_failure=self.sign_in_failure,
                   on_error=self.sign_in_error)

    def successful_reset(self, urlrequest, reset_data):
        """Notifies the user that a password reset email has been sent to them.
        """
        self.hide_loading_screen()
        if self.debug:
            print("Successfully sent a password reset email", reset_data)
        self.sign_in_msg = "Reset password instructions sent to your email."

    def save_refresh_token(self, refresh_token):
        """Saves the refresh token in a local file to enable automatic sign in
        next time the app is opened.
        """
        if self.debug:
            print("Saving the refresh token to file: ", self.refresh_token_file)
        with open(self.refresh_token_file, "w") as f:
            f.write(refresh_token)

    def load_refresh_token(self):
        """Reads the refresh token from local storage.
        """
        if self.debug:
            print("Loading refresh token from file: ", self.refresh_token_file)
        with open(self.refresh_token_file, "r") as f:
            self.refresh_token = f.read()

    def load_saved_account(self):
        """Uses the refresh token to get the user's idToken and localId by
        sending it as a request to Google/Firebase's REST API.

        Called immediately when a web_api_key is set and if the refresh token
        file exists.
        """
        if self.debug:
            print("Attempting to log in a user automatically using a refresh token.")
        self.load_refresh_token()
        refresh_url = "https://securetoken.googleapis.com/v1/token?key=" + self.web_api_key
        refresh_payload = dumps({"grant_type": "refresh_token", "refresh_token": self.refresh_token})
        UrlRequest(refresh_url, req_body=refresh_payload,
                   on_success=self.successful_account_load,
                   on_failure=self.failed_account_load,
                   on_error=self.failed_account_load)

    def successful_account_load(self, urlrequest, loaded_data):
        """Sets the idToken and localId variables upon successfully loading an
        account using the refresh token.
        """
        self.hide_loading_screen()
        if self.debug:
            print("Successfully logged a user in automatically using the refresh token")
        self.idToken = loaded_data['id_token']
        self.localId = loaded_data['user_id']
        self.login_success = True

    def failed_account_load(self, *args):
        self.hide_loading_screen()
        if self.debug:
            print("Failed to load an account.", args)

    def display_loading_screen(self, *args):
        self.popup.color = self.tertiary_color
        self.popup.open()

    def hide_loading_screen(self, *args):
        self.popup.dismiss()
Esempio n. 52
0
 def build(self):
     return Factory.ScreenManager()
Esempio n. 53
0
 def render_conditions(self, conditions_description):
     conditions_widget = Factory.UnknownConditions()  # <3>
     conditions_widget.conditions = conditions_description
     self.conditions.clear_widgets()
     self.conditions.add_widget(conditions_widget)  # <4>
Esempio n. 54
0
 def show_popup(self, title, content):
     popup = Factory.Popup(title=title,
                           content=Label(text=content, text_size=(Window.size[0] * 3/4, None)),
                           size_hint=(3/4, 3/4))
     popup.open()
Esempio n. 55
0
#Window.softinput_mode = 'below_target'

# delayed imports: for startup speed on android
notification = app = ref = None
util = False

# register widget cache for keeping memory down timeout to forever to cache
# the data
Cache.register('electrum_bitcoinprivate_widgets', timeout=0)

from kivy.uix.screenmanager import Screen
from kivy.uix.tabbedpanel import TabbedPanel
from kivy.uix.label import Label
from kivy.core.clipboard import Clipboard

Factory.register('TabbedCarousel', module='electrum_bitcoinprivate_gui.kivy.uix.screens')

# Register fonts without this you won't be able to use bold/italic...
# inside markup.
from kivy.core.text import Label
Label.register('Roboto',
               'gui/kivy/data/fonts/Roboto.ttf',
               'gui/kivy/data/fonts/Roboto.ttf',
               'gui/kivy/data/fonts/Roboto-Bold.ttf',
               'gui/kivy/data/fonts/Roboto-Bold.ttf')


from electrum_bitcoinprivate.util import base_units


class ElectrumWindow(App):
Esempio n. 56
0
    def build(self):
        self.theflag = 0
        self.theflag0 = 0
        self.distan = 1000  # дистанция до начальной точки (0,0,-50) что бы ничего не было за экраном (надо будет выстваить на изменение)
        bl = BoxLayout(orientation='vertical',
                       size_hint=(.15, 1),
                       spacing=10,
                       padding=10)  # левая панель
        al = AnchorLayout(anchor_x='left',
                          anchor_y='center')  # основная система интерфейса
        layout = GridLayout(cols=2, spacing=3,
                            size_hint=(1, 1))  #сетка для кнопок поворота

        matrix = np.load('matrix0.npy', allow_pickle=True)
        print(matrix)
        #a=matrix['self.a']
        print(a)
        counter = int(int(matrix.size) / 2)
        x = np.zeros(counter)
        y = np.zeros(counter)
        z = np.zeros(counter)
        soe = np.zeros((counter, counter))

        for i in range(2):
            if (i == 0):
                for j in range(counter):
                    for k in range(3):
                        #a=matrix[i,j]
                        if (k == 0):
                            x[j] = a[k] * 10
                        elif (k == 1):
                            y[j] = a[k] * 10
                        else:
                            z[j] = a[k] * 10
            else:
                for j in range(counter):
                    a = matrix[i, j]
                    for k in range(counter):
                        soe[j][k] = a[k]
        print(x, y, z)
        print(soe)
        # кнопка загрузки координат
        loader = Button(text='Load', on_press=self.load)
        bl.add_widget(loader)

        #starter = Button(text='Построить', on_press = self.letstart)
        #bl.add_widget(starter)

        bl.add_widget(Widget())
        # create renderer
        self.renderer = Renderer()

        # create scene
        scene = Scene()

        #lines
        k0 = 0
        k1 = 0
        lines_list = []
        for i in soe:
            for j in i:
                if (j == 1):
                    line0_geo = BoxGeometry(
                        1,
                        int(((y[k0] - y[k1])**2 + (x[k0] - x[k1])**2 +
                             (z[k0] - z[k1])**2)**0.5), 1)
                    #print(int(((abs(x[k0]-x[k1]) + abs(y[k0]-y[k1])+ abs(z[k0]-z[k1]))**0.5)),'length')
                    #print(int(abs(y[k0]-y[k1]) + abs(x[k0]-x[k1])+ abs(z[k0]-z[k1])))
                    line0_mat = Material()
                    self.line0 = Mesh(
                        geometry=line0_geo,
                        material=line0_mat)  # default pos == (0, 0, 0)
                    self.line0.pos.x = int((x[k0] + x[k1]) / 2)
                    self.line0.pos.y = int((y[k0] + y[k1]) / 2)
                    self.line0.pos.z = int((z[k0] + z[k1]) / 2) - self.distan
                    if y[k0] - y[k1] == 0 and x[k0] - x[
                            k1] == 0 and z[k0] - z[k1] != 0:
                        self.line0.rotation.x = 90
                    elif y[k0] - y[k1] == 0 and x[k0] - x[k1] != 0 and z[
                            k0] - z[k1] == 0:
                        self.line0.rotation.z = 90
                    elif y[k0] - y[k1] != 0 and x[k0] - x[k1] == 0 and z[
                            k0] - z[k1] == 0:
                        ###
                        fff = 0
                    elif y[k0] - y[k1] != 0 and x[k0] - x[k1] != 0 and z[
                            k0] - z[k1] == 0:
                        self.line0.rotation.z = math.atan(
                            (x[k0] - x[k1]) / (y[k0] - y[k1])) / math.pi * 180
                    elif y[k0] - y[k1] != 0 and x[k0] - x[
                            k1] == 0 and z[k0] - z[k1] != 0:
                        #self.line0.rotation.x = math.atan((z[k0]-z[k1])/(y[k0]-y[k1]))/math.pi*180
                        self.line0.rotation.x = math.acos(
                            abs(y[k0] - y[k1]) /
                            ((x[k0] - x[k1])**2 + (y[k0] - y[k1])**2 +
                             (z[k0] - z[k1])**2)**0.5) / math.pi * 180
                        #print()
                    elif y[k0] - y[k1] == 0 and x[k0] - x[k1] != 0 and z[
                            k0] - z[k1] != 0:
                        self.line0.rotation.z = math.atan(
                            (x[k0] - x[k1]) /
                            (z[k0] - z[k1])) / math.pi * 180 * -1
                        self.line0.rotation.x = 90

                    ###
                    elif y[k0] - y[k1] != 0 and x[k0] - x[k1] != 0 and z[
                            k0] - z[k1] != 0:
                        if ((x[k0] < x[k1] and y[k0] < y[k1])
                                or (x[k0] > x[k1] and y[k0] > y[k1])):
                            #self.line0.rotation.z = math.atan((abs(z[k0]-z[k1]))/1.5/(abs(y[k0]-y[k1])))/math.pi*180
                            self.line0.rotation.z = math.acos(
                                abs(y[k0] - y[k1]) /
                                ((x[k0] - x[k1])**2 + (y[k0] - y[k1])**2 +
                                 (0)**2)**0.5) / math.pi * 180 * -1
                            #проблема
                        else:
                            self.line0.rotation.z = math.acos(
                                abs(y[k0] - y[k1]) /
                                ((x[k0] - x[k1])**2 + (y[k0] - y[k1])**2 +
                                 (0)**2)**0.5) / math.pi * 180
                        #self.line0.rotation.x = math.atan((1.25*abs(x[k0]-x[k1]))/(abs(y[k0]-y[k1])))/math.pi*180*-1
                        if ((z[k0] < z[k1] and y[k0] < y[k1])
                                or (z[k0] > z[k1] and y[k0] > y[k1])):
                            self.line0.rotation.x = math.acos(
                                abs(y[k0] - y[k1]) /
                                ((0)**2 + (y[k0] - y[k1])**2 +
                                 (z[k0] - z[k1])**2)**0.5) / math.pi * 180
                            #проблема
                        else:
                            self.line0.rotation.x = math.acos(
                                abs(y[k0] - y[k1]) /
                                ((0)**2 + (y[k0] - y[k1])**2 +
                                 (z[k0] - z[k1])**2)**0.5) / math.pi * 180 * -1

                        #self.line0.rotation.x = math.acos(abs(y[k0]-y[k1])/((0)**2+(y[k0]-y[k1])**2+(z[k0]-z[k1])**2)**0.5)/math.pi*180*-1#there
                        print(self.line0.rotation.z)
                        print(self.line0.rotation.x)
                    lines_list.append(self.line0)
                k1 += 1
            k0 += 1
            k1 = 0
        line0_geo = BoxGeometry(1, y[1] - y[0], 1)
        line0_mat = Material()
        self.line0 = Mesh(geometry=line0_geo,
                          material=line0_mat)  # default pos == (0, 0, 0)
        self.line0.pos.z = int(z[0]) - self.distan

        #self.line3.rotation.x = 90

        #points
        point_list = []
        sumx = 0
        sumy = 0
        sumz = 0
        sumcount = 0
        loader = OBJLoader()

        for i in range(counter):
            point_geom = SphereGeometry(1.1)
            point_mat = Material()
            self.point0 = Mesh(geometry=point_geom, material=point_mat)
            self.point0.pos.x = int(x[i])
            self.point0.pos.y = int(y[i])
            self.point0.pos.z = int(z[i]) - self.distan
            self.point0.scale = (1, 1, 1)
            point_list.append(self.point0)
            sumx += self.point0.pos.x
            sumy += self.point0.pos.y
            sumz += self.point0.pos.z
            sumcount += 1
            #scene.add(self.point0)

        point_geom = SphereGeometry()
        point_mat = Material()
        self.point1 = Mesh(geometry=point_geom, material=point_mat)
        self.point1.pos.x = sumx / sumcount
        self.point1.pos.y = sumy / sumcount
        self.point1.pos.z = sumz / sumcount
        self.point1.scale = (1, 1, 1)
        #scene.add(self.point1)
        self.camera = PerspectiveCamera(
            fov=100,  # размер окна т.е. чем больше фов тем больше масштаб
            aspect=0,  # "screen" ratio
            near=1,  # рендер от
            far=10000  # дистанция рендера
        )

        k0 = 0
        self.ll = []
        for i in soe:
            for j in i:
                if (j == 1):
                    self.ll.append(lines_list[k0])
                    scene.add(lines_list[k0])
                    k0 += 1

        for i in range(counter):
            scene.add(point_list[i])
            pass

        self.pp = point_list
        self.renderer.render(scene, self.camera)
        self.renderer.bind(size=self._adjust_aspect)
        al.add_widget(self.renderer)
        bl.add_widget(Factory.Fov())
        bl.add_widget(Factory.CamNav())
        al.add_widget(bl)
        return al
Esempio n. 57
0
from kivy.app import App
from kivy.factory import Factory
from kivy.lang import Builder

Factory.register('QRScanner', module='electrum_cesc_gui.kivy.qr_scanner')


class QrScannerDialog(Factory.AnimatedPopup):

    __events__ = ('on_complete', )

    def on_symbols(self, instance, value):
        instance.stop()
        self.dismiss()
        data = value[0].data
        self.dispatch('on_complete', data)

    def on_complete(self, x):
        ''' Default Handler for on_complete event.
        '''
        print x


Builder.load_string('''
<QrScannerDialog>
    title:
        _(\
        '[size=18dp]Hold your QRCode up to the camera[/size][size=7dp]\\n[/size]')
    title_size: '24sp'
    border: 7, 7, 7, 7
    size_hint: None, None
Esempio n. 58
0
 def __init__(mcs, name, bases, attrs):
     super(WidgetMetaclass, mcs).__init__(name, bases, attrs)
     Factory.register(name, cls=mcs)
Esempio n. 59
0
 def do_save(self):
     gro_list = ListState.instance.convert_to_pool()
     Factory.SaveDialog(gro_list).open()
     self.dismiss()
Esempio n. 60
0
"""
A program to register Kivy Cupertino widgets for use in kv lang
"""

from kivy.factory import Factory

Factory.register('CupertinoNavigationBar', module='kivycupertino.uix.bar')
Factory.register('CupertinoTabBar', module='kivycupertino.uix.bar')
Factory.register('CupertinoButton', module='kivycupertino.uix.button')
Factory.register('CupertinoSystemButton', module='kivycupertino.uix.button')
Factory.register('CupertinoSymbolButton', module='kivycupertino.uix.button')
Factory.register('CupertinoSegmentedControls',
                 module='kivycupertino.uix.control')
Factory.register('CupertinoStepper', module='kivycupertino.uix.control')
Factory.register('CupertinoProgressBar', module='kivycupertino.uix.indicator')
Factory.register('CupertinoAlertDialog', module='kivycupertino.uix.indicator')
Factory.register('CupertinoLabel', module='kivycupertino.uix.label')
Factory.register('CupertinoScrollView', module='kivycupertino.uix.scrollview')
Factory.register('CupertinoSlider', module='kivycupertino.uix.slider')
Factory.register('CupertinoSwitch', module='kivycupertino.uix.switch')
Factory.register('CupertinoSymbol', module='kivycupertino.uix.symbol')
Factory.register('CupertinoTextField', module='kivycupertino.uix.textfield')
Factory.register('CupertinoTextView', module='kivycupertino.uix.textfield')