コード例 #1
1
ファイル: test_uix_listview.py プロジェクト: JF002/kivy
    def test_list_view_with_list_of_integers_scrolling(self):

        data = [{'text': str(i), 'is_selected': False} for i in xrange(100)]

        args_converter = lambda row_index, rec: {'text': rec['text'],
                                                 'size_hint_y': None,
                                                 'height': 25}

        list_adapter = ListAdapter(data=data,
                                   args_converter=args_converter,
                                   selection_mode='single',
                                   allow_empty_selection=False,
                                   cls=ListItemButton)

        list_view = ListView(adapter=list_adapter)

        list_view.scroll_to(20)
        self.assertEqual(list_view._index, 20)
コード例 #2
0
    def __init__(self, **kwargs):
        self.data = list()
        for x in range(0, len(Active.cl.c_list)):
            self.data.append({
                'hostname': Active.cl.c_list[x].name,
                'ip': Active.cl.c_list[x].ip
            })
        self.list_adapter = ListAdapter(data=self.data,
                                        args_converter=self.formatter,
                                        cls=ClCompositeListItem,
                                        selection_mode='single',
                                        allow_empty_selection=False)
        super(ListViewModal, self).__init__(**kwargs)
        self.list_view = ListView(adapter=self.list_adapter)
        self.add_widget(self.list_view)
        if len(self.data) is 0:
            detail_view = ClientDetailView(cl_name="List is empty", size_hint=(.6, 1.0))
        else:
            detail_view = ClientDetailView(cl_name=self.list_adapter.selection[0].text,
                                       size_hint=(.6, 1.0))

        self.list_adapter.bind(
            on_selection_change=detail_view.cl_changed)
        self.add_widget(detail_view)
        Clock.schedule_interval(self.callback, 5)
コード例 #3
0
ファイル: k_lex.py プロジェクト: alex-me/py_master
 def __init__(self):
     super(Widg, self).__init__(orientation='vertical', spacing=20)
     self.s = ""
     self.txt = TextInput(multiline=False, font_size=24)
     self.bsel = Button(text='select files',
                        font_size=24,
                        background_color=[0.8, 0.2, 0.1, 1])
     self.bfrq = Button(text='compute frequency',
                        font_size=24,
                        background_color=[0.2, 0.8, 0.1, 1])
     self.lsel = ListView(item_strings=[""])
     self.lles = ListView(item_strings=[""])
     self.lmos = ListView(item_strings=[""])
     self.f = FileChooserListView(path=path,
                                  filters=['*.txt'],
                                  multiselect=True)
     self.bsel.bind(on_release=self.on_files)
     self.bfrq.bind(on_release=self.on_conv)
     self.bb = BoxLayout(size_hint=(1, 0.2))
     self.ff = BoxLayout()
     self.lm = BoxLayout(size_hint=(1, 0.6))
     self.ff.add_widget(self.f)
     self.ff.add_widget(self.lsel)
     self.bb.add_widget(self.bsel)
     self.bb.add_widget(self.bfrq)
     self.lm.add_widget(self.lles)
     self.lm.add_widget(self.lmos)
     self.add_widget(self.lm)
     self.add_widget(self.bb)
     self.add_widget(self.ff)
コード例 #4
0
ファイル: test_selection.py プロジェクト: won21kr/kivy
    def test_dict_adapter_selection_cascade(self):

        # Categories of fruits:
        #
        categories = sorted(fruit_categories.keys())
        categories_dict_adapter = \
            DictAdapter(sorted_keys=categories,
                        data=fruit_categories,
                        args_converter=self.args_converter,
                        selection_mode='single',
                        allow_empty_selection=False,
                        cls=ListItemButton)

        fruit_categories_list_view = \
            ListView(adapter=categories_dict_adapter,
                     size_hint=(.2, 1.0))

        # Fruits, for a given category, are shown based on the fruit category
        # selected in the first categories list above. The selected item in
        # the first list is used as the key into a dict of lists of list
        # items to reset the data in FruitsDictAdapter's
        # fruit_category_changed() method.
        #
        # data is initially set to the first list of list items.
        #
        fruits_dict_adapter = \
                FruitsDictAdapter(
                    sorted_keys=fruit_categories[categories[0]]['fruits'],
                    data=fruit_data,
                    args_converter=self.args_converter,
                    selection_mode='single',
                    allow_empty_selection=False,
                    cls=ListItemButton)

        categories_dict_adapter.bind(
            on_selection_change=fruits_dict_adapter.fruit_category_changed)

        fruits_list_view = ListView(adapter=fruits_dict_adapter,
                                    size_hint=(.2, 1.0))

        # List views should have adapters set.
        self.assertEqual(fruit_categories_list_view.adapter,
                         categories_dict_adapter)
        self.assertEqual(fruits_list_view.adapter, fruits_dict_adapter)

        # Each list adapter has allow_empty_selection=False, so each should
        # have one selected item.
        self.assertEqual(len(categories_dict_adapter.selection), 1)
        self.assertEqual(len(fruits_dict_adapter.selection), 1)

        # The selected list items should show is_selected True.
        self.assertEqual(categories_dict_adapter.selection[0].is_selected,
                         True)
        self.assertEqual(fruits_dict_adapter.selection[0].is_selected, True)

        # And they should be red, for background_color.
        self.assertEqual(categories_dict_adapter.selection[0].background_color,
                         [1.0, 0., 0., 1.0])
        self.assertEqual(fruits_dict_adapter.selection[0].background_color,
                         [1.0, 0., 0., 1.0])
コード例 #5
0
    def init(self, simulate=False, time_interval=1, **kwargs):
        """
        Initializes Datamodel

        """
        self.minval = kwargs.get("minval", self.minval)
        self.maxval = kwargs.get("maxval", self.maxval)
        self.blockname = kwargs.get("blockname", self.blockname)
        self.clear_widgets()
        self.simulate = simulate
        self.time_interval = time_interval
        dict_adapter = DictAdapter(data={},
                                   args_converter=self.arg_converter,
                                   selection_mode='single',
                                   allow_empty_selection=True,
                                   cls=CompositeListItem
                                   )

        # Use the adapter in our ListView:
        self.list_view = ListView(adapter=dict_adapter)
        self.add_widget(self.list_view)
        self.dispatcher = UpdateEventDispatcher()
        self._parent = kwargs.get('_parent', None)
        self.simulate_timer = BackgroundJob(
            "simulation",
            self.time_interval,
            self._simulate_block_values
        )
コード例 #6
0
    def build(self):
        # screen manager steup
        sm = ScreenManager()

        # main menu setup
        main_menu = 

        # define Spell screen
        spell_layout = BoxLayout()
        # add big_layout to ScreenManger
        sm.add_widget(spell_layout)
        left_box = BoxLayout(orientation='vertical', spacing=10, size_hint=(.3, 1))
        right_box = StackLayout(size_hint=(.7, 1))
        left_top_box = ListView(size_hint=(1, .8))
        left_bottom_box = BoxLayout(size_hint=(1, .2))

        rb = Label(text='right box')
        ltb = Label(text='left top box')
        btn_rest = Button(text='Rest')
        btn_main = Button(text='Main Menu')
        btn_quit = Button(text='Quit')

        spell_layout.add_widget(left_box)
        spell_layout.add_widget(right_box)

        left_box.add_widget(left_top_box)
        left_box.add_widget(left_bottom_box)

        right_box.add_widget(rb)
        left_top_box.add_widget(ltb)
        left_bottom_box.add_widget(btn_rest)
        left_bottom_box.add_widget(btn_main)
        left_bottom_box.add_widget(btn_quit)

        return sm
コード例 #7
0
ファイル: LabpiLoad.py プロジェクト: quydau35/vilas
    def __init__(self, *args, **kwargs):
        super(LoadScreen, self).__init__(*args, **kwargs)

        list_item_args_converter = lambda row_index, obj: {
            'root_path': obj.root_path,
            'item_id': obj.item_id,
            'text': obj.text,
            'pdbFile': obj.pdbFile,
            'remove_item': obj.remove_item,
            'zoom_item': obj.zoom_item,
            'list_id': obj.list_id
        }

        self.list_adapter_receptor = LoadAdapter(
            data=[],
            args_converter=list_item_args_converter,
            template='LoadListItem')
        pdb_list_1 = ListView(adapter=self.list_adapter_receptor,
                              divider_height=1,
                              id='pdb_list_1')
        self.boxlist_1.add_widget(pdb_list_1)

        self.list_adapter_ligand = LoadAdapter(
            data=[],
            args_converter=list_item_args_converter,
            template='LoadListItem')
        pdb_list_2 = ListView(adapter=self.list_adapter_ligand,
                              divider_height=1,
                              id='pdb_list_2')
        self.boxlist_2.add_widget(pdb_list_2)
コード例 #8
0
ファイル: GUIMenu.py プロジェクト: renatotnk/UDESC
    def listaCaes(self, a):
        box = GridLayout(cols=1, rows=5, spacing=[0, 10])

        nao_adotados = self.dados.getDoguinhosNaoAdotados()

        adotados = self.dados.getDoguinhosAdotados()
        box.add_widget(Label(text='Cães Não Adotados', size_hint_y=0.15))
        dados_nao_adotados = []
        for dog in nao_adotados:
            dog_infos = dog.getInfos()
            dados_nao_adotados.append("ID: {0}     Nome: {1}".format(
                dog_infos[0], dog_infos[1]))
            dados_nao_adotados.append("Raça: {0}     Sexo: {1}".format(
                dog_infos[2], dog_infos[3]))
            dados_nao_adotados.append("Porte: {0}     Idade: {1}".format(
                dog_infos[4], dog_infos[5]))
            if dog_infos[6] == "1":
                stat = "Apto para adoção."
            else:
                stat = "Inapto para adoção."
            dados_nao_adotados.append("Status: {0}".format(stat))
            dados_nao_adotados.append("{0}".format(dog_infos[7]))
            dados_nao_adotados.append('')
            dados_nao_adotados.append('')

        simple_list_adapter = SimpleListAdapter(data=dados_nao_adotados,
                                                cls=Label)
        list_view1 = ListView(adapter=simple_list_adapter)
        box.add_widget(list_view1)

        box.add_widget(Label(text='Cães Adotados', size_hint_y=0.15))

        dados_adotados = []
        for dog in adotados:
            dog_infos = dog.getInfos()
            dados_adotados.append("ID: {0}     Nome: {1}".format(
                dog_infos[0], dog_infos[1]))
            dados_adotados.append("Raça: {0}     Sexo: {1}".format(
                dog_infos[2], dog_infos[3]))
            dados_adotados.append("Porte: {0}     Idade: {1}".format(
                dog_infos[4], dog_infos[5]))
            dados_adotados.append("{0}".format(dog_infos[7]))
            dados_adotados.append('')
            dados_adotados.append('')

        simple_list_adapter2 = SimpleListAdapter(data=dados_adotados,
                                                 cls=Label)
        list_view2 = ListView(adapter=simple_list_adapter2)
        box.add_widget(list_view2)

        fechar_botao = Button(text='Fechar', size_hint_y=0.2)
        box.add_widget(fechar_botao)
        self.popupListaCaes = Popup(title='Lista de Cães',
                                    content=box,
                                    size_hint=(None, None),
                                    size=(600, 600))
        fechar_botao.bind(on_press=self.popupListaCaes.dismiss)

        self.popupListaCaes.open()
    def __init__(self, **kwargs):
        super(MainLayout, self).__init__(**kwargs)

        self.args_converter = lambda row_index, rec: \
        {'size_hint_y': None,
        'height': 30,
         'spacing':8,
        'is_selected':False,
        'cls_dicts': [{'cls':ListItemLabel,
                        'kwargs': {'text': rec['firstname'],'size_hint_x': .2,'size_hint_y': None,'height': 25, 'font_size': '12sp'}},
                      {'cls': ListItemLabel,
                        'kwargs': {'text': rec['lastname'],'size_hint_x': .2,'size_hint_y': None,'height': 25,'font_size': '12sp'}},
                      {'cls': ListItemLabel,
                        'kwargs': {'text': rec['role'],'size_hint_x': .2,'size_hint_y': None,'height': 25,'font_size': '12sp'}},
                      {'cls': MyListItemButton,
                        'kwargs': {'text': u'edit','size_hint_x': .2,'size_hint_y': None,'height': 25,'font_size': '12sp', 'disabled': False,
                                  'on_press':self.find_user}},
                      {'cls': MyListItemButton,
                        'kwargs': {'text': u'delete','size_hint_x': .2,'size_hint_y': None,'height': 25,'font_size': '12sp','disabled': False,
                                  'on_press':self.delete_user}},
                      ]}

        self.list_adapter = ListAdapter(data=[],
                                        args_converter=self.args_converter,
                                        selection_mode='none',
                                        allow_empty_selection=True,
                                        cls=CompositeListItem)

        list_view = ListView(adapter=self.list_adapter)
        self.lv_users_box.add_widget(list_view)

        self.args_converter_order = lambda row_index, rec: \
        {'size_hint_y': None,
        'height': 30,
         'spacing':8,
        'is_selected':False,
        'cls_dicts': [{'cls':ListItemLabel,
                        'kwargs': {'text': str(row_index+1),'size_hint_x': .2,'size_hint_y': None,'height': 25, 'font_size': '12sp'}},
                      {'cls': ListItemLabel,
                        'kwargs': {'text': rec['table'],'size_hint_x': .2,'size_hint_y': None,'height': 25,'font_size': '12sp'}},
                      {'cls': ListItemLabel,
                        'kwargs': {'text': rec['status'],'size_hint_x': .2,'size_hint_y': None,'height': 25,'font_size': '12sp'}},
                      {'cls': ListItemLabel,
                        'kwargs': {'text': str(rec['total']),'size_hint_x': .2,'size_hint_y': None,'height': 25,'font_size': '12sp'}},
                      ]}

        self.order_adapter = ListAdapter(
            data=[],
            args_converter=self.args_converter_order,
            selection_mode='none',
            allow_empty_selection=True,
            cls=CompositeListItem)

        self.list_view_order = ListView(adapter=self.order_adapter)
        self.lv_orders_box.add_widget(self.list_view_order)

        self.choice_role_user()  #dropdown
