urwid-satext: urwid_satext/sat_widgets.py comparison

comparison urwid_satext/sat_widgets.py @ 107:ed2675f92f7c

menus management improvment

author	Goffi <goffi@goffi.org>
date	Wed, 10 Dec 2014 19:08:35 +0100
parents	b2fee87c1d5a
children	5bb3b7e25bf6

comparison

equal deleted inserted replaced

-:f083eca93047
+:ed2675f92f7c
 import urwid
 import logging as log
 import encodings
 utf8decode = lambda s: encodings.codecs.utf_8_decode(s)[0]
+import uuid
+import collections
 from urwid.util import is_mouse_press #XXX: is_mouse_press is not included in urwid in 1.0.0
 from .keys import action_key_map as a_key
 FOCUS_KEYS = (a_key['FOCUS_SWITCH'], a_key['FOCUS_UP'], a_key['FOCUS_DOWN'])
 @param align: same as urwid.Text's align parameter
 @select_attr: attrbute to use when selected
 @param selected: is the text selected ?
 """
 self.focus_attr = focus_attr
-self.__selected = False
+self._selected = False
-self.__was_focused = False
+self._was_focused = False
 self.header = header
 self.text = text
 urwid.WidgetWrap.__init__(self, urwid.Text("",align=align))
 self.setSelectedText(selected_text)
 self.setState(selected)
 return self.getValue()
 def set_text(self, text):
 """/!\ set_text doesn't change self.selected_txt !"""
 self.text = text
-self.setState(self.__selected,invisible=True)
+self.setState(self._selected,invisible=True)
 def setSelectedText(self, text=None):
 """Text to display when selected
 @text: text as in urwid.Text or None for default value"""
 if text == None:
 text = ('selected',self.getValue())
 self.selected_txt = text
-if self.__selected:
+if self._selected:
-self.setState(self.__selected)
+self.setState(self._selected)
-def __set_txt(self):
+def _set_txt(self):
 txt_list = [self.header]
-txt = self.selected_txt if self.__selected else self.text
+txt = self.selected_txt if self._selected else self.text
 if isinstance(txt,list):
 txt_list.extend(txt)
 else:
 txt_list.append(txt)
 self._w.base_widget.set_text(txt_list)
 def setState(self, selected, invisible=False):
 """Change state
 @param selected: boolean state value
-@param invisible: don't emit change signal if True"""
+@param invisible: don't emit change signal if True
-assert(type(selected)==bool)
+"""
-self.__selected=selected
+assert type(selected)==bool
-self.__set_txt()
+self._selected=selected
-self.__was_focused = False
+self._set_txt()
+self._was_focused = False
 self._invalidate()
 if not invisible:
-self._emit("change", self.__selected)
+self._emit("change", self._selected)
 def getState(self):
-return self.__selected
+return self._selected
 def selectable(self):
 return True
 def keypress(self, size, key):
 if key in (a_key['TEXT_SELECT'], a_key['TEXT_SELECT2']):
-self.setState(not self.__selected)
+self.setState(not self._selected)
 else:
 return key
 def mouse_event(self, size, event, button, x, y, focus):
 if is_mouse_press(event) and button == 1:
-self.setState(not self.__selected)
+self.setState(not self._selected)
 return True
 return False
 def render(self, size, focus=False):
 attr_list = self._w.base_widget._attrib
 if not focus:
-if self.__was_focused:
+if self._was_focused:
-self.__set_txt()
+self._set_txt()
-self.__was_focused = False
+self._was_focused = False
 else:
-if not self.__was_focused:
+if not self._was_focused:
 if not attr_list:
 attr_list.append((self.focus_attr,len(self._w.base_widget.text)))
 else:
 for idx in range(len(attr_list)):
 attr,attr_len = attr_list[idx]
 else:
 if not attr.endswith('_focus'):
 attr+="_focus"
 attr_list[idx] = (attr,attr_len)
 self._w.base_widget._invalidate()
-self.__was_focused = True #bloody ugly hack :)
+self._was_focused = True #bloody ugly hack :)
 return self._w.render(size, focus)
 class SelectableText(AlwaysSelectableText):
 """Like AlwaysSelectableText but not selectable when text is empty"""
 self._emit('click')
 class CustomButton(ClickableText):
-def __init__(self, label, on_press=None, user_data=None, left_border = "[ ", right_border = " ]"):
+def __init__(self, label, on_press=None, user_data=None, left_border="[ ", right_border=" ]", align="left"):
 self.label = label
 self.left_border = left_border
 self.right_border = right_border
-super(CustomButton, self).__init__([left_border, label, right_border])
+super(CustomButton, self).__init__([left_border, label, right_border], align=align)
 self.size = len(self.get_text())
 if on_press:
 urwid.connect_signal(self, 'click', on_press, user_data)
 def getSize(self):
 self.label = label
 self.set_text([self.left_border, label, self.right_border])
 class ListOption(unicode):
-""" Class similar to unicode, but which make the difference between value and label
+"""Unicode which manage label and value
+This class similar to unicode, but which make the difference between value and label
 label is show when use as unicode, the .value attribute contain the actual value
 Can be initialised with:
 - basestring (label = value = given string)
 - a tuple with (value, label)
 XXX: comparaison is made against value, not the label which is the one displayed
 """
 def __new__(cls, option):
 if (isinstance(option, cls)):
 return option
 self.__size_cache = size
 self.__focus_cache = focus
 return super(UnselectableListBox, self).render(size, focus)
