Python Pile.set_focus方法代码示例

# 需要导入模块: from urwid import Pile [as 别名]
# 或者: from urwid.Pile import set_focus [as 别名]
class WaitFiscalAnswer(Dialog):#{{{

    def __init__(self, filename, title=None, timeout=10, interval=0.1):#{{{
        self.filename = filename
        self.interval = interval
        self.timeout = timeout

        if title is None:
            title = "IMPRIMIENDO"

        msg = Text("Esperando la respuesta de la Impresora Fiscal ...", align='left')
        self.eta = Text("", align='left')

        self.dummy = Text("")
        self.dummy._selectable = True
        self.dummy.keypress = lambda s,k : None

        self.buttons = Columns([
            AttrMap(Button("Seguir esperando", on_press=self.remove_buttons),'dialog.button', 'dialog.button.focus'),
            AttrMap(Button("Cancelar Impresion", on_press=lambda *w: self.quit()), 'dialog.button', 'dialog.button.focus'),
        ], dividechars=1)

        self.content = Pile([
            msg,
            Divider(),
            self.eta,
            self.dummy,
        ])

        self.__super.__init__(
            self.content,
            title=title,
            attr_style='dialog.waitfiscal',
            title_attr_style='dialog.waitfiscal.title',
            height=None,
            width=60,
        )
#}}}
    def run(self):#{{{
        self._start_time = datetime.now()
        self._last_option = time.time()
        return self.__super.run(alarm=(self.interval, self._alarm))
#}}}
    def _alarm(self, main_loop, user_data=None):#{{{
        if not os.path.exists(self.filename):
            self.update_status()
            main_loop.set_alarm_in(self.interval, self._alarm)
            return
        else:
            self.dialog_result = True
            self.quit()
#}}}
    def update_status(self):#{{{
        self.eta.set_text("Tiempo: %s" % get_elapsed_time(self._start_time))
        if type(self.content.widget_list[-1]) is Text:
            if (time.time() - self._last_option) > self.timeout:
                self.add_buttons()
#}}}
    def add_buttons(self):#{{{
        self.content.widget_list[-1] = self.buttons
        self.content.set_focus(self.buttons)
#}}}
    def remove_buttons(self, *btn):#{{{
        self._last_option = time.time()
        self.content.widget_list[-1] = self.dummy
        self.content.set_focus(self.dummy)

# 需要导入模块: from urwid import Pile [as 别名]
# 或者: from urwid.Pile import set_focus [as 别名]