コード例 #10
0
    def __init__(self, **kwargs):
        kwargs['cols'] = 3
        super(CascadingView, self).__init__(**kwargs)

        list_item_args_converter = \
                lambda row_index, rec: {'text': rec['name'],
                                        'size_hint_y': None,
                                        'height': 25}

        # Fruit categories list on the left:
        #
        categories = sorted(fruit_categories.keys())
        fruit_categories_list_adapter = \
            DictAdapter(
                    sorted_keys=categories,
                    data=fruit_categories,
                    args_converter=list_item_args_converter,
                    selection_mode='single',
                    allow_empty_selection=False,
                    cls=ListItemButton)
        fruit_categories_list_view = \
                ListView(adapter=fruit_categories_list_adapter,
                        size_hint=(.2, 1.0))
        self.add_widget(fruit_categories_list_view)

        # Fruits, for a given category, in the middle:
        #
        image_list_item_args_converter = \
                lambda row_index, rec: {'text': rec['name'],
                                        'size_hint_y': None,
                                        'height': 32}
        fruits_list_adapter = \
                FruitsDictAdapter(
                    sorted_keys=fruit_categories[categories[0]]['fruits'],
                    data=fruit_data,
                    args_converter=image_list_item_args_converter,
                    selection_mode='single',
                    allow_empty_selection=False,
                    template='ThumbnailedListItem')
        fruits_list_view = \
                ListView(adapter=fruits_list_adapter,
                    size_hint=(.2, 1.0))

        fruit_categories_list_adapter.bind(
                on_selection_change=fruits_list_adapter.fruit_category_changed)

        self.add_widget(fruits_list_view)

        # Detail view, for a given fruit, on the right:
        #
        detail_view = FruitImageDetailView(
                fruit_name=fruits_list_adapter.selection[0].fruit_name,
                size_hint=(.6, 1.0))

        fruits_list_adapter.bind(
                on_selection_change=detail_view.fruit_changed)
        self.add_widget(detail_view)
コード例 #11
0
    def enter_state(self, context=None):
        print 'ShowingListsScreen/enter_state'

        if not 'Lists' in self.statechart.app.sm.screen_names:

            # Convenience references:
            self.app = self.statechart.app

            view = BoxLayout(orientation='vertical', spacing=10)

            toolbar = BoxLayout(size_hint=(1.0, None), height=50)

            label = Label(text='Lists', color=[.8, .8, .8, .8], bold=True)
            toolbar.add_widget(label)

            button = Button(text='Search')
            button.bind(on_press=self.go_to_search)
            toolbar.add_widget(button)

            button = Button(text='Data')
            button.bind(on_press=self.go_to_data)
            toolbar.add_widget(button)

            button = Button(text='Detail')
            button.bind(on_press=self.go_to_detail)
            toolbar.add_widget(button)

            view.add_widget(toolbar)

            lists_view = GridLayout(cols=3, size_hint=(1.0, 1.0))

            lists_view.add_widget(
                ListView(adapter=self.statechart.fruit_categories_dict_adapter,
                         size_hint=(.2, 1.0)))

            lists_view.add_widget(
                ListView(adapter=self.statechart.fruits_dict_adapter,
                         size_hint=(.2, 1.0)))

            selected_fruit = \
                    self.statechart.fruits_dict_adapter.selection[0].text
            self.detail_view = FruitDetailView(fruit_name=selected_fruit,
                                               size_hint=(.6, 1.0))

            lists_view.add_widget(self.detail_view)

            view.add_widget(lists_view)

            self.create_adapter_bindings()

            screen = Screen(name='Lists')
            screen.add_widget(view)
            self.app.sm.add_widget(screen)

        if self.app.sm.current != 'Lists':
            self.app.sm.current = 'Lists'
コード例 #12
0
    def __init__(self, **kwargs):
        self.qrdata = list()
        # FOR NETWORK
        Active.qrList.clear()
        try:
            Active.qrList = Active.qr_task.get_qr_list(Active.client)
        except QrException as qr:
            popup = Popup(size_hint=(None, None), size=(400, 150))
            popup.add_widget(Label(text=qr.value))
            popup.bind(on_press=popup.dismiss)
            popup.title = qr.title
            popup.open()
        except EmptyListException as ee:
            global empty
            if empty is 0:
                empty = 1
                popup = Popup(size_hint=(None, None), size=(400, 150))
                popup.add_widget(Label(text=ee.value))
                popup.bind(on_press=popup.dismiss)
                popup.title = ee.title
                popup.open()
        for x in range(0, len(Active.qrList)):
            self.qrdata.append({
                'filename': Active.qrList[x].f_name,
                'old_path': Active.qrList[x].o_path
            })

        self.list_adapter = ListAdapter(data=self.qrdata,
                                        args_converter=self.formatter,
                                        selection_mode='single',
                                        allow_empty_selection=False,
                                        cls=QrCompositeListItem)

        super(QuarantineViewModal, self).__init__(**kwargs)
        self.list_view = ListView(adapter=self.list_adapter)
        self.add_widget(self.list_view)
        if len(self.qrdata) is 0:
            detail_view = QrDetailView(qr_name="List is empty",
                                       size_hint=(.6, 1.0))
        else:
            detail_view = QrDetailView(
                qr_name=self.list_adapter.selection[0].text,
                size_hint=(.6, 1.0))

        self.list_adapter.bind(on_selection_change=detail_view.qr_changed)
        self.add_widget(detail_view)
        Clock.schedule_interval(self.callback, 60)
        Clock.schedule_interval(self.callback2, 5)
コード例 #13
0
ファイル: sample.py プロジェクト: Raivk/L3_social_project
    def connect_popup(self):
        popup = Popup(title='Connecter deux sommets',
                      size_hint=(0.9, 0.9),
                      auto_dismiss=False)
        bl = BoxLayout(orientation='vertical')

        confirm_button = Button(text="Confirmer")
        confirm_button.disabled = True

        gl_inputs = GridLayout(cols=2)

        gl_inputs.add_widget(Label(text="Sommet 1"))
        gl_inputs.add_widget(Label(text="Sommet 2"))

        list_adapter1 = ListAdapter(data=[
            str(i + 1) + "- " + self.g.get_sommets()[i].nom
            for i in range(len(self.g.get_sommets()))
        ],
                                    cls=ListItemButton,
                                    sorted_keys=[])
        list_adapter1.bind(on_selection_change=lambda a: self.selection_change(
            list_adapter1, 0, list_adapter2, confirm_button))
        list_view1 = ListView(adapter=list_adapter1)

        gl_inputs.add_widget(list_view1)

        list_adapter2 = ListAdapter(data=[
            str(i + 1) + "- " + self.g.get_sommets()[i].nom
            for i in range(len(self.g.get_sommets()))
        ],
                                    cls=ListItemButton,
                                    sorted_keys=[])
        list_adapter2.bind(on_selection_change=lambda a: self.selection_change(
            list_adapter2, 1, list_adapter1, confirm_button))
        list_view2 = ListView(adapter=list_adapter2)

        gl_inputs.add_widget(list_view2)

        bl.add_widget(gl_inputs)

        confirm_button.bind(on_press=lambda a: self.connect(popup))
        cancel_button = Button(text="Annuler")
        cancel_button.bind(on_press=lambda a: popup.dismiss())
        bl.add_widget(confirm_button)
        bl.add_widget(cancel_button)

        popup.content = bl
        popup.open()
コード例 #14
0
ファイル: GUIMenu.py プロジェクト: renatotnk/UDESC
    def listaTut(self, a):
        box = GridLayout(cols=1, rows=3)
        box.add_widget(Label(text='Lista de Tutores', size_hint_y=0.15))
        tutores = self.dados.getTutores()
        dados = []
        for tut in tutores:
            tutInfos = tut.getInfos()
            dados.append("ID: {0}   Nome: {1}   CPF: {2}".format(
                tutInfos[0], tutInfos[1], tutInfos[3]))
            telefone = tutInfos[4]
            telefone = telefone[:-4] + "-" + telefone[-4:]
            dados.append("Endereço: {0}   Telefone: {1}".format(
                tutInfos[2], telefone))
            dados.append('')
            dados.append('')

        simple_list_adapter = SimpleListAdapter(data=dados, cls=Label)
        list_view1 = ListView(adapter=simple_list_adapter)
        box.add_widget(list_view1)
        botao = Button(text='Fechar', size_hint_y=0.2)
        box.add_widget(botao)
        self.popupListaTutores = Popup(title='Lista de Tutores',
                                       content=box,
                                       size_hint=(None, None),
                                       size=(600, 600))
        botao.bind(on_press=self.popupListaTutores.dismiss)

        self.popupListaTutores.open()
