632 lines
23 KiB
Python
632 lines
23 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
Primitivus: a SAT frontend
|
|
Copyright (C) 2009, 2010 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
import urwid
|
|
from urwid.escape import utf8decode
|
|
|
|
class Password(urwid.Edit):
|
|
toto=0
|
|
"""Edit box which doesn't show what is entered (show '*' or other char instead)"""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""Same args than Edit.__init__ with an additional keyword arg 'hidden_char'
|
|
@param hidden_char: char to show instead of what is actually entered: default '*'
|
|
"""
|
|
self.hidden_char=kwargs['hidden_char'] if kwargs.has_key('hidden_char') else '*'
|
|
self.__real_text=''
|
|
super(Password, self).__init__(*args, **kwargs)
|
|
|
|
def set_edit_text(self, text):
|
|
self.__real_text = text
|
|
hidden_txt = len(text)*'*'
|
|
super(Password, self).set_edit_text(hidden_txt)
|
|
|
|
def get_edit_text(self):
|
|
return self.__real_text
|
|
|
|
def insert_text(self, text):
|
|
self._edit_text = self.__real_text
|
|
super(Password,self).insert_text(text)
|
|
|
|
def render(self, size, focus=False):
|
|
Password.toto+=1
|
|
if Password.toto==30:
|
|
import os,pdb
|
|
os.system('reset')
|
|
pdb.set_trace()
|
|
return super(Password, self).render(size, focus)
|
|
|
|
class AdvancedEdit(urwid.Edit):
|
|
"""Edit box with some custom improvments
|
|
new chars:
|
|
- C-a: like 'home'
|
|
- C-e: like 'end'
|
|
- C-k: remove everything on the right of the cursor
|
|
- C-w: remove the word on the back
|
|
new behaviour: emit a 'click' signal when enter is pressed"""
|
|
signals = urwid.Edit.signals + ['click']
|
|
|
|
def keypress(self, size, key):
|
|
#TODO: insert mode is not managed yet
|
|
if key == 'ctrl a':
|
|
key = 'home'
|
|
elif key == 'ctrl e':
|
|
key = 'end'
|
|
elif key == 'ctrl k':
|
|
self._delete_highlighted()
|
|
self.set_edit_text(self.edit_text[:self.edit_pos])
|
|
elif key == 'ctrl w':
|
|
before = self.edit_text[:self.edit_pos]
|
|
pos = before.rstrip().rfind(" ")+1
|
|
self.set_edit_text(before[:pos] + self.edit_text[self.edit_pos:])
|
|
self.set_edit_pos(pos)
|
|
elif key == 'enter':
|
|
self._emit('click')
|
|
return super(AdvancedEdit, self).keypress(size, key)
|
|
|
|
|
|
class SurroundedText(urwid.FlowWidget):
|
|
"""Text centered on a repeated character (like a Divider, but with a text in the center)"""
|
|
|
|
def __init__(self,text,car=utf8decode('─')):
|
|
self.text=text
|
|
self.car=car
|
|
|
|
def rows(self,size,focus=False):
|
|
return self.display_widget(size, focus).rows(size, focus)
|
|
|
|
def render(self, size, focus=False):
|
|
return self.display_widget(size, focus).render(size, focus)
|
|
|
|
def display_widget(self, size, focus):
|
|
(maxcol,) = size
|
|
middle = (maxcol-len(self.text))/2
|
|
render_text = middle * self.car + self.text + (maxcol - len(self.text) - middle) * self.car
|
|
return urwid.Text(render_text)
|
|
|
|
|
|
|
|
class SelectableText(urwid.FlowWidget):
|
|
"""Text which can be selected with space"""
|
|
signals = ['change']
|
|
|
|
def __init__(self, text, align='left', header='', select_attr=None, default_attr=None, selected = False, data=None):
|
|
self.text=unicode(text)
|
|
self.header=header
|
|
if data:
|
|
self.data=data
|
|
if select_attr:
|
|
self.selected = select_attr
|
|
if default_attr:
|
|
self.default = default_attr
|
|
self.align = align
|
|
self.__selected=selected
|
|
|
|
def getValue(self):
|
|
return self.text
|
|
|
|
def setAttribute(self, name, value):
|
|
"""Change attribut used for rendering widget
|
|
@param name: one of
|
|
-default: when not selected
|
|
-selected: when selected
|
|
@param value: name of the attribute
|
|
/!\ the attribute name followed by _focus is used when widget has focus"""
|
|
assert name in ['default', 'selected']
|
|
self.__setattr__(name,value)
|
|
self._invalidate()
|
|
|
|
def setState(self, selected, invisible=False):
|
|
"""Change state
|
|
@param selected: boolean state value
|
|
@param invisible: don't emit change signal if True"""
|
|
assert(type(selected)==bool)
|
|
self.__selected=selected
|
|
self._invalidate()
|
|
if not invisible:
|
|
self._emit("change", self.__selected)
|
|
|
|
def getState(self):
|
|
return self.__selected
|
|
|
|
def selectable(self):
|
|
return True
|
|
|
|
def keypress(self, size, key):
|
|
if key==' ' or key=='enter':
|
|
self.setState(not self.__selected)
|
|
else:
|
|
return key
|
|
|
|
def rows(self,size,focus=False):
|
|
return self.display_widget(size, focus).rows(size, focus)
|
|
|
|
def render(self, size, focus=False):
|
|
return self.display_widget(size, focus).render(size, focus)
|
|
|
|
def display_widget(self, size, focus):
|
|
try:
|
|
select_attr = self.selected
|
|
except AttributeError:
|
|
select_attr = 'selected'
|
|
try:
|
|
default_attr = self.default
|
|
except AttributeError:
|
|
default_attr = 'default'
|
|
attr = select_attr if self.__selected else default_attr
|
|
if focus:
|
|
attr+="_focus"
|
|
return urwid.Text((attr,self.header+self.text), align=self.align)
|
|
|
|
class ClickableText(SelectableText):
|
|
signals = SelectableText.signals + ['click']
|
|
|
|
def setState(self, selected, invisible=False):
|
|
self._emit('click')
|
|
|
|
class GenericList(urwid.WidgetWrap):
|
|
signals = ['click','change']
|
|
|
|
def __init__(self, options, style=[], align='left', option_type = SelectableText, on_click=None, on_change=None, user_data=None):
|
|
"""
|
|
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
|
|
@param align: alignement of text inside the list
|
|
@param on_click: method called when click signal is emited
|
|
@param user_data: data sent to the callback for click signal
|
|
"""
|
|
self.single = 'single' in style
|
|
self.no_first_select = 'no_first_select' in style
|
|
self.can_select_none = 'can_select_none' in style
|
|
self.align = align
|
|
self.option_type = option_type
|
|
self.first_display = True
|
|
|
|
if on_click:
|
|
urwid.connect_signal(self, 'click', on_click, user_data)
|
|
|
|
if on_change:
|
|
urwid.connect_signal(self, 'change', on_change, user_data)
|
|
|
|
self.content = urwid.SimpleListWalker([])
|
|
self.list_box = urwid.ListBox(self.content)
|
|
urwid.WidgetWrap.__init__(self, self.list_box)
|
|
self.changeValues(options)
|
|
|
|
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("click")
|
|
|
|
|
|
def unselectAll(self, invisible=False):
|
|
for widget in self.content:
|
|
if widget.getState():
|
|
widget.setState(False, invisible)
|
|
widget._invalidate()
|
|
|
|
def deleteValue(self, value):
|
|
"""Delete the first value equal to the param given"""
|
|
for widget in self.content:
|
|
if widget.getValue() == value:
|
|
self.content.remove(widget)
|
|
self._emit('change')
|
|
return
|
|
raise ValueError("%s ==> %s" % (str(value),str(self.content)))
|
|
|
|
def getSelectedValue(self):
|
|
"""Convenience method to get the value selected as a string in single mode, or None"""
|
|
values = self.getSelectedValues()
|
|
return values[0] if values else None
|
|
|
|
def getAllValues(self):
|
|
"""Return values of all items"""
|
|
return [widget.getValue() for widget in self.content]
|
|
|
|
def getSelectedValues(self):
|
|
"""Return values of selected items"""
|
|
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 value in one shot"""
|
|
if not self.first_display:
|
|
old_selected = self.getSelectedValues()
|
|
widgets = []
|
|
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)
|
|
try:
|
|
urwid.connect_signal(widget, 'change', self.__onStateChange)
|
|
except NameError:
|
|
pass #the widget given doesn't support 'change' 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):
|
|
self.unselectAll()
|
|
idx = 0
|
|
for widget in self.content:
|
|
if widget.getSelectedValue() == value:
|
|
widget.setState(True)
|
|
self.list_box.set_focus(idx)
|
|
return
|
|
idx+=1
|
|
|
|
class List(urwid.FlowWidget):
|
|
"""FlowWidget list, same arguments as GenericList, with an additional one 'max_height'"""
|
|
signals = ['click','change']
|
|
|
|
def __init__(self, options, style=[], max_height=5, align='left', option_type = SelectableText, on_click=None, on_change=None, user_data=None):
|
|
self.genericList = GenericList(options, style, align, option_type, on_click, on_change, user_data)
|
|
self.max_height = max_height
|
|
|
|
def selectable(self):
|
|
return True
|
|
|
|
def keypress(self, size, key):
|
|
return self.displayWidget(size,True).keypress(size, key)
|
|
|
|
def unselectAll(self, invisible=False):
|
|
return self.genericList.unselectAll(invisible)
|
|
|
|
def deleteValue(self, value):
|
|
return self.genericList.deleteValue(value)
|
|
|
|
def getSelectedValue(self):
|
|
return self.genericList.getSelectedValue()
|
|
|
|
def getAllValues(self):
|
|
return self.genericList.getAllValues()
|
|
|
|
def getSelectedValues(self):
|
|
return self.genericList.getSelectedValues()
|
|
|
|
def changeValues(self, new_values):
|
|
return self.genericList.changeValues(new_values)
|
|
|
|
def selectValue(self, value):
|
|
return self.genericList.selectValue(value)
|
|
|
|
def render(self, size, focus=False):
|
|
return self.displayWidget(size, focus).render(size, focus)
|
|
|
|
def rows(self, size, focus=False):
|
|
return self.displayWidget(size, focus).rows(size, focus)
|
|
|
|
def displayWidget(self, size, focus):
|
|
list_size = sum([wid.rows(size, focus) for wid in self.genericList.content])
|
|
height = min(list_size,self.max_height) or 1
|
|
return urwid.BoxAdapter(self.genericList, height)
|
|
|
|
## MISC ##
|
|
|
|
class MenuBox(urwid.WidgetWrap):
|
|
signals = ['click']
|
|
|
|
def __init__(self,parent,items):
|
|
self.parent = parent
|
|
self.selected = None
|
|
content = urwid.SimpleListWalker([ClickableText(text,default_attr='menuitem') for text in items])
|
|
for wid in content:
|
|
urwid.connect_signal(wid, 'click', self.onClick)
|
|
|
|
self.listBox = urwid.ListBox(content)
|
|
menubox = urwid.LineBox(urwid.BoxAdapter(self.listBox,len(items)))
|
|
urwid.WidgetWrap.__init__(self,menubox)
|
|
|
|
def getValue(self):
|
|
return self.selected
|
|
|
|
def keypress(self, size, key):
|
|
if key=='up':
|
|
if self.listBox.get_focus()[1] == 0:
|
|
self.parent.keypress(size, key)
|
|
elif key=='left' or key=='right':
|
|
self.parent.keypress(size,'up')
|
|
self.parent.keypress(size,key)
|
|
return super(MenuBox,self).keypress(size,key)
|
|
|
|
def onClick(self, wid):
|
|
self.selected = wid.getValue()
|
|
self._emit('click')
|
|
|
|
class Menu(urwid.FlowWidget):
|
|
|
|
def __init__(self,loop, x_orig=0):
|
|
"""Menu widget
|
|
@param loop: main loop of urwid
|
|
@param x_orig: absolute start of the abscissa
|
|
"""
|
|
super(Menu, self).__init__()
|
|
self.loop = loop
|
|
self.menu_keys = []
|
|
self.menu = {}
|
|
self.x_orig = x_orig
|
|
self.shortcuts = {} #keyboard shortcuts
|
|
self.focus_menu = 0
|
|
self.save_bottom = None
|
|
|
|
def selectable(self):
|
|
return True
|
|
|
|
def getMenuSize(self):
|
|
"""return the current number of categories in this menu"""
|
|
return len(self.menu_keys)
|
|
|
|
def setOrigX(self, orig_x):
|
|
self.x_orig = orig_x
|
|
|
|
def __buildOverlay(self,menu_key,columns):
|
|
"""Build the overlay menu which show menuitems
|
|
@param menu_key: name of the category
|
|
@colums: column number where the menubox must be displayed"""
|
|
max_len = 0
|
|
for item in self.menu[menu_key]:
|
|
if len(item[0]) > max_len:
|
|
max_len = len(item[0])
|
|
|
|
self.save_bottom = self.loop.widget
|
|
menu_box = MenuBox(self,[item[0] for item in self.menu[menu_key]])
|
|
urwid.connect_signal(menu_box, 'click', self.onClick)
|
|
|
|
self.loop.widget = urwid.Overlay(urwid.AttrMap(menu_box,'menubar'),self.save_bottom,('fixed left', columns),max_len+2,('fixed top',1),None)
|
|
|
|
def keypress(self, size, key):
|
|
if key == 'right' and self.focus_menu < len(self.menu)-1:
|
|
self.focus_menu += 1
|
|
self._invalidate()
|
|
elif key == 'left' and self.focus_menu > 0:
|
|
self.focus_menu -= 1
|
|
self._invalidate()
|
|
return
|
|
elif key == 'down':
|
|
if self.menu_keys and not self.save_bottom:
|
|
column = sum([len(menu)+4 for menu in self.menu_keys[0:self.focus_menu]],self.focus_menu+self.x_orig)
|
|
self.__buildOverlay(self.menu_keys[self.focus_menu],column)
|
|
elif key == 'up':
|
|
if self.save_bottom:
|
|
self.loop.widget = self.save_bottom
|
|
self.save_bottom = None
|
|
|
|
return key
|
|
|
|
def checkShortcuts(self, key):
|
|
for shortcut in self.shortcuts.keys():
|
|
if key == shortcut:
|
|
category, item, callback = self.shortcuts[shortcut]
|
|
callback((category, item))
|
|
return key
|
|
|
|
def addMenu(self, category, item, callback, shortcut=None):
|
|
"""Add a menu item, create the category if new
|
|
@param category: category of the menu (e.g. File/Edit)
|
|
@param item: menu item (e.g. new/close/about)
|
|
@callback: method to call when item is selected"""
|
|
if not category in self.menu.keys():
|
|
self.menu_keys.append(category)
|
|
self.menu[category] = []
|
|
self.menu[category].append((item, callback))
|
|
if shortcut:
|
|
assert(shortcut not in self.shortcuts.keys())
|
|
self.shortcuts[shortcut] = (category, item, callback)
|
|
|
|
def rows(self,size,focus=False):
|
|
return self.display_widget(size, focus).rows(size, focus)
|
|
|
|
def render(self, size, focus=False):
|
|
return self.display_widget(size, focus).render(size, focus)
|
|
|
|
def display_widget(self, size, focus):
|
|
render_txt = []
|
|
idx = 0
|
|
for menu in self.menu_keys:
|
|
if focus and idx == self.focus_menu:
|
|
render_txt.append(('selected_menu', '[ %s ]' % menu))
|
|
render_txt.append(' ')
|
|
else:
|
|
render_txt.append('[ %s ] ' % menu)
|
|
idx += 1
|
|
return urwid.AttrMap(urwid.Text(render_txt), 'menubar')
|
|
|
|
def onClick(self, widget):
|
|
category = self.menu_keys[self.focus_menu]
|
|
item = widget.getValue()
|
|
for menu_item in self.menu[category]:
|
|
if item == menu_item[0]:
|
|
callback = menu_item[1]
|
|
break
|
|
if callback:
|
|
self.keypress(None,'up')
|
|
callback((category, item))
|
|
|
|
class MenuRoller(urwid.WidgetWrap):
|
|
|
|
def __init__(self,menus_list):
|
|
"""Create a MenuRoller
|
|
@param menus_list: list of tuple with (name, Menu_instance), name can be None
|
|
"""
|
|
assert (menus_list)
|
|
self.selected = 0
|
|
self.name_list = []
|
|
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
|
|
self.addMenu(name, menu)
|
|
|
|
def __showSelected(self):
|
|
"""show menu selected"""
|
|
name_txt = u'\u21c9 '+self.name_list[self.selected]+u' \u21c7 '
|
|
current_name = ClickableText(name_txt)
|
|
name_len = len(name_txt)
|
|
current_menu = self.menus[self.name_list[self.selected]]
|
|
current_menu.setOrigX(name_len)
|
|
self.columns.widget_list[0] = current_name
|
|
self.columns.column_types[0]=('fixed', name_len)
|
|
self.columns.widget_list[1] = current_menu
|
|
|
|
def keypress(self, size, key):
|
|
if key=='up':
|
|
if self.columns.get_focus_column()==0 and self.selected > 0:
|
|
self.selected -= 1
|
|
self.__showSelected()
|
|
elif key=='down':
|
|
if self.columns.get_focus_column()==0 and self.selected < len(self.name_list)-1:
|
|
self.selected += 1
|
|
self.__showSelected()
|
|
elif key=='right':
|
|
if self.columns.get_focus_column()==0 and \
|
|
(self.columns.widget_list[1].__class__ == urwid.Text or \
|
|
self.menus[self.name_list[self.selected]].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):
|
|
name = name_param or ''
|
|
if name not in self.name_list:
|
|
self.name_list.append(name)
|
|
self.menus[name] = menu
|
|
if self.name_list[self.selected] == name:
|
|
self.__showSelected() #if we are on the menu, we update it
|
|
|
|
def checkShortcuts(self, key):
|
|
for menu in self.name_list:
|
|
key = self.menus[menu].checkShortcuts(key)
|
|
return key
|
|
|
|
|
|
## DIALOGS ##
|
|
|
|
class GenericDialog(urwid.WidgetWrap):
|
|
|
|
def __init__(self, widgets_lst, title, style=[], **kwargs):
|
|
frame_header = urwid.AttrMap(urwid.Text(title,'center'),'title')
|
|
|
|
buttons = None
|
|
|
|
if "OK/CANCEL" in style:
|
|
buttons = [urwid.Button(_("Cancel"), kwargs['cancel_cb']),
|
|
urwid.Button(_("Ok"), kwargs['ok_cb'], kwargs['ok_value'])]
|
|
elif "YES/NO" in style:
|
|
buttons = [urwid.Button(_("Yes"), kwargs['yes_cb']),
|
|
urwid.Button(_("No"), kwargs['no_cb'], kwargs['yes_value'])]
|
|
if "OK" in style:
|
|
buttons = [urwid.Button(_("Ok"), kwargs['ok_cb'], kwargs['ok_value'])]
|
|
if buttons:
|
|
buttons_flow = urwid.GridFlow(buttons, max([len(button.get_label()) for button in buttons])+4, 1, 1, 'center')
|
|
widgets_lst.append(buttons_flow)
|
|
body_content = urwid.SimpleListWalker(widgets_lst)
|
|
frame_body = urwid.ListBox(body_content)
|
|
frame = urwid.Frame(frame_body, frame_header)
|
|
decorated_frame = urwid.LineBox(frame)
|
|
urwid.WidgetWrap.__init__(self, decorated_frame)
|
|
|
|
|
|
|
|
class InputDialog(GenericDialog):
|
|
"""Dialog with an edit box"""
|
|
|
|
def __init__(self, title, instrucions, style=['OK/CANCEL'], default_txt = '', **kwargs):
|
|
instr_wid = urwid.Text(instrucions+':')
|
|
edit_box = urwid.Edit(edit_text=default_txt)
|
|
GenericDialog.__init__(self, [instr_wid,edit_box], title, style, ok_value=edit_box, **kwargs)
|
|
|
|
class ConfirmDialog(GenericDialog):
|
|
"""Dialog with buttons for confirm or cancel an action"""
|
|
|
|
def __init__(self, title, style=['YES/NO'], **kwargs):
|
|
GenericDialog.__init__(self, [], title, style, yes_value=None, **kwargs)
|
|
|
|
class Alert(GenericDialog):
|
|
"""Dialog with just a message and a OK button"""
|
|
|
|
def __init__(self, title, message, style=['OK'], **kwargs):
|
|
GenericDialog.__init__(self, [urwid.Text(message, 'center')], title, style, ok_value=None, **kwargs)
|
|
|
|
## CONTAINERS ##
|
|
|
|
class FocusFrame(urwid.Frame):
|
|
"""Frame which manage 'tab' key"""
|
|
|
|
def keypress(self, size, key):
|
|
if key == 'tab':
|
|
focus_list = ('header','body','footer')
|
|
focus_idx = focus_list.index(self.focus_part)
|
|
for i in range(2):
|
|
focus_idx = (focus_idx + 1) % len(focus_list)
|
|
focus_name = focus_list[focus_idx]
|
|
widget = getattr(self,'_'+focus_name)
|
|
if widget!=None and widget.selectable():
|
|
self.set_focus(focus_name)
|
|
|
|
return urwid.Frame.keypress(self, size, key)
|
|
|
|
## DECORATORS ##
|
|
class LabelLine(urwid.LineBox):
|
|
"""Like LineBox, but with a Label centered in the top line"""
|
|
|
|
def __init__(self, original_widget, label_widget):
|
|
urwid.LineBox.__init__(self, original_widget)
|
|
top_columns = self._w.widget_list[0]
|
|
top_columns.widget_list[1] = label_widget
|
|
|
|
class VerticalSeparator(urwid.WidgetDecoration, urwid.WidgetWrap):
|
|
def __init__(self, original_widget, left_char = utf8decode("│"), right_char = ''):
|
|
"""Draw a separator on left and/or of original_widget."""
|
|
|
|
widgets = [original_widget]
|
|
if left_char:
|
|
widgets.insert(0, ('fixed', 1, urwid.SolidFill(left_char)))
|
|
if right_char:
|
|
widgets.append(('fixed', 1, urwid.SolidFill(right_char)))
|
|
columns = urwid.Columns(widgets, box_columns = [0,2], focus_column = 1)
|
|
urwid.WidgetDecoration.__init__(self, original_widget)
|
|
urwid.WidgetWrap.__init__(self, columns)
|
|
|
|
|