#.........这里部分代码省略.........

        self.pile = Pile([
            username_row,
            Divider(),
            password_row,
        ], focus_item=0)

        self.login_widget = Filler(Columns([Divider(), self.pile, Divider()]))

    def show(self):
        """Show login window"""
        #self.pile.set_focus(0)
        self.clear()
        loop = self.app.loop
        self.overlay.bottom_w = loop.widget
        loop.widget = self.overlay
        if loop.screen.started:
            loop.draw_screen()

    def hide(self):
        """Hide login window"""
        loop = self.app.loop
        loop.widget = self.overlay.bottom_w
        if loop.screen.started:
            loop.draw_screen()

    def login(self, user):
        """
        Login the session, showing all content and hidding login window.
        """
        # connect esc-esc signal to logout
        widget = self.overlay.bottom_w
        widget.orig_keypress = widget.keypress
        widget.keypress = self._wrapped_keypress

        self._last_key_time = time.time()
        self._timeout_sig_id = self.app.loop.set_alarm_in(self.max_time+1,
                                                          self._check_logout)

        if hasattr(widget, 'set_user') and callable(widget.set_user):
            widget.set_user(user)
        self.hide()
        self._emit("login")

    def logout(self):
        """Logout the session, hidding all content and showing login window
        again.
        """
        # disconnect esc-esc signal
        self.app.loop.widget.keypress = self.app.loop.widget.orig_keypress

        self.app.loop.remove_alarm(self._timeout_sig_id)
        self.show()
        self._emit("logout")

    def clear(self):
        self.username_entry.set_edit_text("")
        self.password_entry.set_edit_text("")
        self.pile.set_focus(0)

    def _wrapped_keypress(self, size, key):
        self._last_key_time = time.time()
        if key == 'esc':
            if self._out_count == 1 and (time.time() - self._evt_time) < 1:
                self._out_count = 0
                self._evt_time = 0
                self.logout()
            else:
                self._out_count = 1
                self._evt_time = time.time()
            return None
        else:
            return self.app.loop.widget.orig_keypress(size, key)

    def _username_keypress(self, size, key):
        if key == 'enter':
            key = 'down'
        return self.username_entry.__class__.keypress(self.username_entry, size, key)

    def _password_keypress(self, size, key):
        if key == 'enter':
            password = self.password_entry.get_edit_text()
            username = self.username_entry.get_edit_text()
            self.password_entry.set_edit_text("")
            if password and username:
                user = self.get_user(username, password)
                if user:
                    #self.username_entry.set_edit_text("")
                    self.login(user)
            return
        return self.password_entry.__class__.keypress(self.password_entry, size, key)

    def _check_logout(self, main_loop, user_data=None):
        etime = int(time.time() - self._last_key_time)
        if etime >= self.max_time:
            self.logout()
        else:
            main_loop.remove_alarm(self._timeout_sig_id)
            self._timeout_sig_id = main_loop.set_alarm_in(self.max_time-etime, self._check_logout)
        return False

# 需要导入模块: from urwid import Pile [as 别名]
# 或者: from urwid.Pile import set_focus [as 别名]
class SelectClient(Dialog):

    def __init__(self, title=None, cls=None):
        if cls is None:
            cls = type('Dummy', (object,), {'__init__': lambda *a, **k: None, 'run': lambda *a: None})
        self.cls = cls
        self._obj = None

        _edit_cancel = lambda *w: self.focus_button(1)

        self.codigo_box = MaeterCodeBox(max_length=12, align='right')
        connect_signal(self.codigo_box, 'focus-in', highlight_focus_in),
        connect_signal(self.codigo_box, 'edit-done', self.on_codigo_edit_done)
        connect_signal(self.codigo_box, 'edit-cancel', _edit_cancel)
        connect_signal(self.codigo_box, 'search-client', self.on_client_search)

        self.nombre = Text(u'')

        client_row = Columns([
            ('fixed', 8, AttrMap(Text("Cliente", align='right'), 'dialog.selectdate.label')),
            ('fixed', 6, AttrMap(self.codigo_box, 'dialog.selectdate.input', 'dialog.selectdate.input.focus')),
            AttrMap(self.nombre, 'dialog.selectdate.label'),
        ], dividechars=1)

        self.content = Pile([
            client_row,
            Divider(),
        ])

        buttons = [("Continuar", self.run_list), ("Cancelar", self.quit)]

        self.__super.__init__(self.content, buttons,
                title=title or u'<Falta titulo>',
                height=None,
                width=60,
                attr_style='dialog.selectdate',
                title_attr_style='dialog.selectdate.title')

    def run_list(self, *args):
        if not self._obj:
            self._pile.set_focus(0)
            self.content.set_focus(0)
            return
        subdialog = self.cls(cliente=self._obj)
        self.dialog_result = subdialog.run()
        self.quit()

    def on_codigo_edit_done(self, widget, code):
        if code != u"":
            query = session.query(Cliente).filter(Cliente.codigo==int(code))
            query = query.filter(Cliente.relacion==u"C")
            try:
                self._obj = query.one()
                self.codigo_box.set_edit_text(self._obj.codigo)
                self.nombre.set_text(self._obj.nombre + " - " + self._obj.direccion)
                self.focus_button(0)
            except NoResultFound:
                self._obj = None
                self.nombre.set_text(u"")

    def on_client_search(self, widget, search_by=None, first_key=None):
        response = search_terceros(search_by=search_by, first_key=first_key)
        if response:
            self.codigo_box.set_edit_text(str(response[0].codigo))
            self.nombre.set_text(str(response[0].nombre))
            self.on_codigo_edit_done(self.codigo_box, str(response[0].codigo))
        return None