コード例 #15
0
ファイル: main.py プロジェクト: martkins/images_exif_viewer
    def start_app(self):
        labels = [LabelModel() for _ in range(100)]

        self.image = Factory.MainImage(ImageModel())
        self.root.ids.image_box.add_widget(self.image)

        self.exif = Factory.GetExifData(ButtonModel(image=self.image, labels=labels))
        self.root.ids.button_box.add_widget(self.exif)
        right = Factory.RotateRight(self.exif.model)
        self.root.ids.button_box.add_widget(right)
        left = Factory.RotateLeft(self.exif.model)
        self.root.ids.button_box.add_widget(left)
        loc = Factory.GetLocation(self.exif.model)
        self.root.ids.button_box.add_widget(loc)
        next = Factory.NextImage(self.exif.model)
        self.root.ids.cycle_box.add_widget(next)
        prev = Factory.PreviousImage(self.exif.model)
        self.root.ids.cycle_box.add_widget(prev)
        get = Factory.OpenImage(self.exif.model)
        self.root.ids.button_box.add_widget(get)

        lab = Factory.ExifLabel(LabelModel())
        self.root.ids.exif_container.add_widget(lab)

        list_adapter = SimpleListAdapter(
            data=labels,
            args_converter=lambda row, model: {'model': model,
                                               'size_hint_y': None,
                                               'height':100},
            cls=Factory.ExifTags)
        self.root.ids.exif_container.add_widget(ListView(adapter=list_adapter))
コード例 #16
0
def lookup_item(self, item):

    if not item or not item.get('uri'):
        return

    uri = item['uri']
    logger.debug('Browsing on URI: %s', uri)

    info = self.mopidy.library.browse(uri=uri, timeout=40)
    info_tracks = format_nice(info, format='browse').split('\n')

    title = '[%s] %s  (%d items)' % (item['type'], item['name'], len(info_tracks))

    lv = ListView(item_strings=info_tracks, halign='left')
    btn = Button(text='Close', size_hint_y=None, height=50)
    cnt = BoxLayout(orientation='vertical')
    cnt.add_widget(lv)
    cnt.add_widget(btn)

    popup = Popup(title=title,
                    content=cnt,
                    size_hint=(0.8, 0.8),
                    title_size=22,)

    btn.bind(on_press=popup.dismiss)
    popup.open()
コード例 #17
0
ファイル: GUIMenu.py プロジェクト: renatotnk/UDESC
    def listaAdoc(self, a):
        box = GridLayout(cols=1, rows=3)
        box.add_widget(Label(text='Lista de Adoções', size_hint_y=0.15))
        adocoes = self.dados.getAdocoes()
        dados = []
        for ad in adocoes:
            adInfos = ad.getInfos()
            for dog in self.dados.doguinhos:
                if dog.getId() == adInfos[0]:
                    nome = dog.getNome()
            for tutor in self.dados.tutores:
                if tutor.getId() == adInfos[1]:
                    nome_tutor = tutor.getNome()
            dados.append("ID do cão: {0}   Nome do cão: {1}".format(
                adInfos[0], nome))
            dados.append("ID do tutor: {0}   Nome do tutor: {1}".format(
                adInfos[1], nome_tutor))
            dados.append("Data de adoção: {0}".format(adInfos[2]))
            dados.append('')
            dados.append('')

        simple_list_adapter = SimpleListAdapter(data=dados, cls=Label)
        list_view1 = ListView(adapter=simple_list_adapter)
        box.add_widget(list_view1)
        botao = Button(text='Fechar', size_hint_y=0.2)
        box.add_widget(botao)
        self.popupListaAdoc = Popup(title='Lista de Adoções',
                                    content=box,
                                    size_hint=(None, None),
                                    size=(600, 600))
        botao.bind(on_press=self.popupListaAdoc.dismiss)

        self.popupListaAdoc.open()
コード例 #18
0
    def __init__(self, items, **kwargs):
        kwargs['cols'] = 2
        kwargs['size_hint'] = (1.0, 1.0)
        super(MasterDetailView, self).__init__(**kwargs)

        list_item_args_converter = \
                lambda row_index, rec: {'text': rec['name'],
                                        'size_hint_y': None,
                                        'height': 25}

        dict_adapter = DictAdapter(sorted_keys=sorted(fruit_data.keys()),
                                   data=fruit_data,
                                   args_converter=list_item_args_converter,
                                   selection_mode='single',
                                   allow_empty_selection=False,
                                   cls=ListItemButton)

        master_list_view = ListView(adapter=dict_adapter, size_hint=(.3, 1.0))

        self.add_widget(master_list_view)

        detail_view = FruitDetailView(
            fruit_name=dict_adapter.selection[0].text, size_hint=(.7, 1.0))

        dict_adapter.bind(on_selection_change=detail_view.fruit_changed)
        self.add_widget(detail_view)
コード例 #19
0
    def __init__(self, **kwargs):

        def items_args_converter(row_index, rec):
            return {
                'text': rec.name,
                'value': str(rec.value),
                'unit': rec.unit,
                'size_hint_y': None, 'height': 20,
                'cls_dicts': [{
                    'cls': ListItemButton,
                    'kwargs': {
                        'text': rec.name,
                        'size_hint_x': 0.6,
                        'is_representing_cls': True}},
                    {'cls': ListItemLabel,
                     'kwargs': {'text': str(rec.value)[:6], 'size_hint_x': 0.3}},
                    {'cls': ListItemLabel,
                     'kwargs': {'text': rec.unit, 'size_hint_x': 0.1}}]}

        self.list_adapter = ListAdapter(
            data={},
            args_converter=items_args_converter,
            selection_mode='single',
            allow_empty_selection=True,
            propagate_selection_to_data=True,
            cls=CompositeListItem)
        self.list_adapter.bind(on_selection_change=self.reg_selection_changed)
        super(RegDictView, self).__init__(**kwargs)
        self.add_widget(ListView(adapter=self.list_adapter))
        self.slider_view = RegSliderView(reg_index=0, list_adapter=self.list_adapter)
        self.add_widget(self.slider_view)
コード例 #20
0
def videoArchiveBtnCallback(self):
        setDisplaySleepTime(9999,1)
        data = getVideoList()
        listData = []
        for d in data:
                listData.append(d.id + "  " + d.time.strftime('%d. %b - %H:%M:%S'))

        list_adapter = ListAdapter(data=listData,
                           cls=VideoListItemButton,
                           selection_mode='single',
                           allow_empty_selection=False)
        player = VideoPlayer(source=data[0].path, state='play', options={'allow_stretch': True})
        root = GridLayout(cols=2)
        popup = Popup(title='Video archív  -  '+data[0].time.strftime('%d. %b - %H:%M:%S'),
                    content=root,
                    size_hint=(1, 1))
        list_adapter.bind(on_selection_change=partial(videoArchiveItemSelected,player, popup))
        
        
        layout1 = BoxLayout(orientation='vertical')
        layout2 = BoxLayout(orientation='vertical')
        videoList = ListView(adapter=list_adapter)
        btn = Button(text='Zatvoriť', size_hint_y=0.2)
        layout1.add_widget(videoList)
        layout2.add_widget(player)
        layout2.add_widget(btn)
        root.add_widget(layout1)
        root.add_widget(layout2)
        
        btn.bind(on_press=partial(videoArchiveExitBtnCallback,popup))
        popup.open()
コード例 #21
0
ファイル: plist.py プロジェクト: wushin/manachat
    def __init__(self, **kwargs):
        super(PlayersList, self).__init__(**kwargs)

        player_args_coverter = lambda row_index, nick: {
            "nick": nick,
            "size_hint_y": None,
            "height": "30dp",
            "pos_hint_y": 0.9
        }

        list_adapter = ListAdapter(data=["Ginaria", "Celestia"],
                                   args_converter=player_args_coverter,
                                   selection_mode='single',
                                   allow_empty_selection=True,
                                   cls=PlayersListItem)

        list_view = ListView(adapter=list_adapter,
                             size_hint=(1.0, 1.0),
                             pos_hint={'center_x': 0.5})

        def data_changed(instance, value):
            list_adapter.data = value

        self.bind(items=data_changed)

        self.add_widget(list_view)
コード例 #22
0
    def __init__(self, screen, **kwargs):
        super(SevenTest, self).__init__(screen, **kwargs)
        self.desc = "Odečítání sedmiček"
        self.instruction = "Odečtěte od čísla 100 číslo 7 a pak pokračujte v odčítání 7."
        self.instruction_audio = "sounds/ins7.mp3"
        self.points = 0
        self.pomoc1 = 0
        self.pomoc2 = 0
        self.pomoc3 = 0
        self.pomoc4 = 0
        self.pomoc5 = 0
        self.test_field = GridLayout(cols=1,
                                     size_hint=(.2, .8),
                                     pos_hint={"x": .4})
        self.prvni = TextInput(hint=u"první", font_size="60px", size_hint_y=.6)
        self.druhy = TextInput(hint=u"druhy", font_size="60px", size_hint_y=.6)
        self.treti = TextInput(hint=u"třetí", font_size="60px", size_hint_y=.6)
        self.ctvrty = TextInput(hint=u"čtvrtý",
                                font_size="60px",
                                size_hint_y=.6)
        self.paty = TextInput(hint=u"pátý", font_size="60px", size_hint_y=.6)
        self.number_list = ListView(item_strings=[])

        self.prvni.bind(text=self.prvni_callback)
        self.druhy.bind(text=self.druhy_callback)
        self.treti.bind(text=self.treti_callback)
        self.ctvrty.bind(text=self.ctvrty_callback)
        self.paty.bind(text=self.paty_callback)

        with self.canvas.before:
            Color(0, 0, 0, 1)
            self.rec = Rectangle(size=Window.size)
コード例 #23
0
    def __init__(self, *args, **kwargs):
        super(EditProducts, self).__init__(*args, **kwargs)
        args_converter_edit = lambda row_index, rec: \
        {'size_hint_y': None,
        'height': 30,
        'spacing':8,
        'is_selected':True,
        'text':rec['text'],
        'active':rec['active'],

        'cls_dicts':
                 [{'cls':ListItemLabel,
                    'kwargs': {'text':rec['text'],
                               'color': [0,0,0, 0.95],
                               'size_hint_x': .2,'size_hint_y': None,'height': 25, 'font_size': '12sp'}},
                 {'cls':MyCheckBox,
                   'kwargs': {'active':rec['active'],
                              'size_hint_x': .2,'size_hint_y': None,'height': 25, 'font_size': '12sp',
                              'on_press': self.on_active}}
        ]}
        self.choices_adapter = ListAdapter(
            data=[],  #edit_adapter
            args_converter=args_converter_edit,
            selection_mode='none',
            allow_empty_selection=True,
            cls=CompositeListItem)
        self.list_view_choices = ListView(adapter=self.choices_adapter)
        self.choices_oprop.add_widget(self.list_view_choices)
コード例 #24
0
    def init(self, simulate=False, time_interval=1, **kwargs):
        """
        Initializes Datamodel

        """
        self.minval = kwargs.get("minval", self.minval)
        self.maxval = kwargs.get("maxval", self.maxval)
        self.blockname = kwargs.get("blockname", self.blockname)
        self.clear_widgets()
        self.simulate = simulate
        self.time_interval = time_interval
        dict_adapter = DictAdapter(data={},
                                   args_converter=self.arg_converter,
                                   selection_mode='single',
                                   allow_empty_selection=True,
                                   cls=CompositeListItem
                                   )

        # Use the adapter in our ListView:
        self.list_view = ListView(adapter=dict_adapter)
        self.add_widget(self.list_view)
        self.dispatcher = UpdateEventDispatcher()
        self._parent = kwargs.get('_parent', None)
        self.simulate_timer = BackgroundJob(
            "simulation",
            self.time_interval,
            self._simulate_block_values
        )