-class GenericList(urwid.WidgetWrap):
+class GenericList(urwid.ListBox):
 signals = ['click','change']
 def __init__(self, options, style=None, align='left', option_type = SelectableText, on_click=None, on_change=None, user_data=None):
-"""
+"""Widget managing list of string and their selection
-Widget managing list of string and their selection
 @param options: list of strings used for options
 @param style: list of string:
 - 'single' if only one must be selected
 - 'no_first_select' nothing selected when list is first displayed
 - 'can_select_none' if we can select nothing
 if on_change:
 urwid.connect_signal(self, 'change', on_change, user_data)
 self.content = urwid.SimpleListWalker([])
-self.list_box = urwid.ListBox(self.content)
+super(GenericList, self).__init__(self.content)
-urwid.WidgetWrap.__init__(self, self.list_box)
 self.changeValues(options)
-def __onStateChange(self, widget, selected):
+def _onStateChange(self, widget, selected):
 if self.single:
 if not selected and not self.can_select_none:
 #if in single mode, it's forbidden to unselect a value
 widget.setState(True, invisible=True)
 return
 if selected:
 self.unselectAll(invisible=True)
 widget.setState(True, invisible=True)
 self._emit("change")
-def __onClick(self, widget):
+def _onClick(self, widget):
 self._emit("click", widget)
 def unselectAll(self, invisible=False):
 for widget in self.content:
 if widget.getState():
 result = []
 for widget in self.content:
 if widget.getState():
 result.append(widget.getValue())
 return result
-def getDisplayWidget(self):
-return self.list_box
 def changeValues(self, new_values):
 """Change all values in one shot"""
 new_values = ListOption.fromOptions(new_values)
 if not self.first_display:
 for option in new_values:
 widget = self.option_type(option, self.align)
 if not self.first_display and option in old_selected:
 widget.setState(True)
 widgets.append(widget)
-for signal, callback in (('change', self.__onStateChange), ('click', self.__onClick)):
+for signal, callback in (('change', self._onStateChange), ('click', self._onClick)):
 try:
 urwid.connect_signal(widget, signal, callback)
 except NameError:
 pass #the widget given doesn't support the signal
 self.content[:] = widgets
 if self.first_display and self.single and new_values and not self.no_first_select:
 self.content[0].setState(True)
-display_widget = self.getDisplayWidget()
-self._set_w(display_widget)
 self._emit('change')
 self.first_display = False
 def selectValue(self, value, move_focus=True):
 """Select the first item which has the given value.
 @param value
-@param move_focus (boolean): True to move the focus on the selected value,
+@param move_focus (bool):
-False to leave the focus position unchanged.
+- True to move the focus on the selected value,
+- False to leave the focus position unchanged.
 """
 self.unselectAll()
 idx = 0
 for widget in self.content:
 if widget.getValue() == value:
 widget.setState(True)
 if move_focus:
-self.list_box.focus_position = idx
+self.focus_position = idx
 return
 idx+=1
 def selectValues(self, values, move_focus=True):
 """Select all the given values.
 idx = 0
 for widget in self.content:
 if widget.getValue() == value:
 widget.setState(True)
 if move_focus:
-self.list_box.focus_position = idx
+self.focus_position = idx
 idx += 1
 class List(urwid.Widget):
 """FlowWidget list, same arguments as GenericList, with an additional one 'max_height'"""
 def onCategoryClick(self, button):
 self.__buildOverlay(button.get_label(),
 self.x_orig + self._w.base_widget.getStartCol(button))
+MenuItem = collections.namedtuple('MenuItem', ('name', 'widget'))
 class MenuRoller(urwid.WidgetWrap):
-def __init__(self,menus_list):
+def __init__(self, menus_list):
 """Create a MenuRoller