# 需要导入模块: from urwid import Pile [as 别名]
# 或者: from urwid.Pile import set_focus [as 别名]
class TreePile(WidgetWrap):
    _selectable = True

    def __init__(self, walker, **kwargs):
        if not isinstance(walker, TreeListWalker):
            walker = TreeListWalker(walker)
        self._walker = walker
        self._lines = []
        self.loadlines()
        logging.debug('lines:\n\n%s' % str(self._lines))
        self._pile = Pile(self._lines)
        self.__super.__init__(self._pile)

    def loadlines(self):
        widget, pos = self._walker.get_focus()
        while pos is not None:
            self._lines.append(widget)
            widget, pos = self._walker.get_next(pos)

    # Widget API
    def get_focus(self):
        return self._pile.get_focus()

    def keypress(self, size, key):
        key = self._pile.keypress(size, key)
        if key in ['left', 'right', '[', ']', '-', '+', 'C', 'E']:
            if key == 'left':
                self.focus_parent()
            elif key == 'right':
                self.focus_first_child()
            elif key == '[':
                self.focus_prev_sibling()
            elif key == ']':
                self.focus_next_sibling()
            if isinstance(self._walker, CollapseMixin):
                if key == '-':
                    w, focuspos = self._walker.get_focus()
                    self._walker.collapse(focuspos)
                elif key == '+':
                    w, focuspos = self._walker.get_focus()
                    self._walker.expand(focuspos)
                elif key == 'C':
                    self._walker.collapse_all()
                elif key == 'E':
                    self._walker.expand_all()
            # This is a hack around ListBox misbehaving:
            # it seems impossible to set the focus without calling keypress as
            # otherwise the change becomes visible only after the next render()
            return self._pile.keypress(size, None)
        else:
            return self._pile.keypress(size, key)

    # Tree based focus movement
    def focus_parent(self):
        w, focuspos = self._walker.get_focus()
        parent = self._walker.parent_position(focuspos)
        if parent is not None:
            self._pile.set_focus(parent)

    def focus_first_child(self):
        w, focuspos = self._walker.get_focus()
        child = self._walker.first_child_position(focuspos)
        if child is not None:
            self._outer_list.set_focus(child)

    def focus_next_sibling(self):
        w, focuspos = self._walker.get_focus()
        sib = self._walker.next_sibling_position(focuspos)
        if sib is not None:
            self._outer_list.set_focus(sib)

    def focus_prev_sibling(self):
        w, focuspos = self._walker.get_focus()
        sib = self._walker.prev_sibling_position(focuspos)
        if sib is not None:
            self._outer_list.set_focus(sib)