コード例 #25
0
    def build(self):
        args_converter = lambda row_index, rec: \
            {'text': rec['text'],
            'size_hint_y': None,
            'height': 25,
            'cls_dicts': [{'cls': ListItemButton,
                            'kwargs': {'text': rec['text']}},
                        {'cls': ListItemLabel,
                            'kwargs': {'text': "Middle-{0}".format(rec['text']),
                                    'is_representing_cls': True}},
                        {'cls': ListItemButton,
                            'kwargs': {'text': rec['text']}}]}

        item_strings = ["{0}".format(index) for index in range(100)]

        integers_dict = \
            {str(i): {'text': str(i), 'is_selected': False} for i in range(100)}

        dict_adapter = DictAdapter(sorted_keys=item_strings,
                                   data=integers_dict,
                                   args_converter=args_converter,
                                   selection_mode='single',
                                   allow_empty_selection=False,
                                   cls=CompositeListItem)

        list_view = ListView(adapter=dict_adapter)
        return list_view
コード例 #26
0
ファイル: test_selection.py プロジェクト: won21kr/kivy
    def test_list_adapter_selection_mode_single(self):
        list_adapter = ListAdapter(data=fruit_data_items,
                                   args_converter=self.args_converter,
                                   selection_mode='single',
                                   propagate_selection_to_data=True,
                                   allow_empty_selection=True,
                                   cls=ListItemButton)
        list_view = ListView(adapter=list_adapter)

        # The reason why len(selection) == 0 here is because ListView,
        # at the end of its __init__(), calls check_for_empty_selection()
        # and does NOT trigger the initial selection, because we set
        # allow_empty_selection = True.
        self.assertEqual(len(list_adapter.selection), 0)
        list_adapter.check_for_empty_selection()

        # Nothing should have changed by that call, because still we have
        # allow_empty_selection = True, so no action in that check.
        self.assertEqual(len(list_adapter.selection), 0)

        # Still no selection, but triggering a selection should make len = 1.
        # So, first we need to select the associated data item.
        self.assertEqual(fruit_data_items[0].name, 'Apple')
        fruit_data_items[0].is_selected = True
        apple = list_view.adapter.get_view(0)
        self.assertEqual(apple.text, 'Apple')
        self.assertTrue(apple.is_selected)
        self.assertEqual(len(list_adapter.selection), 1)
コード例 #27
0
class DeleteProfileScreen(Screen):
    user_dict = {}
    userKey = ListProperty()
    users_list = ListView()
    sel_usr = StringProperty()

    def __init__(self, **kwargs):
        super(DeleteProfileScreen, self).__init__(**kwargs)
        self.sel_usr = '******'

    def on_enter(self, *args):
        print('on_enter called for delete profile screen')
        del self.userKey[:]
        self.user_dict.clear()
        self.userKey = fn.reload_dictionary(self.user_dict)
        if self.userKey != None:
            list_adapter = ListAdapter(data=self.userKey, selection_mode='single', allow_empty_selection=False, cls=myListItemButton)
        self.sel_usr = self.userKey[0]
        self.users_list.adapter = list_adapter
        self.users_list.adapter.bind(on_selection_change=self.callback)
        self.users_list._trigger_reset_populate()

    def callback(self, adapter):
        if len(adapter.selection) == 0:
            self.sel_usr = '******'
            print "No selected item"
        else:
            print adapter.selection[0].text
            self.sel_usr = adapter.selection[0].text
コード例 #28
0
    def init_selector(self, _height):
        """ Initializer the selector
        :param _height: Height of the selector
        :return: An instance of the selector
        """

        _list_adapter = ListAdapter(data=self.get_values_hosts(),
                           args_converter=list_item_args_converter,
                           cls=ListItemButton,
                           selection_mode='single',
                           allow_empty_selection=False)
        _selector = ListView(adapter=_list_adapter)
        _selector.height = _height

        _selector.adapter.bind(on_selection_change= self.set_selector_text)
        return _selector
コード例 #29
0
    def __init__(self, **kwargs):
        super(MainView, self).__init__(**kwargs)

        data_items = []
        data_items.append(DataItem())
        data_items.append(DataItem())
        data_items.append(DataItem())

        list_item_args_converter = lambda row_index, obj: {
            'text': obj.name,
            'size_hint_y': None,
            'height': 25
        }

        self.list_adapter = \
                ListAdapter(data=data_items,
                            args_converter=list_item_args_converter,
                            selection_mode='single',
                            propagate_selection_to_data=False,
                            allow_empty_selection=False,
                            cls=ListItemButton)

        self.list_view = ListView(adapter=self.list_adapter)

        self.add_widget(self.list_view)

        self.toggle = 'adding'

        Clock.schedule_interval(self.update_list_data, 1)
コード例 #30
0
    def view_student(self):
        self.update_info()
        if self.grade12s_list.adapter.selection:
            # getting selected item name
            selection = self.grade12s_list.adapter.selection[0].text

            # creating layout for tab
            content = GridLayout(cols=2)
            col1 = GridLayout(cols=1)
            col2 = GridLayout(cols=1)
            col1.add_widget(Label(text="Student Name: " + selection))
            for i in self.grade12_list:
                if i[1] == selection:
                    col1.add_widget(Label(text="Grade: " + i[2]))
                    col1.add_widget(Label(text="Student ID: " + str(i[4])))
                    col1.add_widget(
                        Label(text="Accumulated Points: " + str(i[3])))
                    simple_list_adapter = SimpleListAdapter(
                        data=i[6].split('.')[1:], cls=Label)

            col2.add_widget(
                Label(text='Student Rewards History',
                      size_hint_y=None,
                      height=40))
            activity_history = ListView(adapter=simple_list_adapter)
            col2.add_widget(activity_history)
            content.add_widget(col1)
            content.add_widget(col2)
            popup = Popup(title=selection,
                          content=content,
                          size_hint=(None, None),
                          size=(800, 500))
            popup.open()
コード例 #31
0
    def __init__(self, **kwargs):
        kwargs['cols'] = 2
        super(MainView, self).__init__(**kwargs)

        list_view = ListView(item_strings=[str(index) for index in range(100)])

        self.add_widget(list_view)
コード例 #32
0
ファイル: gzuro.py プロジェクト: dduong42/gzuro
    def __init__(self, *, choices, default):
        self._selection_callbacks = []

        class _ListAdapter(ListAdapter):
            selected = StringProperty('')

            def on_selection(_self, item, value):
                if value:
                    _self.selected = value[0].text
                    for callback in self._selection_callbacks:
                        callback()

            def select(self, choice):
                v = self.get_view(self.data.index(choice))
                if v is not None:
                    self.handle_selection(v)

        self._adapter = _ListAdapter(
            data=choices,
            args_converter=_args_converter,
            cls=ListItemButton,
            selection_mode='single',
            allow_empty_selection=False,
        )
        self._element = ListView(adapter=self._adapter)
        self._adapter.select(default)
コード例 #33
0
    def __init__(self, **kwargs):
        super(MapChoice, self).__init__(**kwargs)

        self.root = Builder.load_string(kv)
        self.map_items = kwargs.get('map_items', [])

        list_item_args_converter = \
                lambda row_index, selectable: {'name': selectable.name,
                                               'max_zoom': selectable.max_zoom,
                                               'description': selectable.description,
                                               'size_hint_y': None,
                                               'is_selected': selectable.is_selected,
                                               'select_change_callback': selectable.on_selection_change,
                                               'calibration_callback': selectable.on_calibration,
                                               'index': row_index}

        map_list_adapter = \
            ListAdapter(data=self.map_items,
                        args_converter=list_item_args_converter,
                        selection_mode='single',
                        allow_empty_selection=False,
                        template='CustomListItem')

        list_view = ListView(adapter=map_list_adapter)

        # map_list_adapter.bind(on_selection_change=self.callback_function)

        self.add_widget(list_view)
コード例 #34
0
ファイル: test_uix_listview.py プロジェクト: edthedev/kivy
    def test_list_view_with_list_of_integers_scrolling(self):

        data = [{"text": str(i), "is_selected": False} for i in xrange(100)]

        args_converter = lambda row_index, rec: {"text": rec["text"], "size_hint_y": None, "height": 25}

        list_adapter = ListAdapter(
            data=data,
            args_converter=args_converter,
            selection_mode="single",
            allow_empty_selection=False,
            cls=ListItemButton,
        )

        list_view = ListView(adapter=list_adapter)

        list_view.scroll_to(20)
        self.assertEqual(list_view._index, 20)
コード例 #35
0
ファイル: LabpiReceptor.py プロジェクト: comobiophys/vilas
    def __init__(self, *args, **kwargs):
        super(ReceptorScreen, self).__init__(*args, **kwargs)
        list_item_args_converter = lambda row_index, obj: {'root_path': obj.root_path, 'item_id': obj.item_id, 'text': obj.text, 'pdbFile': obj.pdbFile, 'list_id': obj.list_id, 'number_chain': obj.number_chain, 'zoom_item': obj.zoom_item}

        self.list_adapter_receptor = ReceptorAdapter(data=[],
                            args_converter=list_item_args_converter,
                            template='GroupListItem')
        self.recetor_lv = ListView(adapter=self.list_adapter_receptor,
                                divider_height= 1,
                                id='receptor_lv')
        self.receptorList.add_widget(self.recetor_lv)
コード例 #36
0
    def __init__(self, **kwargs):
        self.scdata = list()
        self.orientation = 'vertical'
        # FOR NETWORK
        Active.scanList.clear()
        try:
            Active.scanList = Active.scan_task.get_scan_list(Active.client)
        except ScanException as se:
            popup = Popup(size_hint=(None, None), size=(400, 150))
            popup.add_widget(Label(text=se.value))
            popup.bind(on_press=popup.dismiss)
            popup.title = se.title
            popup.open()
            return
        except EmptyListException as ee:
            global empty
            if empty is 0:
                empty = 1
                popup = Popup(size_hint=(None, None), size=(400, 150))
                popup.add_widget(Label(text=ee.value))
                popup.bind(on_press=popup.dismiss)
                popup.title = ee.title
                popup.open()
        for x in range(0, len(Active.scanList)):
            self.scdata.append({'path': Active.scanList[x].path,
                                'options': Active.scanList[x].options})

        self.list_adapter = ListAdapter(data=self.scdata,
                                        args_converter=self.formatter,
                                        cls=ScCompositeListItem,
                                        selection_mode='single',
                                        allow_empty_selection=False)

        super(ScannerViewModal, self).__init__(**kwargs)
        self.list_view = ListView(adapter=self.list_adapter)
        self.add_widget(HeaderBox())
        self.add_widget(self.list_view)
        if len(self.scdata) is 0:
            detail_view = ScDetailView(sc_name="List is empty", size_hint=(.6, 1.0))
        else:
            detail_view = ScDetailView(sc_name=self.list_adapter.selection[0].text, size_hint=(.6, 1.0))

        self.list_adapter.bind(
            on_selection_change=detail_view.sc_changed)
        self.add_widget(detail_view)
        Clock.schedule_interval(self.callback, 60)
        Clock.schedule_interval(self.callback2, 5)