-@param menus_list: list of tuple with (name, Menu_instance), name can be None
+@param menus_list: list of tuples which can be either:
+- (name, Menu instance)
+- (name, Menu instance, id)
 """
-assert (menus_list)
+assert menus_list
-self.selected = 0
+self.selected = None
-self.name_list = []
+self.menu_items = collections.OrderedDict()
-self.menus = {}
 self.columns = urwid.Columns([urwid.Text(''),urwid.Text('')])
 urwid.WidgetWrap.__init__(self, self.columns)
 for menu_tuple in menus_list:
-name,menu = menu_tuple
+try:
-self.addMenu(name, menu)
+name, menu, id_ = menu_tuple
+except ValueError:
+name, menu = menu_tuple
+id_ = None
+self.addMenu(name, menu, id_)
 def _showSelected(self):
 """show menu selected"""
-name_txt = u'\u21c9 '+self.name_list[self.selected]+u' \u21c7 '
+if self.selected is None:
-current_name = ClickableText(name_txt)
+self.columns.contents[0] = (urwid.Text(''), ('given', 0, False))
-name_len = len(name_txt)
+self.columns.contents[1] = (urwid.Text(''), ('weight', 1, False))
-current_menu = self.menus[self.name_list[self.selected]]
+else:
-current_menu.setOrigX(name_len)
+menu_item = self.menu_items[self.selected]
-self.columns.contents[0] = (current_name, ('given', name_len, False))
+name_txt = u'\u21c9 ' + menu_item.name + u' \u21c7 '
-self.columns.contents[1] = (current_menu, ('weight', 1, False))
+current_name = ClickableText(name_txt)
+name_len = len(name_txt)
+current_menu = menu_item.widget
+current_menu.setOrigX(name_len)
+self.columns.contents[0] = (current_name, ('given', name_len, False))
+self.columns.contents[1] = (current_menu, ('weight', 1, False))
 def keypress(self, size, key):
+menu_ids = self.menu_items.keys()
+try:
+idx = menu_ids.index(self.selected)
+except ValueError:
+return super(MenuRoller, self).keypress(size, key)
 if key==a_key['MENU_ROLLER_UP']:
 if self.columns.get_focus_column()==0:
-if self.selected > 0:
+if idx > 0:
-self.selected -= 1
+self.selected = menu_ids[idx-1]
 self._showSelected()
 return
 elif key==a_key['MENU_ROLLER_DOWN']:
 if self.columns.get_focus_column()==0:
-if self.selected < len(self.name_list)-1:
+if idx < len(menu_ids)-1:
-self.selected += 1
+self.selected = menu_ids[idx+1]
 self._showSelected()
 return
 elif key==a_key['MENU_ROLLER_RIGHT']:
 if self.columns.get_focus_column()==0 and \
 (isinstance(self.columns.contents[1][0], urwid.Text) or \
-self.menus[self.name_list[self.selected]].getMenuSize()==0):
+self.menu_items[self.selected].widget.getMenuSize()==0):
 return #if we have no menu or the menu is empty, we don't go the right column
 return super(MenuRoller, self).keypress(size, key)
-def addMenu(self, name_param, menu):
+def addMenu(self, name, widget, menu_id=None):
-name = name_param or ''
+"""Add a menu
-if name not in self.name_list:
-self.name_list.append(name)
+@param name: name of the menu to add, it name already exists, menu is not added
-self.menus[name] = menu
+@param widget: instance of Menu
-if self.name_list[self.selected] == name:
+@param menu_id: id to use of this menu, or None to generate
+@return: menu_id
+"""
+names = {menu_item.name: id_ for id_, menu_item in self.menu_items.iteritems()}
+if name not in names:
+id_ = menu_id or str(uuid.uuid4())
+if id_ in self.menu_items:
+raise ValueError('Conflict: the id [{}] is already used'.format(id_))
+self.menu_items[id_] = MenuItem(name, widget)
+else:
+id_ = names[name]
+menu_item = self.menu_items[id_]
+if menu_item.widget is not widget:
+raise ValueError("The menu with id [{}] exists and doesn't contain the given instance. Use replaceMenu if you want to change the menu.".format(id_))
+if self.selected is None:
+self.selected = id_
+self._showSelected()
+return id_
+def replaceMenu(self, name, widget, menu_id):
+"""Add a menu or replace it if the id already exists
+@param name: name of the menu to add, it name already exists, menu is not added
+@param widget: instance of Menu
+@param menu_id: id or the menu
+"""
+assert menu_id is not None
+if menu_id in self.menu_items:
+del self.menu_items[menu_id]
+self.addMenu(name, widget, menu_id)
+if self.selected == menu_id:
 self._showSelected() #if we are on the menu, we update it
-def removeMenu(self, name):
+def removeMenu(self, menu_id):
-if name in self.name_list:
+del self.menu_items[menu_id]
-self.name_list.remove(name)
+if self.selected == menu_id:
-if name in self.menus.keys():
+self.selected = self.menu_items.items[0] if self.menu_items else None
-del self.menus[name]
+self._showSelected()
-self.selected = 0
-self._showSelected()
 def checkShortcuts(self, key):
-for menu in self.name_list:
+for menu_item in self.menu_items.values():
-key = self.menus[menu].checkShortcuts(key)
+key = menu_item.widget.checkShortcuts(key)
 return key
 ## DIALOGS ##

Mercurial > urwid-satext

comparison urwid_satext/sat_widgets.py @ 107:ed2675f92f7c