# 需要导入模块: from urwid import Pile [as 别名]
# 或者: from urwid.Pile import set_focus [as 别名]
class SelectArticlesDateRange(SelectDateRange):#{{{

    def __init__(self, title=None, cls=None):#{{{
        if cls is None:
            cls = type('Dummy', (object,), {'run': lambda *a: None})
        self.cls = cls

        self._desde_err = None
        self._hasta_err = None

        _edit_cancel = lambda *w: self.focus_button(1)
        _edit_ok = lambda *w: self.focus_button(0)
        def _focus_hasta(*w):
            self.content.set_focus(2)

        self.articulos = InputBox()
        self.articulos.filter_input = lambda t: t.upper()
        connect_signal(self.articulos, "edit-done", self.on_articulos_edit_done)
        connect_signal(self.articulos, "edit-cancel", _edit_cancel)

        self.desde = DateSelectorBox(out_fmt="%d/%m/%Y")
        err = ('desde_error', '_desde_err')
        connect_signal(self.desde, 'focus-in', self.on_fecha_focus_in, err)
        connect_signal(self.desde, 'focus-out', self.on_fecha_focus_out, err)
        connect_signal(self.desde, 'edit-cancel', _edit_cancel)
        connect_signal(self.desde, 'edit-done', self.on_fecha_edit_done, err+(_focus_hasta,))
        connect_signal(self.desde, 'bad-date-error', self.on_fecha_error, err)
        self.desde_error = Text("", wrap='clip')

        self.hasta = DateSelectorBox(out_fmt="%d/%m/%Y")
        err = ('hasta_error', '_hasta_err')
        connect_signal(self.hasta, 'focus-in', self.on_fecha_focus_in, err)
        connect_signal(self.hasta, 'focus-out', self.on_fecha_focus_out, err)
        connect_signal(self.hasta, 'edit-cancel', _edit_cancel)
        connect_signal(self.hasta, 'edit-done', self.on_fecha_edit_done, err+(_edit_ok,))
        connect_signal(self.hasta, 'bad-date-error', self.on_fecha_error, err)
        self.hasta_error = Text("", wrap='clip')

        articulos_row = Columns([
            ('fixed', 14, AttrMap(Text("Artículos", align='right'), 'dialog.selectdate.label')),
            AttrMap(self.articulos, 'dialog.selectdate.input', 'dialog.selectdate.input.focus'),
        ], dividechars=1)

        desde_row = Columns([
            ('fixed', 14, AttrMap(Text("Desde", align='right'), 'dialog.selectdate.label')),
            ('fixed', 11, AttrMap(self.desde, 'dialog.selectdate.input', 'dialog.selectdate.input.focus')),
            AttrMap(self.desde_error, 'dialog.selectdate.error'),
        ], dividechars=1)

        hasta_row = Columns([
            ('fixed', 14, AttrMap(Text("Hasta", align='right'), 'dialog.selectdate.label')),
            ('fixed', 11, AttrMap(self.hasta, 'dialog.selectdate.input', 'dialog.selectdate.input.focus')),
            AttrMap(self.hasta_error, 'dialog.selectdate.error'),
        ], dividechars=1)

        self.include_inactives = CheckBox(u"Incluir Desactivados", state=True)
        include_inactives_row = Columns([
            ('fixed', 14, Divider()),
            AttrMap(self.include_inactives, 'dialog.selectdate.label'),
        ], dividechars=1)

        self.content = Pile([
            articulos_row,
            desde_row,
            hasta_row,
            include_inactives_row,
            Divider(),
        ])

        t = u"Artículos y Rango de Fechas"
        if title:
            t += u" - %s" % title

        # Set initial dates
        self.desde.set_value(date(2001, 01, 01)) # FIXME: hardcoded > Principio de actividad
        self.hasta.set_value(date.today()+relativedelta(day=31)) # Fin de mes

        buttons = [("Continuar", self.run_list), ("Cancelar", self._quit)]

        Dialog.__init__(self, self.content, buttons,
                title=t,
                height=None,
                width=60,
                attr_style='dialog.selectdate',
                title_attr_style='dialog.selectdate.title')
#}}}
    def run_list(self, *args):
        art_list = self.get_articles()
        if not art_list:
            show_error([u"Los artículos ingresados no producen ningún resultado válido, ",
                        u"ingrese ", ('dialog.warning.important', u"artículos"), " o ",
                        ('dialog.warning.important', "grupos"), " correctos."])
            self._pile.set_focus(0)
            self.content.set_focus(0)
            return
        subdialog = self.cls(start_date=self.desde.get_value(),
                             end_date=self.hasta.get_value(),
                             articles=art_list)
        self.dialog_result = subdialog.run()
        self.quit()
#.........这里部分代码省略.........