コード例 #37
0
    def __init__(self, **kwargs):
        self.qrdata = list()
        # FOR NETWORK
        Active.qrList.clear()
        try:
            Active.qrList = Active.qr_task.get_qr_list(Active.client)
        except QrException as qr:
            popup = Popup(size_hint=(None, None), size=(400, 150))
            popup.add_widget(Label(text=qr.value))
            popup.bind(on_press=popup.dismiss)
            popup.title = qr.title
            popup.open()
        except EmptyListException as ee:
            global empty
            if empty is 0:
                empty = 1
                popup = Popup(size_hint=(None, None), size=(400, 150))
                popup.add_widget(Label(text=ee.value))
                popup.bind(on_press=popup.dismiss)
                popup.title = ee.title
                popup.open()
        for x in range(0, len(Active.qrList)):
            self.qrdata.append({'filename': Active.qrList[x].f_name,
                                'old_path': Active.qrList[x].o_path})

        self.list_adapter = ListAdapter(data=self.qrdata,
                                        args_converter=self.formatter,
                                        selection_mode='single',
                                        allow_empty_selection=False,
                                        cls=QrCompositeListItem)

        super(QuarantineViewModal, self).__init__(**kwargs)
        self.list_view = ListView(adapter=self.list_adapter)
        self.add_widget(self.list_view)
        if len(self.qrdata) is 0:
            detail_view = QrDetailView(qr_name="List is empty", size_hint=(.6, 1.0))
        else:
            detail_view = QrDetailView(qr_name=self.list_adapter.selection[0].text,
                                       size_hint=(.6, 1.0))

        self.list_adapter.bind(
            on_selection_change=detail_view.qr_changed)
        self.add_widget(detail_view)
        Clock.schedule_interval(self.callback, 60)
        Clock.schedule_interval(self.callback2, 5)
コード例 #38
0
ファイル: main.py プロジェクト: spillz/37.6
    def __init__(self):
        super(GameMenu, self).__init__()
        self.w_start_button.bind(on_release = self.start_game)
        self.w_join_button.bind(on_release = self.find_network_game)

        args_converter = lambda row_index, rec: {'text': '%s on %s:%s'%(rec['game_name'],str(rec['ip_address']),str(rec['port'])) ,
            'size_hint_y': 0.1}
        adapter = ListAdapter(data = [],
            args_converter=args_converter,
            cls=ListItemButton,
            selection_mode='single',
            allow_empty_selection=True)
        self.w_join_game_list_view = ListView(size_hint = (0.6, 0.6), pos_hint = {'center_x':0.5, 'center_y':0.6},
                    adapter = adapter)
        self.w_join_game_box.add_widget(self.w_join_game_list_view)
        self.w_join_game_list_view.adapter.bind(on_selection_change = self.network_game_join)

        self.player_spec = []
        self.server = None
        self.disconnected = False
コード例 #39
0
ファイル: LabpiReceptor.py プロジェクト: comobiophys/vilas
class ReceptorScreen(Screen):
    root_path = os.path.dirname(__file__)

    pymol = ObjectProperty(None)
    list_adapter_receptor = ObjectProperty(None)

    receptorList = ObjectProperty(None)
    recetor_lv = ListView()

    def __init__(self, *args, **kwargs):
        super(ReceptorScreen, self).__init__(*args, **kwargs)
        list_item_args_converter = lambda row_index, obj: {'root_path': obj.root_path, 'item_id': obj.item_id, 'text': obj.text, 'pdbFile': obj.pdbFile, 'list_id': obj.list_id, 'number_chain': obj.number_chain, 'zoom_item': obj.zoom_item}

        self.list_adapter_receptor = ReceptorAdapter(data=[],
                            args_converter=list_item_args_converter,
                            template='GroupListItem')
        self.recetor_lv = ListView(adapter=self.list_adapter_receptor,
                                divider_height= 1,
                                id='receptor_lv')
        self.receptorList.add_widget(self.recetor_lv)

    def setupView(self):
        data = []
        global ItemId
        ItemId = 0
        pdbFiles = Variable.parsepdb.Receptors
        for pdbFile in pdbFiles:
            ItemId+=1

            filename = os.path.basename(pdbFile.file_path)
            chainname = os.path.splitext(filename)[0]
            
            # zoom to recepter
            pymol_thread = Thread(target = self.pymol_zoom, args = (chainname, ))
            pymol_thread.start()

            # Find number of chain avarible for kivy height
            number_chain = 0
            for chain in pdbFile.chains:
                if(chain.is_selected):
                    number_chain += 1
                    pymol_thread = Thread(target = self.pymol_spectrum, args = (chain, chainname, chain.resindices, ))
                    pymol_thread.start()

            filename = os.path.basename(pdbFile.file_path)
            data.append(DataItem(root_path=self.root_path, item_id=ItemId, text=filename, pdbFile=pdbFile , list_id = 'receptor_lv', number_chain = number_chain, zoom_item = self.zoom_item))

        ligands = Variable.parsepdb.Ligands
        for ligand in ligands:
            filename = os.path.basename(ligand.file_path)
            chainname = os.path.splitext(filename)[0]
            
            chains = ligand.chains
            for chain in chains:
                print str(chain.chain_view)
                pymol_thread = Thread(target = self.pymol_hide, args = (chain, chainname, ))
                pymol_thread.start()

        self.recetor_lv.adapter.data = data
        self.recetor_lv._trigger_reset_populate()

    def set_pymol(self, pym):
        self.pymol = pym
        self.list_adapter_receptor.set_data(self.pymol)

    def pymol_zoom(self, chainname):
        self.pymol.cmd.zoom(chainname)

    def pymol_spectrum(self, chain, chainname, value):
        if chain.chain_type == 'protein':
            # self.pymol.cmd.color('gray', str(chain.chain_view) + ' & ' + chainname + '& resi '+str(chain.chain_view.getResnums()[0])+'-'+str(chain.chain_view.getResnums()[len(chain.chain_view.getResnums())-1]) ) 
            self.pymol.cmd.color('gray', str(chain.chain_view) + ' & ' + chainname)
            self.pymol.cmd.spectrum('count', 'rainbow', str(chain.chain_view) + ' & ' + chainname +' & resi '+str(value))
        else:
            self.pymol.cmd.hide('sticks', 'resname ' + str(chain.chain_view.getResnames()[0]) + ' & ' + chainname)

    def pymol_hide(self, chain, chainname):
        if chain.chain_type == 'protein':
            self.pymol.cmd.hide('cartoon', str(chain.chain_view) + ' & ' + chainname)
        else:
            self.pymol.cmd.hide('sticks', 'resname ' + str(chain.chain_view.getResnames()[0]) + ' & ' + chainname)

    def zoom_item(self, pdbFile):
        filename = os.path.basename(pdbFile.file_path)
        chainname = os.path.splitext(filename)[0]
        self.pymol.cmd.zoom(chainname)    
コード例 #40
0
class ScannerViewModal(BoxLayout):

    ## Constructor
    # @exception ScanException
    # @exception EmptyListException
    def __init__(self, **kwargs):
        self.scdata = list()
        self.orientation = 'vertical'
        # FOR NETWORK
        Active.scanList.clear()
        try:
            Active.scanList = Active.scan_task.get_scan_list(Active.client)
        except ScanException as se:
            popup = Popup(size_hint=(None, None), size=(400, 150))
            popup.add_widget(Label(text=se.value))
            popup.bind(on_press=popup.dismiss)
            popup.title = se.title
            popup.open()
            return
        except EmptyListException as ee:
            global empty
            if empty is 0:
                empty = 1
                popup = Popup(size_hint=(None, None), size=(400, 150))
                popup.add_widget(Label(text=ee.value))
                popup.bind(on_press=popup.dismiss)
                popup.title = ee.title
                popup.open()
        for x in range(0, len(Active.scanList)):
            self.scdata.append({'path': Active.scanList[x].path,
                                'options': Active.scanList[x].options})

        self.list_adapter = ListAdapter(data=self.scdata,
                                        args_converter=self.formatter,
                                        cls=ScCompositeListItem,
                                        selection_mode='single',
                                        allow_empty_selection=False)

        super(ScannerViewModal, self).__init__(**kwargs)
        self.list_view = ListView(adapter=self.list_adapter)
        self.add_widget(HeaderBox())
        self.add_widget(self.list_view)
        if len(self.scdata) is 0:
            detail_view = ScDetailView(sc_name="List is empty", size_hint=(.6, 1.0))
        else:
            detail_view = ScDetailView(sc_name=self.list_adapter.selection[0].text, size_hint=(.6, 1.0))

        self.list_adapter.bind(
            on_selection_change=detail_view.sc_changed)
        self.add_widget(detail_view)
        Clock.schedule_interval(self.callback, 60)
        Clock.schedule_interval(self.callback2, 5)

    ## Callback on clock schedule to update list
    def callback(self, dt):
        self.update_list()

    ## Callback on clock schedule to update list
    def callback2(self, dt):
        global update
        if update != 0:
            update = 0
            Clock.schedule_once(lambda dt: self.update_list(), 0.1)
        if Active.changed['sc'] != 0:
            Active.changed['sc'] = 0
            Clock.schedule_once(lambda dt: self.update_list(), 0.1)

    ## Updates the Scanner list
    # @exception ScanException
    # @exception EmptyListException
    def update_list(self):
        try:
            Active.scanList = Active.scan_task.get_scan_list(Active.client)
        except ScanException as se:
            popup = Popup(size_hint=(None, None), size=(400, 150))
            popup.add_widget(Label(text=se.value))
            popup.bind(on_press=popup.dismiss)
            popup.title = se.title
            popup.open()
            return
        except EmptyListException as ee:
            global empty
            if empty is 0:
                empty = 1
                popup = Popup(size_hint=(None, None), size=(400, 150))
                popup.add_widget(Label(text=ee.value))
                popup.bind(on_press=popup.dismiss)
                popup.title = ee.title
                popup.open()
        self.scdata.clear()
        for x in range(0, len(Active.scanList)):
            self.scdata.append({'path': Active.scanList[x].path,
                              'options': Active.scanList[x].options})
        self.list_adapter.data = self.scdata
        if hasattr(self.list_view, '_reset_spopulate'):
            self.list_view._reset_spopulate()

    ## The args converter
    def formatter(self, rowindex, scdata):
        return {'text': scdata['path'],
                'size_hint_y': None,
                'height': 50,
                'cls_dicts': [{'cls': ListItemButton,
                               'kwargs': {'text': scdata['path'],
                                          'size_hint_x': 0.5}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['BR_S']) else False,
                                          'size_hint_x': 0.1}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['DUP_S']) else False,
                                          'size_hint_x': 0.1}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['DUP_F']) else False,
                                          'size_hint_x': 0.1}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['INTEGRITY']) else False,
                                          'size_hint_x': 0.1}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['CL_TEMP']) else False,
                                          'size_hint_x': 0.1}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['BACKUP_OLD']) else False,
                                          'size_hint_x': 0.1}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['DEL_F_OLD']) else False,
                                          'size_hint_x': 0.1}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['BACKUP']) else False,
                                          'size_hint_x': 0.1}},
                              {'cls': ScCheckBox,
                               'kwargs': {'disabled': True,
                                          'active': True if bool(scdata['options']['DEL_F_SIZE']) else False,
                                          'size_hint_x': 0.1}}]}
コード例 #41
0
ファイル: main.py プロジェクト: spillz/37.6
class GameMenu(ScreenManager):
    player_count = NumericProperty()
    players = ListProperty()
    disconnected = BooleanProperty()
    w_game = ObjectProperty()
    w_start_button = ObjectProperty()
    w_join_button = ObjectProperty()
    w_join_game_box = ObjectProperty()
    w_join_game_adapter = ObjectProperty()

    def __init__(self):
        super(GameMenu, self).__init__()
        self.w_start_button.bind(on_release = self.start_game)
        self.w_join_button.bind(on_release = self.find_network_game)

        args_converter = lambda row_index, rec: {'text': '%s on %s:%s'%(rec['game_name'],str(rec['ip_address']),str(rec['port'])) ,
            'size_hint_y': 0.1}
        adapter = ListAdapter(data = [],
            args_converter=args_converter,
            cls=ListItemButton,
            selection_mode='single',
            allow_empty_selection=True)
        self.w_join_game_list_view = ListView(size_hint = (0.6, 0.6), pos_hint = {'center_x':0.5, 'center_y':0.6},
                    adapter = adapter)
        self.w_join_game_box.add_widget(self.w_join_game_list_view)
        self.w_join_game_list_view.adapter.bind(on_selection_change = self.network_game_join)

        self.player_spec = []
        self.server = None
        self.disconnected = False

    def find_network_game(self, *args):
        print('looking for network games')
        import msocket
        self.w_join_game_list_view.adapter.data = []
        self.server = msocket.BroadcastClient(game_id, BROADCAST_PORT, callback = self.network_broadcaster_callback)
        self.current = 'join_game'

    def stop_server(self):
        if self.server is not None:
            self.server.stop()
            self.server = None

    def network_broadcaster_callback(self, *args):
        Clock.schedule_once(functools.partial(self.network_game_found, *args))

    def network_game_found(self, *args):
        (ip, bport), (game_id, game_name, gport), dt = args
        data = self.w_join_game_list_view.adapter.data[:]
        data.append({'ip_address': ip, 'game_name': game_name, 'port': gport})
        self.w_join_game_list_view.adapter.data = data
        self.w_join_game_list_view.populate()

    def network_game_join(self, adapter):
        if len(adapter.selection) == 0:
            return
        sel = adapter.selection[0]
        data = adapter.data[sel.index]
        gname = data['game_name']
        ip = data['ip_address']
        gport = data['port']
        import msocket
        self.stop_server()
        try:
            self.server = msocket.TurnBasedClient(game_id, gname, ip, gport, self.server_callback)
        except:
            #TODO: NOTIFY USER THAT CLIENT COULDN'T CONNECT
            return
        self.disconnected = False
        self.server.send('hello',None)
    
    def start_network_server(self):
        import msocket
        self.server = msocket.TurnBasedServer(game_id, game_name, BROADCAST_PORT, GAME_PORT, self.num_network_players, callback = self.server_callback)
        self.disconnected = False

    def server_callback(self, *args):
        Clock.schedule_once(functools.partial(self.server_msg, *args))
        
    def server_msg(self, *args):
        msg, data, dt = args
        board = self.w_game.children[0]
        if msg == 'players_joined': #all players have joined
            net_players = [x for x in range(self.player_count) if self.players[x]==2]
            self.server.queue.put(('player_ids',net_players))
            self.start_network_game(self.player_spec)
        elif msg == 'hello': #remote player says hello, send the initial game data
            player_id, data = data
            players_id = [x for x in range(len(board.players))]
            board.players[player_id].queue.put(('s_hello', (player_id, players_id)))
        elif msg == 's_hello': #data contains this players id and a list of player id's in turn order
            player_id, players_id = data
            spec = []
            for x in range(len(players_id)):
                ps = PlayerSpec('Player '+str(x), color_lookup[x], 0 if players_id[x] == player_id else 2)
                spec.append(ps)
            self.start_network_game(spec)
        elif msg == 'select': #player wants to select a die
            player_id, (pid, die_num) = data
            p = board.players[pid]
            die = p.dice[die_num]
            board.select_die(die)
            #self.server.send(player_id, True, die_num, die.value)
        elif msg == 's_select': #notify player whether they have selected a die and the roll result
            player_id, die_num, roll_value = data
            p = board.players[player_id]
            die = p.dice[die_num]
            board.select_die(die, roll_value)
        elif msg == 'place': #player wants to place a die
            player_id, (pid, hex_pos) = data
            t = board.tiles[hex_pos]
            board.place_die(t)
            #self.server.send(True, hex_pos)
        elif msg == 's_place': #notify player whether the die has been placed
            success, hex_pos = data
            t = board.tiles[hex_pos]
            board.place_die(t, False)
        elif msg == 's_restart': #resposne to the game restart
            #    data is success
            self.start_network_game()
        elif msg == 's_quitgame': #response to the game quit
            #    data is success
            self.server.stop()
            self.server = None
            self.current = 'main'
        elif msg == 'connection_error':
            board.w_state_label.color = white
#            board.w_state_label.bg_color = grey
            board.w_state_label.text = 'Disconnected - game over'
            board.game_over = True
            self.server = None
            self.disconnected = True

    def start_network_game(self, spec = None):
        if spec is not None:
            self.player_spec = spec
        board = self.w_game.children[0]    
        board.server = self.server
        board.setup_game(self.player_spec)
        board.start_game()
        self.current = 'game'
        try:
            net_players = [x for x in range(self.player_count) if self.players[x]==2]
            for x in range(len(net_players)):
                board.players[net_players[x]].queue = self.server.players[x].queue
        except AttributeError:
            pass

    def restart_game(self):
        if self.disconnected:
            return False
        if self.server is not None:
            try:
                self.server.notify_clients('s_restart',None)
            except AttributeError:
                return False
        board = self.w_game.children[0]    
        board.setup_game(self.player_spec)
        board.start_game()
        try:
            net_players = [x for x in range(self.player_count) if self.players[x]==2]
            for x in range(len(net_players)):
                board.players[net_players[x]].queue = self.server.players[x].queue
        except AttributeError:
            pass
        self.current = 'game'
        
    def join_game(self, *args):
        pass

    def start_game(self, *args):
        self.player_spec = []
        self.num_network_players = 0
        for x in range(self.player_count):
            ps = PlayerSpec('Player '+str(x+1), color_lookup[x], self.players[x])
            if ps.type == 2:
                self.num_network_players += 1
            self.player_spec.append(ps)
        if self.num_network_players > 0:
            self.start_network_server()
            self.current = 'host_wait'
        else:
            board = self.w_game.children[0]
            board.server = None
            board.setup_game(self.player_spec)
            board.start_game()
            self.current = 'game'
コード例 #42
0
class QuarantineViewModal(BoxLayout):

    ## Constructon
    # @exception QrException
    # @exception EmptyListException
    def __init__(self, **kwargs):
        self.qrdata = list()
        # FOR NETWORK
        Active.qrList.clear()
        try:
            Active.qrList = Active.qr_task.get_qr_list(Active.client)
        except QrException as qr:
            popup = Popup(size_hint=(None, None), size=(400, 150))
            popup.add_widget(Label(text=qr.value))
            popup.bind(on_press=popup.dismiss)
            popup.title = qr.title
            popup.open()
        except EmptyListException as ee:
            global empty
            if empty is 0:
                empty = 1
                popup = Popup(size_hint=(None, None), size=(400, 150))
                popup.add_widget(Label(text=ee.value))
                popup.bind(on_press=popup.dismiss)
                popup.title = ee.title
                popup.open()
        for x in range(0, len(Active.qrList)):
            self.qrdata.append({'filename': Active.qrList[x].f_name,
                                'old_path': Active.qrList[x].o_path})

        self.list_adapter = ListAdapter(data=self.qrdata,
                                        args_converter=self.formatter,
                                        selection_mode='single',
                                        allow_empty_selection=False,
                                        cls=QrCompositeListItem)

        super(QuarantineViewModal, self).__init__(**kwargs)
        self.list_view = ListView(adapter=self.list_adapter)
        self.add_widget(self.list_view)
        if len(self.qrdata) is 0:
            detail_view = QrDetailView(qr_name="List is empty", size_hint=(.6, 1.0))
        else:
            detail_view = QrDetailView(qr_name=self.list_adapter.selection[0].text,
                                       size_hint=(.6, 1.0))

        self.list_adapter.bind(
            on_selection_change=detail_view.qr_changed)
        self.add_widget(detail_view)
        Clock.schedule_interval(self.callback, 60)
        Clock.schedule_interval(self.callback2, 5)

    ## Callback on clock schedule to update list
    def callback(self, dt):
        self.update_list()

    ## Callback on clock schedule to update list
    def callback2(self, dt):
        global update
        if update != 0:
            update = 0
            Clock.schedule_once(lambda dt: self.update_list(), 0.1)
        if Active.changed['qr'] != 0:
            Active.changed['qr'] = 0
            Clock.schedule_once(lambda dt: self.update_list(), 1)

    ## Updates the Quarantine list
    # @exception QrException
    # @exception EmptyListException
    def update_list(self):
        try:
            Active.qrList = Active.qr_task.get_qr_list(Active.client)
        except QrException as qr:
            popup = Popup(size_hint=(None, None), size=(400, 150))
            popup.add_widget(Label(text=qr.value))
            popup.bind(on_press=popup.dismiss)
            popup.title = qr.title
            popup.open()
            return
        except EmptyListException as ee:
            global empty
            if empty is 0:
                empty = 1
                popup = Popup(size_hint=(None, None), size=(400, 150))
                popup.add_widget(Label(text=ee.value))
                popup.bind(on_press=popup.dismiss)
                popup.title = ee.title
                popup.open()
        finally:
            self.qrdata.clear()
            for x in range(0, len(Active.qrList)):
                self.qrdata.append({'filename': Active.qrList[x].f_name,
                                  'old_path': Active.qrList[x].o_path})
            self.list_adapter.data = self.qrdata
            if hasattr(self.list_view, '_reset_spopulate'):
                self.list_view._reset_spopulate()

    ## The args converter
    def formatter(self, rowindex, qr_data):
        return {'text': qr_data['filename'],
                'size_hint_y': None,
                'height': 50,
                'cls_dicts': [{'cls': ListItemButton,
                               'kwargs': {'text': qr_data['filename']}},
                              {'cls': ListItemLabel,
                               'kwargs': {'text': "Old Path:"}},
                              {'cls': ListItemLabel,
                               'kwargs': {'text': qr_data['old_path']}}]}
コード例 #43
0
class DataModel(GridLayout):
    """
    Uses :class:`CompositeListItem` for list item views comprised by two
    :class:`ListItemButton`s and one :class:`ListItemLabel`. Illustrates how
    to construct the fairly involved args_converter used with
    :class:`CompositeListItem`.
    """
    minval = NumericProperty(0)
    maxval = NumericProperty(0)
    simulate = False
    time_interval = 1
    dirty_thread = False
    dirty_model = False
    simulate_timer = None
    simulate = False
    dispatcher = None
    list_view = None
    _parent = None
    is_simulating = False
    blockname = "<BLOCK_NAME_NOT_SET>"

    def __init__(self, **kwargs):
        kwargs['cols'] = 2
        kwargs['size_hint'] = (1.0, 1.0)
        super(DataModel, self).__init__(**kwargs)
        self.init()

    def init(self, simulate=False, time_interval=1, **kwargs):
        """
        Initializes Datamodel

        """
        self.minval = kwargs.get("minval", self.minval)
        self.maxval = kwargs.get("maxval", self.maxval)
        self.blockname = kwargs.get("blockname", self.blockname)
        self.clear_widgets()
        self.simulate = simulate
        self.time_interval = time_interval
        dict_adapter = DictAdapter(data={},
                                   args_converter=self.arg_converter,
                                   selection_mode='single',
                                   allow_empty_selection=True,
                                   cls=CompositeListItem
                                   )

        # Use the adapter in our ListView:
        self.list_view = ListView(adapter=dict_adapter)
        self.add_widget(self.list_view)
        self.dispatcher = UpdateEventDispatcher()
        self._parent = kwargs.get('_parent', None)
        self.simulate_timer = BackgroundJob(
            "simulation",
            self.time_interval,
            self._simulate_block_values
        )

    def clear_widgets(self, make_dirty=False, **kwargs):
        """
        Overidden Clear widget function used while deselecting/deleting slave
        :param make_dirty:
        :param kwargs:
        :return:
        """
        if make_dirty:
            self.dirty_model = True
        super(DataModel, self).clear_widgets(**kwargs)

    def reinit(self, **kwargs):
        """
        Re-initializes Datamodel on change in model configuration from settings
        :param kwargs:
        :return:
        """
        self.minval = kwargs.get("minval", self.minval)
        self.maxval = kwargs.get("maxval", self.maxval)
        time_interval = kwargs.get("time_interval", None)
        try:
            if time_interval and int(time_interval) != self.time_interval:
                self.time_interval = time_interval
                if self.is_simulating:
                    self.simulate_timer.cancel()
                self.simulate_timer = BackgroundJob("simulation", self.time_interval,
                                                     self._simulate_block_values)
                self.dirty_thread = False
                self.start_stop_simulation(self.simulate)
        except ValueError:
            Logger.debug("Error while reinitializing DataModel %s" % kwargs)

    def update_view(self):
        """
        Updates view with listview again
        :return:
        """
        if self.dirty_model:
            self.add_widget(self.list_view)
            self.dirty_model = False

    def arg_converter(self, index, data):
        """
        arg converter to convert data to list view
        :param index:
        :param data:
        :return:
        """
        _id = self.list_view.adapter.sorted_keys[index]
        return {
            'text': str(_id),
            'size_hint_y': None,
            'height': 30,
            'cls_dicts': [
                {
                    'cls': ListItemButton,
                    'kwargs': {'text': str(_id)}
                },
                {
                    'cls': NumericTextInput,
                    'kwargs': {
                        'data_model': self,
                        'minval': self.minval,
                        'maxval': self.maxval,
                        'text': str(data),
                        'multiline': False,
                        'is_representing_cls': True,

                        
                    }
                },
            ]
        }

    def add_data(self, data, item_strings):
        """
        Adds data to the Data model
        :param data:
        :param item_strings:
        :return:
        """
        self.update_view()
        last_index = len(item_strings)
        if last_index in item_strings:
            last_index = int(item_strings[-1]) + 1
        item_strings.append(last_index)
        self.list_view.adapter.data.update({last_index: data})
        self.list_view._trigger_reset_populate()
        return self.list_view.adapter.data, item_strings

    def delete_data(self, item_strings):
        """
        Delete data from data model
        :param item_strings:
        :return:
        """
        selections = self.list_view.adapter.selection
        items_popped = []
        for item in selections:
            index_popped = item_strings.pop(item_strings.index(int(item.text)))
            data_popped = self.list_view.adapter.data.pop(int(item.text), None)
            self.list_view.adapter.update_for_new_data()
            self.list_view._trigger_reset_populate()
            items_popped.append(index_popped)
        return items_popped,  self.list_view.adapter.data

    def on_selection_change(self, item):
        pass

    def on_data_update(self, index, data):
        """
        Call back function to update data when data is changed in the list view
        :param index:
        :param data:
        :return:
        """
        self.list_view.adapter.data.update({index: data})
        self.list_view._trigger_reset_populate()
        self.dispatcher.dispatch('on_update', self._parent, self.blockname,
                                 self.list_view.adapter.data)

    def refresh(self, data={}):
        """
        Data model refresh function to update when the view when slave is
        selected
        :param data:
        :return:
        """
        self.update_view()
        self.list_view.adapter.data = data
        self.list_view.disabled = False
        self.list_view._trigger_reset_populate()

    def start_stop_simulation(self, simulate):
        """
        Starts or stops simulating data
        :param simulate:
        :return:
        """
        self.simulate = simulate

        if self.simulate:
            if self.dirty_thread:
                self.simulate_timer = BackgroundJob(
                    "simulation",
                    self.time_interval,
                    self._simulate_block_values
                )
            self.simulate_timer.start()
            self.dirty_thread = False
            self.is_simulating = True
        else:
            self.simulate_timer.cancel()
            self.dirty_thread = True
            self.is_simulating = False

    def _simulate_block_values(self):
        if self.simulate:
            data = self.list_view.adapter.data
            if data:
                for index, value in data.items():
                    data[index] = randint(self.minval, self.maxval)
                    print self.minval, self.maxval, data[index]
                self.refresh(data)
                self.dispatcher.dispatch('on_update',
                                         self._parent,
                                         self.blockname,
                                         self.list_view.adapter.data)
コード例 #44
0
ファイル: main.py プロジェクト: engdan77/edoAutoHomeMobile
    def create_button_view(self, dt):
        import json
        import time

        # Make reference to app root widget
        sm = self._app.root

        # Check that JSON been recieved
        if re.match(r'^\{.*\}$', self._app.sm.json_sensors):
            try:
                j = json.loads(self._app.sm.json_sensors)
            except Exception as e:
                self._app.sm.json_sensors = 'Error in JSON'
            else:
                all_devices_boxlayout = BoxLayout(orientation='vertical', spacing=10)
                all_devices_boxlayout.add_widget(Label(text=''))
                all_devices_boxlayout.add_widget(Label(size_hint_y=0.2, text='[color=ff3333]Devices[/color]', font_size=40, markup=True))
                all_devices_boxlayout.add_widget(Label(text=''))
                all_devices_screen = Screen(id='all_devices_buttons', name='all_devices_buttons')
                all_devices_screen.add_widget(all_devices_boxlayout)
                sm.add_widget(all_devices_screen)

                # Bulding new screens for list of devices and sensors based on json
                # For each device create its own Screen
                for device in j.keys():
                    Logger.info("Creating screen for device %s" % (device,))
                    self._app.log_list.append(get_date("Creating screen for device %s" % (device,)))
                    screen_device = Screen(name=device)

                    # Add button for device on all_devices_boxlayout
                    b = Button(text=device)
                    # This will call the function with 'device' as argument to switch Screen
                    b.bind(on_press=partial(self.change_screen, device))
                    all_devices_boxlayout.add_widget(b)

                    # Create Device Screen with sensors
                    box_device = BoxLayout(orientation='vertical', spacing=10)
                    box_device.add_widget(Label(text=''))
                    box_device.add_widget(Label(size_hint_y=0.2, text='[color=ff3333]' + device + '[/color]', font_size=40, markup=True))
                    box_device.add_widget(Label(text=''))

                    # Create Sensor Screen and button on device screen
                    for sensor in j[device]:
                        sensor_name = sensor.keys()[0]
                        sensor_data = sensor[sensor_name]
                        sensor_values = sensor_data['last_records']

                        sensor_dict = updates_to_plots(sensor_values)
                        sensor_plots = sensor_dict['plots']
                        ymin = sensor_dict['min_y']
                        ymax = sensor_dict['max_y']
                        xmin = sensor_dict['min_x']

                        last_date, last_value = sensor_values[-1]

                        # Determine suffix
                        suffix = ' '
                        if re.match(r'.*temp.*', sensor_name, re.IGNORECASE):
                            suffix = u"\u00b0C"
                        if re.match(r'.*humid.*', sensor_name, re.IGNORECASE):
                            suffix = " %"
                        if re.match(r'.*smoke.*', sensor_name, re.IGNORECASE):
                            suffix = " %"
                        if re.match(r'.*stove.*', sensor_name, re.IGNORECASE):
                            suffix = " %"

                        sensor = device + '_' + sensor_name
                        Logger.info(str(sensor))
                        Logger.info("Last data %s %s" % (last_date, last_value))

                        # Create history view
                        screen_sensor_history = Screen(name=device + "_" + sensor_name + "_history")
                        box_sensor_history = BoxLayout(orientation='vertical', spacing=10)
                        box_sensor_history.add_widget(Label(size_hint_y=0.1, text='[color=B6BAB9]' + sensor_name + ' (' + device + ')[/color]', font_size=30, markup=True))

                        # Create history text
                        text_history = []
                        for d, v in sensor_values:
                            text_history.append(str("%s    %s" % (d, v)))

                        # Create left aligned list
                        adapter = SimpleListAdapter(data=text_history, cls=MyLeftAlignedLabel)
                        list_view = ListView(adapter=adapter)
                        # Fix bug with ListView to refresh if required
                        if(hasattr(list_view, '_reset_spopulate')):
                            Logger.info("Refresh list_view")
                            list_view._reset_spopulate()
                        # Add ListView to Sensor History
                        box_sensor_history.add_widget(list_view)
                        back_button = Button(size_hint_y=0.1, font_size=20, text='Back')
                        back_button.bind(on_press=partial(self.change_screen, device + "_" + sensor_name))
                        box_sensor_history.add_widget(back_button)
                        screen_sensor_history.add_widget(box_sensor_history)
                        sm.add_widget(screen_sensor_history)

                        # Create sensor screen
                        screen_sensor = Screen(name=device + "_" + sensor_name)
                        box_sensor = BoxLayout(orientation='vertical')
                        box_sensor.add_widget(Label(size_hint_y=0.1, text='[color=B6BAB9]' + sensor_name + ' (' + device + ')[/color]', font_size=30, markup=True))
                        # Add sensor value
                        box_sensor.add_widget(Label(text=last_value + suffix, font_size=60))
                        # Add sensor date
                        box_sensor.add_widget(Label(size_hint_y=0.1, markup=True, text='[b]Sensor last updated ' + last_date[:-3] + '[/b]\nPolled ' + get_date(None)[:-3], font_size=15))
                        # Add sensor graph
                        Logger.info("Create plot for %s" % (sensor_name,))
                        Logger.info(str(sensor_plots))
                        plot = MeshLinePlot(mode='line_strip', color=[1, 0, 0, 1])
                        plot.points = sensor_plots
                        sensor_graph = Graph(id='plots_' + sensor_name, precision='%0.0f', x_grid_label=True, y_grid_label=True, xmin=xmin, xmax=0, ymin=ymin, ymax=ymax, xlabel='days ago', ylabel=suffix, x_grid=True, y_grid=False, x_ticks_major=1, y_ticks_major=1)
                        sensor_graph.add_plot(plot)
                        box_sensor.add_widget(sensor_graph)

                        # Add buttonbar for sensor
                        box_buttons = BoxLayout(orientation='horizontal')

                        # Create button for history
                        history_button = Button(size_hint_y=0.2, font_size=20, text='History')
                        history_button.bind(on_press=partial(self.change_screen, device + "_" + sensor_name + "_history"))

                        # Create Back button
                        back_button = Button(size_hint_y=0.2, font_size=20, text='Back')
                        back_button.bind(on_press=partial(self.change_screen, device))

                        # Add buttons to row
                        box_buttons.add_widget(back_button)
                        box_buttons.add_widget(history_button)

                        # Add row to screen
                        box_sensor.add_widget(box_buttons)

                        # Add all of it to screen
                        screen_sensor.add_widget(box_sensor)
                        sm.add_widget(screen_sensor)

                        # Create button on device screen
                        button_sensor = Button(text=sensor_name)
                        button_sensor.bind(on_press=partial(self.change_screen, sensor))
                        box_device.add_widget(button_sensor)

                    # Add Device Screen with all sensor buttons to ScreenManager
                    back_button = Button(font_size=20, text='[b]Back[/b]', markup=True)
                    back_button.bind(on_press=partial(self.change_screen, 'all_devices_buttons'))
                    box_device.add_widget(back_button)
                    screen_device.add_widget(box_device)
                    sm.add_widget(screen_device)

                # Adding Back button to Devices screen
                back_button = Button(font_size=20, text='[b]Back[/b]', markup=True)
                back_button.bind(on_press=partial(self.change_screen, 'initial_screen'))
                all_devices_buttonrow = BoxLayout(orientation='horizontal')
                all_devices_buttonrow.add_widget(back_button)
                slide_all_button = ToggleButton(id='slide_all_button', font_size=20, text='Slideshow All Sensors')
                slide_all_button.bind(on_press=partial(self.control_slideshow_all_sensors, slide_all_button))
                all_devices_buttonrow.add_widget(slide_all_button)
                all_devices_boxlayout.add_widget(all_devices_buttonrow)

                # Unschedule timer
                Clock.unschedule(self.create_button_view)
                # Return to buttons of all devices
                sm.current = 'all_devices_buttons'
                # Schedule updates from server
                Clock.schedule_interval(sm.update_views, int(self._app.sm.settings_dict['refresh_time']))

        # Check if failed pause for error before return
        if re.match(r'.*fail.*', self._app.sm.connect_server_status) or re.match(r'.*error.*', self._app.sm.json_sensors):
            Clock.unschedule(self.create_button_view)
            time.sleep(2)
            self.port = self._app.config.get('network', 'port')
            self.server = self._app.config.get('network', 'ip')
            self._app.sm.connect_server_status = "Connecting to %s:%s" % (self.server, self.port)
            sm.current = 'initial_screen'
コード例 #45
0
ファイル: table.py プロジェクト: DevilDante88/MyCogs
    def __init__(self, data_ap, **kwargs):

        super(Table, self).__init__(**kwargs)
        self.app = App.get_running_app()

        ## first check if len data = 0 add label to alert user
        if len(data_ap) is 0:
            self.add_widget(Label(text="No Data", font_size='32dp'))
            return

        ########################
        ## HEADER
        ########################

        self.container_header = GridLayout(cols=3, size_hint_y=None, height=(self.app.row_height*0.55), spacing=10)

        listview_header_widgets = [Label(text="CHUNK"),
                                   Label(text="FOUND"),
                                   Label(text="SCORE",
                                          size_hint_x=0.2)]

        for x in range(3):
            self.container_header.add_widget(listview_header_widgets[x])

        self.add_widget(self.container_header)

        ########################
        ## GRID
        ########################

        self.container_table = GridLayout(cols=2)

        # This is quite an involved args_converter, so we should go through the
        # details. A CompositeListItem instance is made with the args
        # returned by this converter. The first three, text, size_hint_y,
        # height are arguments for CompositeListItem. The cls_dicts list contains
        # argument sets for each of the member widgets for this composite:
        # ListItemButton and ListItemLabel.
        args_converter = \
            lambda row_index, obj: \
                {'text': obj.chunk,
                 'value': obj.chunk,
                 'size_hint_y': None,
                 'height': self.app.row_height * 0.5,
                 'cls_dicts': [{'cls': Cell,
                                'kwargs': {'text': obj.chunk,
                                           'id': obj.chunk}},
                               {'cls': Cell,
                                'kwargs': {'text': obj.found,
                                           'id': obj.chunk,
                                           'is_representing_cls': True}},
                               {'cls': Cell,
                                'kwargs': {'text': str(obj.score),
                                           'id': obj.chunk,
                                           'size_hint_x': 0.2}}]}

        self.list_adapter = ListAdapter(
                                   data=self.first_fill(data_ap),
                                   args_converter=args_converter,
                                   selection_mode='single',
                                   propagate_selection_to_data=True,
                                   allow_empty_selection=False,
                                   cls=CompositeListItem)

        # Use the adapter in our ListView:
        self.list_view = ListView(adapter=self.list_adapter)

        print 'chunck selezionato: ', self.list_adapter.selection[0].children[2].text

        chunk = MarkupLabel(self.list_adapter.selection[0].children[2].text).markup

        print 'selected: ', self.list_adapter.selection[0].children[2].id
        self.detail_view = RowDetailView(chunk=self.list_adapter.selection[0].children[2].id)

        self.list_adapter.bind(on_selection_change=self.detail_view.row_changed)

        self.container_table.add_widget(self.list_view)
        self.add_widget(self.container_table)
        self.add_widget(self.detail_view)
コード例 #46
0
class ListViewModal(BoxLayout):
    ## The data containing clients
    data = ListProperty()

    ## Constructor
    def __init__(self, **kwargs):
        self.data = list()
        for x in range(0, len(Active.cl.c_list)):
            self.data.append({
                'hostname': Active.cl.c_list[x].name,
                'ip': Active.cl.c_list[x].ip
            })
        self.list_adapter = ListAdapter(data=self.data,
                                        args_converter=self.formatter,
                                        cls=ClCompositeListItem,
                                        selection_mode='single',
                                        allow_empty_selection=False)
        super(ListViewModal, self).__init__(**kwargs)
        self.list_view = ListView(adapter=self.list_adapter)
        self.add_widget(self.list_view)
        if len(self.data) is 0:
            detail_view = ClientDetailView(cl_name="List is empty", size_hint=(.6, 1.0))
        else:
            detail_view = ClientDetailView(cl_name=self.list_adapter.selection[0].text,
                                       size_hint=(.6, 1.0))

        self.list_adapter.bind(
            on_selection_change=detail_view.cl_changed)
        self.add_widget(detail_view)
        Clock.schedule_interval(self.callback, 5)

    ## Callback on clock schedule to update list
    def callback(self, dt):
        global update
        if update != 0:
            update = 0
            Clock.schedule_once(lambda dt: self.update_list(), 0.1)
        if Active.changed['cl'] != 0:
            Active.changed['cl'] = 0
            Clock.schedule_once(lambda dt: self.update_list(), 0.1)

    ## The args converter
    def formatter(self, rowindex, data):
        return {'text': data['hostname'],
                'size_hint_y': None,
                'height': 40,
                'cls_dicts': [{'cls': ListItemButton,
                               'kwargs': {'text': data['hostname']}},
                              {'cls': ListItemLabel,
                               'kwargs': {'text': data['ip']}}]}

    ## Updates the Client list
    # @exception QrException
    # @exception EmptyListException
    def update_list(self):
        self.data.clear()
        for x in range(0, len(Active.cl.c_list)):
            self.data.append({
                'hostname': Active.cl.c_list[x].name,
                'ip': Active.cl.c_list[x].ip
            })
        self.list_adapter.data = self.data
        if hasattr(self.list_view, '_reset_spopulate'):
            self.list_view._reset_spopulate()
コード例 #47
0
ファイル: main.py プロジェクト: engdan77/edoAutoHomeMobile
    def update_views(self, dt):
        ''' Method to be scheduled for updating from server '''
        # Poll new JSON data
        Logger.info(str(self._app.connect_to_server()))

        # Clean records in log_screen if too many lines
        if len(self._app.log_list) > 100:
            self._app.log_list.append(get_date("Cleaning old records in log"))
            while len(self._app.log_list) > 100:
                self._app.log_list.pop(0)

        def return_screen_object(screen_name):
            # Iterate through all screens
            found = None
            for current_screen in self._app.sm.screens:
                if current_screen.name == screen_name:
                   found = current_screen
            return found

        # For each device update Screen
        if re.match(r'^\{.*\}$', self._app.sm.json_sensors):
            try:
                j = json.loads(self._app.sm.json_sensors)
            except Exception as e:
                self._app.sm.json_sensors = 'Error in JSON'
            else:
                for device in j.keys():
                    Logger.info("Updating screen for device %s" % (device,))
                    self._app.log_list.append(get_date("Updating screen for device %s" % (device,)))

                    # Create Device Screen with sensors
                    box_device = BoxLayout(orientation='vertical', spacing=10)
                    box_device.add_widget(Label(text=''))
                    box_device.add_widget(Label(size_hint_y=0.2, text='[color=ff3333]' + device + '[/color]', font_size=40, markup=True))
                    box_device.add_widget(Label(text=''))

                    # Create Sensor Screen and button on device screen
                    for sensor in j[device]:
                        sensor_name = sensor.keys()[0]
                        sensor_data = sensor[sensor_name]
                        sensor_values = sensor_data['last_records']

                        sensor_dict = updates_to_plots(sensor_values)
                        sensor_plots = sensor_dict['plots']
                        ymin = sensor_dict['min_y']
                        ymax = sensor_dict['max_y']
                        xmin = sensor_dict['min_x']

                        last_date, last_value = sensor_values[-1]

                        # Determine suffix
                        suffix = ' '
                        if re.match(r'.*temp.*', sensor_name, re.IGNORECASE):
                            suffix = u"\u00b0C"
                        if re.match(r'.*humid.*', sensor_name, re.IGNORECASE):
                            suffix = " %"
                        if re.match(r'.*smoke.*', sensor_name, re.IGNORECASE):
                            suffix = " %"
                        if re.match(r'.*stove.*', sensor_name, re.IGNORECASE):
                            suffix = " %"

                        sensor = device + '_' + sensor_name
                        Logger.info(str(sensor))
                        Logger.info("Last data %s %s" % (last_date, last_value))

                        # Create new history view
                        box_sensor_history = BoxLayout(orientation='vertical', spacing=10)
                        box_sensor_history.add_widget(Label(size_hint_y=0.1, text='[color=B6BAB9]' + sensor_name + ' (' + device + ')[/color]', font_size=30, markup=True))

                        # Create history text
                        text_history = []
                        for d, v in sensor_values:
                            text_history.append(str("%s    %s" % (d, v)))

                        # Create left aligned list
                        adapter = SimpleListAdapter(data=text_history, cls=MyLeftAlignedLabel)
                        list_view = ListView(adapter=adapter)
                        # Fix bug with ListView to refresh if required
                        if(hasattr(list_view, '_reset_spopulate')):
                            Logger.info("Refresh list_view")
                            list_view._reset_spopulate()
                        # Add ListView to Sensor History
                        box_sensor_history.add_widget(list_view)
                        back_button = Button(size_hint_y=0.1, font_size=20, text='Back')
                        back_button.bind(on_press=partial(self.change_screen, device + "_" + sensor_name))
                        box_sensor_history.add_widget(back_button)

                        screen_sensor_history = return_screen_object(device + "_" + sensor_name + '_history')
                        screen_sensor_history.clear_widgets()
                        screen_sensor_history.add_widget(box_sensor_history)
                        screen_sensor = return_screen_object(device + "_" + sensor_name)

                        box_sensor = BoxLayout(orientation='vertical')
                        box_sensor.add_widget(Label(size_hint_y=0.1, text='[color=B6BAB9]' + sensor_name + ' (' + device + ')[/color]', font_size=30, markup=True))
                        # Add sensor value
                        box_sensor.add_widget(Label(text=last_value + suffix, font_size=60))
                        # Add sensor date
                        box_sensor.add_widget(Label(size_hint_y=0.1, markup=True, text='[b]Sensor last updated ' + last_date[:-3] + '[/b]\nPolled ' + get_date(None)[:-3], font_size=15))
                        # Add sensor graph
                        Logger.info("Create plot for %s" % (sensor_name,))
                        Logger.info(str(sensor_plots))
                        plot = MeshLinePlot(mode='line_strip', color=[1, 0, 0, 1])
                        plot.points = sensor_plots
                        sensor_graph = Graph(id='plots_' + sensor_name, precision='%0.0f', x_grid_label=True, y_grid_label=True, xmin=xmin, xmax=0, ymin=ymin, ymax=ymax, xlabel='days ago', ylabel=suffix, x_grid=True, y_grid=False, x_ticks_major=1, y_ticks_major=1)
                        sensor_graph.add_plot(plot)
                        box_sensor.add_widget(sensor_graph)

                        # Add buttonbar for sensor
                        box_buttons = BoxLayout(orientation='horizontal')

                        # Create button for history
                        history_button = Button(size_hint_y=0.2, font_size=20, text='History')
                        history_button.bind(on_press=partial(self.change_screen, device + "_" + sensor_name + "_history"))

                        # Create Back button
                        back_button = Button(size_hint_y=0.2, font_size=20, text='Back')
                        back_button.bind(on_press=partial(self.change_screen, device))

                        # Add buttons to row
                        box_buttons.add_widget(back_button)
                        box_buttons.add_widget(history_button)

                        # Add row to screen
                        box_sensor.add_widget(box_buttons)

                        # Add all of it to screen
                        screen_sensor.clear_widgets()
                        screen_sensor.add_widget(box_sensor)