def make_compile_error_view(self):
blank = urwid.Divider()
status_header = urwid.AttrWrap(urwid.Text('Run Code Status: '), 'body')
status = urwid.AttrWrap(urwid.Text('Compile Error'), 'hometag')
columns = urwid.Columns([(17, status_header), (20, status)])
column_wrap = urwid.WidgetWrap(columns)
result_header = urwid.Text('--- Run Code Result: ---', align='center')
your_input_header = urwid.Text('Your input:')
your_input = urwid.Text('')
your_answer_header = urwid.Text('Your answer:')
your_answer = urwid.Text(self.result['compile_error'])
expected_answer_header = urwid.Text('Expected answer:')
expected_answer = urwid.Text('Unkown Error')
list_items = [
result_header,
blank, column_wrap,
blank, your_input_header, your_input,
blank, your_answer_header, your_answer,
blank, expected_answer_header, expected_answer
]
return urwid.Padding(urwid.ListBox(urwid.SimpleListWalker(list_items)), left=2, right=2)
def players_sentences(choices):
body = [
urwid.Text('Chosen Black Card:'),
urwid.Text(general_sentence),
urwid.Divider(),
urwid.Text('Your sentence:'),
urwid.Text(your_sentence),
urwid.Divider(),
urwid.Text('All Sentences')
]
iterchoices = iter(choices)
next(iterchoices)
for c in iterchoices:
choise = print_sentence_card()
button = urwid.Button(c)
# button = urwid.CheckBox(c)
# button = urwid.AttrMap(urwid.SelectableIcon([u' * ', c], 2), None, 'selected')
urwid.connect_signal(button, 'click', sentence_chosen, c)
# urwid.connect_signal(button, 'change', item_chosen, c)
body.append(urwid.AttrMap(button, None, focus_map='reversed'))
return urwid.ListBox(urwid.SimpleListWalker(body))
def __init__(self, loop, engine, showlist={}, width=30):
self.viewing_info = False
self.engine = engine
self.listheader = urwid.Columns([
('fixed', 7, urwid.Text('ID')),
('weight', 1, urwid.Text('Title')),
('fixed', 10, urwid.Text('Type')),
('fixed', 7, urwid.Text('Total')),
])
self.listwalker = urwid.SimpleListWalker([])
self.listbox = urwid.ListBox(self.listwalker)
# Add results to the list
for show in showlist:
self.listwalker.append(SearchItem(show))
self.info_txt = urwid.Text("Add View | Enter:Add i:Info O:Website Esc:Cancel")
self.frame = urwid.Frame(self.listbox, header=self.listheader, footer=self.info_txt)
self.__super.__init__(self.frame, loop, width=width, height=('relative', 80), title='Search results')
def __init__(self, loop, manager, switch=False, width=50):
self.switch = switch
self.manager = manager
listheader = urwid.Columns([
('weight', 1, urwid.Text('Username')),
('fixed', 15, urwid.Text('Site')),
])
self.listwalker = urwid.SimpleListWalker([])
listbox = urwid.ListBox(self.listwalker)
self.build_list()
self.foot = urwid.Text('enter:Use once r:Use always a:Add D:Delete')
self.frame = urwid.Frame(listbox, header=listheader, footer=self.foot)
self.__super.__init__(self.frame, loop, width=width, height=15, title='Select Account')
self.adding = False
self.show()
def __init__(self):
self.rootpw1_bar = urwid.Edit(mask='*')
self.rootpw2_bar = urwid.Edit(mask='*')
content = [
urwid.Divider(),
urwid.Text(TEXT_PASSWD_DIALOG_PASSWD1 + ':'),
urwid.AttrMap(self.rootpw1_bar, 'app.editbox', 'app.editfocus'),
urwid.Text(TEXT_PASSWD_DIALOG_PASSWD2 + ':'),
urwid.AttrMap(self.rootpw2_bar, 'app.editbox', 'app.editfocus'),
urwid.Divider(),
urwid.Columns([
urwid.Divider(),
('fixed', 10, urwid.AttrMap(urwid.Button(TEXT_BUTTON_APPLY, self.on_apply), 'app.button', 'app.buttonfocus')),
('fixed', 10, urwid.AttrMap(urwid.Button(TEXT_BUTTON_CANCEL, self.on_cancel), 'app.button', 'app.buttonfocus')),
urwid.Divider()
], dividechars=8)
]
walker = urwid.SimpleListWalker(content)
self.footer = urwid.Pile([urwid.Text(TEXT_ELEMENT_KEYBOARD_DLG_HINT), urwid.Text(TEXT_ELEMENT_KEYBOARD_HINT)])
self.view = urwid.AttrMap(urwid.LineBox(urwid.Frame(urwid.ListBox(walker), footer=self.footer), title=TEXT_PASSWD_DIALOG_CAPTION), 'app.dialog')
urwid.WidgetWrap.__init__(self, self.view)
def __init__(self, server, options):
flow.FlowMaster.__init__(self, options, server, ConsoleState())
self.stream_path = None
# This line is just for type hinting
self.options = self.options # type: Options
self.options.errored.connect(self.options_error)
r = self.set_intercept(options.intercept)
if r:
print("Intercept error: {}".format(r), file=sys.stderr)
sys.exit(1)
if options.filter:
self.set_view_filter(options.filter)
self.set_stream_large_bodies(options.stream_large_bodies)
self.palette = options.palette
self.palette_transparent = options.palette_transparent
self.logbuffer = urwid.SimpleListWalker([])
self.follow = options.follow
if options.client_replay:
self.client_playback_path(options.client_replay)
if options.server_replay:
self.server_playback_path(options.server_replay)
self.view_stack = []
if options.app:
self.start_app(self.options.app_host, self.options.app_port)
signals.call_in.connect(self.sig_call_in)
signals.pop_view_state.connect(self.sig_pop_view_state)
signals.replace_view_state.connect(self.sig_replace_view_state)
signals.push_view_state.connect(self.sig_push_view_state)
signals.sig_add_log.connect(self.sig_add_log)
self.addons.add(options, *builtins.default_addons())
def build_menu(self, widget=None, title="", items=[], focused=None, cb=None, modal_keys=None):
self.cb = cb
walker = urwid.SimpleListWalker([self.button(token, token) for token in items])
self.listbox = urwid.ListBox(walker)
self.linebox = urwid.LineBox(self.listbox)
focused_index = 0
for index, token in enumerate(walker):
if token.button_text == focused:
# Need to account for the insertion of the title at the start (below), so
# we add 1
focused_index = index + 1
walker.insert(0, urwid.Text(title))
try:
self.listbox.set_focus(focused_index)
except:
pass
if not modal_keys:
modal_keys = {}
def make_func(x):
def handle_key(kv, ret, widget):
self.number_pressed(kv, x)
return handle_key
for x in xrange(10):
modal_keys[str(x)] = {
"fn" : make_func(x)
}
modal_keys['enter'] = { "fn" : self.confirm_action }
widget.open_overlay(self.linebox, modal_keys=modal_keys)
def __init__(self, sensor: ManagerObjSensor, node: ManagerObjNode,
alertLevels: List[ManagerObjAlertLevel]):
self.node = node
self.sensor = sensor
content = list()
content.append(urwid.Divider("="))
content.append(urwid.Text("Node"))
content.append(urwid.Divider("="))
temp = self._createNodeWidgetList(node)
self.nodePileWidget = urwid.Pile(temp)
content.append(self.nodePileWidget)
content.append(urwid.Divider())
content.append(urwid.Divider("="))
content.append(urwid.Text("Sensor"))
content.append(urwid.Divider("="))
temp = self._createSensorWidgetList(sensor)
self.sensorPileWidget = urwid.Pile(temp)
content.append(self.sensorPileWidget)
content.append(urwid.Divider())
content.append(urwid.Divider("="))
content.append(urwid.Text("Alert Levels"))
content.append(urwid.Divider("="))
temp = self._createAlertLevelsWidgetList(alertLevels)
self.alertLevelsPileWidget = urwid.Pile(temp)
content.append(self.alertLevelsPileWidget)
# use ListBox here because it handles all the
# scrolling part automatically
detailedList = urwid.ListBox(urwid.SimpleListWalker(content))
detailedFrame = urwid.Frame(
detailedList,
footer=urwid.Text("Keys: ESC - Back, Up/Down - Scrolling"))
self.detailedBox = urwid.LineBox(detailedFrame,
title="Sensor: " +
self.sensor.description)
def buildFrame(self, board):
'''returns the board widget'''
threadButtonList = []
for title, l, s, c, t in self.titles.items():
if self.uFilter:
if re.search(self.uFilter.lower(), title.lower()):
threadButton = urwid.Button(str(l), self.changeFrameThread)
threadInfo = urwid.Text(
self.info_text.format(str(s), str(c)))
threadList = [
threadButton,
urwid.Divider('-'),
urwid.Divider(),
urwid.Text(title),
urwid.Divider(),
urwid.Divider('-'), threadInfo
]
threadButtonList.append(
urwid.LineBox(urwid.Pile(threadList)))
else:
threadButton = urwid.Button(str(l), self.changeFrameThread)
threadInfo = urwid.Text(self.info_text.format(str(s), str(c)))
threadList = [
threadButton,
urwid.Divider('-'),
urwid.Divider(),
urwid.Text(title),
urwid.Divider(),
urwid.Divider('-'), threadInfo
]
threadButtonList.append(urwid.LineBox(urwid.Pile(threadList)))
self.parsedItems = len(threadButtonList)
catalogueButtons = urwid.GridFlow(threadButtonList, 30, 2, 2, 'center')
listbox = urwid.ListBox(urwid.SimpleListWalker([catalogueButtons]))
self.uvm.itemCount = len(threadButtonList)
return [listbox]
def __init__(self):
# self.warning = urwid.Text('')
self._component = "basic"
# To use 'user_data', set 'on_state_change'
radio_group = []
for key, title in conf.COMPONENTS.items():
# urwid.RadioButton(radio_group, title, on_state_change=self._handle_checkbox_change, user_data=key)
rb = urwid.RadioButton(radio_group, title)
# urwid.connect_signal(rb, "postchange", self._handle_checkbox_change, key)
urwid.connect_signal(rb, 'change', self._handle_checkbox_change,
key)
# radioboxes.append(rb)
choice = urwid.Pile(radio_group)
wrapped_btn = urwid.AttrWrap(
urwid.Button('Install', on_press=self._handle_button_click),
'button')
install_btn = urwid.Padding(wrapped_btn,
width=('relative', 10),
align='left',
min_width=12)
content = [
urwid.Divider(top=conf.DEFAULT_TOP_PADDING),
urwid.Text(('error', 'Choose Component to Install:')),
urwid.Divider(),
choice,
urwid.Divider(),
# urwid.AttrWrap(self.warning, 'warning'),
urwid.Divider(),
install_btn
]
widget = urwid.Padding(urwid.ListBox(urwid.SimpleListWalker(content)),
width=('relative', 50),
align="center")
# widget = urwid.AttrWrap(widget, 'body')
urwid.WidgetWrap.__init__(self, widget)
def __init__(self, ui, target=None):
self.ui = ui
if target:
tname = target.__class__.__name__
htxt = [urwid.Text("Help: " + tname)]
else:
htxt = [urwid.Text("Help")]
header = urwid.AttrMap(urwid.Columns(htxt), 'header')
pile = []
# format command help line
def fch(k, h):
return urwid.Columns([('fixed', 10, urwid.Text(k)),
urwid.Text(h),
])
if target:
for k, h in target.help():
if not k:
pile.append(urwid.Text(''))
pile.append(urwid.Text(''))
pile.append(urwid.Text(h))
pile.append(urwid.Text(''))
else:
pile.append(fch(k, h))
pile.append(urwid.Text(''))
pile.append(urwid.Text(''))
pile.append(urwid.Text('Global commands:'))
pile.append(urwid.Text(''))
for k, cmd in self.ui.keys.items():
f = getattr(ui, cmd)
h = str(getattr(f, '__doc__'))
pile.append(fch(k, h))
body = urwid.ListBox(urwid.SimpleListWalker(pile))
super(Help, self).__init__(body, header=header)
def main(self):
self.header = self.create_header()
self.footer = self.create_footer()
self.listbox = ViListBox(
self.key_bindings,
urwid.SimpleListWalker([
TodoWidget(t, self.key_bindings, self.colorscheme, self)
for t in self.todos.todo_items
]))
self.frame = urwid.Frame(urwid.AttrMap(self.listbox, 'plain'),
header=self.header,
footer=self.footer)
self.view = ViColumns(self.key_bindings, [('weight', 2, self.frame)])
self.loop = urwid.MainLoop(self.view,
self.palette,
unhandled_input=self.keystroke)
self.loop.screen.set_terminal_properties(colors=256)
self.loop.run()
def __init__(self, parent):
self.text = (
"Host Validation\n\nThe hosts have already been checked for "
"DNS and passwordless SSH. The next step is to 'probe' the hosts "
"to validate that their configuration matches the intended Ceph "
"role.")
self.probe_btn = ui_button(label='Probe',
align='center',
callback=self.probe)
self.next_btn = ui_button(label='Next',
align='right',
callback=self.next_page)
self.table_body = urwid.SimpleListWalker([])
self.table = urwid.ListBox(self.table_body)
self.table_footer = urwid.Text(
"Use arrow keys to move, 'space' to toggle the use of a host")
self.probed = False
UIBaseClass.__init__(self, parent)
def __init__(self, screen, auto_scroll):
"""Constructor. These objects should only be constructed by a parent
:class:`Screen` object.
:param screen: the :class:`Screen` building this code box
"""
self.screen = screen
self.auto_scroll = auto_scroll
# urwid does weird things when trying to focus an empty listing, never
# allow it to be empty
self.is_empty = True
self.walker = urwid.SimpleListWalker([
urwid.Text(''),
])
scroller = ScrollingIndicator()
self.listbox = ScrollingListBox(scroller, self.walker)
layout = [self.listbox, (1, scroller)]
super(CodeWidget, self).__init__(layout)
def create(self):
self.create_new_rant_button()
login_logout_btn = LogInLogOutBtn(
parent_widget=self,
login_action=self.parent_widget.get_trigger_show_login_widget())
rant_list_btn = urwid.AttrMap(
urwid.Button("Rants",
self.parent_widget.get_trigger_show_rant_list()),
'button normal', 'button select')
quit_btn = urwid.AttrMap(
urwid.Button("Quit", self.controller.exit_program()),
'button normal', 'button select')
options = [
rant_list_btn,
self.new_rant_button,
urwid.Divider(),
login_logout_btn,
quit_btn,
]
self.widget = urwid.Frame(urwid.ListBox(
urwid.SimpleListWalker([
urwid.AttrMap(option, None, focus_map='reversed')
for option in options
])),
header=urwid.WidgetWrap(
urwid.Pile([
urwid.AttrMap(
urwid.Text('Main menu',
align='center'),
'header'),
urwid.Divider(u'\u2500')
])),
focus_part='body')
def control_panel(self):
control_widgets = [
urwid.Text('Number of queens: ' + str(self.N)),
urwid.GridFlow([
self.button('-', self.on_decrease_button),
self.button('+', self.on_increase_button),
],
cell_width=5,
h_sep=2,
v_sep=0,
align='center'),
urwid.Divider(),
urwid.Text('Number of solutions: 0'),
urwid.GridFlow([self.button('Solve', self.on_solve_button)],
cell_width=9,
h_sep=0,
v_sep=0,
align='center'),
urwid.Divider(),
urwid.Text('Solution: 0', 'center'),
urwid.GridFlow([
self.button('Prev', self.on_prev_button),
self.button('Next', self.on_next_button),
],
cell_width=8,
h_sep=2,
v_sep=0,
align='center'),
urwid.Divider(),
urwid.Divider(),
urwid.Divider(),
urwid.GridFlow([self.button('Quit', self.quit)],
cell_width=8,
h_sep=0,
v_sep=0,
align='center'),
]
w = urwid.ListBox(urwid.SimpleListWalker(control_widgets))
return w
def make_unified_error_view(self, error_title):
blank = urwid.Divider()
status_header = urwid.AttrWrap(urwid.Text('Run Code Status: '), 'body')
status = urwid.AttrWrap(urwid.Text(error_title), 'hometag')
columns = urwid.Columns([(17, status_header), (30, status)])
column_wrap = urwid.WidgetWrap(columns)
if 'last_testcase' in self.result:
result_header = urwid.Text('--- Run Code Result: ---', align='center')
your_input_header = urwid.Text('Last executed input:')
your_input = urwid.Text(self.result['last_testcase'])
list_items = [
result_header,
blank, column_wrap,
blank, your_input_header, your_input,
]
else:
list_items = [
result_header,
blank, column_wrap,
]
self._append_stdout_if_non_empty(list_items)
return urwid.Padding(urwid.ListBox(urwid.SimpleListWalker(list_items)), left=2, right=2)
def __init__(self, connection, **args):
self.connection = connection
self.tables = []
self.searching = False
self.search_matches_idx = []
self.search_match_focus = 0
self.search_term = ''
self.tableslist = urwid.SimpleListWalker(self.get_tables_list())
listbox = CommonListBoxWidget(self.tableslist)
self.widget = urwid.LineBox(
listbox,
title="Tables"
)
def changed(**args):
selected_table = self.tableslist.get_focus()[0].base_widget.value
urwid.emit_signal(self, 'changed_table', selected_table)
urwid.connect_signal(self.tableslist, 'modified', changed)
urwid.WidgetWrap.__init__(self, self.widget)
def __init__(self, controller: Any, msg: Any) -> None:
self.controller = controller
self.msg = msg
if msg['reactions']:
reactions = sorted(
[reaction['emoji_name'] +
": " +
reaction['user']['full_name'] +
"\n"
for reaction in msg['reactions']])
reactions[-1] = reactions[-1].rstrip("\n")
msg_info = OrderedDict([
('Date & Time', time.ctime(msg['timestamp'])[:-5]),
('Sender', msg['sender_full_name']),
('Sender\'s Email ID', msg['sender_email']),
('Reactions', reactions if msg['reactions'] else '---None---'),
])
widths = [(len(field)+7,
max(len(reaction_users) for reaction_users in data)
if isinstance(data, list)
else len(data)+2)
for field, data in msg_info.items()]
max_widths = [max(width) for width in zip(*widths)]
self.width = sum(max_widths)
self.height = len(msg_info['Reactions'])+4 if msg['reactions'] else 5
self.log = urwid.SimpleListWalker(
[urwid.AttrWrap(
urwid.Columns([
urwid.Text(field),
(max_widths[1], urwid.Text(data))
], dividechars=2),
None if index % 2 else 'bar')
for index, (field, data) in enumerate(msg_info.items())])
super(MsgInfoView, self).__init__(self.log)
def main():
text_header = ('This is the header')
divider = urwid.Divider()
listbox_content = []
mons = monad.load_monads()
for mon in mons:
listbox_content.append(divider)
listbox_content.append(urwid.Padding(urwid.Text(mon.title),left=2,right=2,min_width=20))
header = urwid.AttrWrap(urwid.Text(text_header),'header')
listbox = urwid.ListBox(urwid.SimpleListWalker(listbox_content))
frame = urwid.Frame(urwid.AttrMap(listbox,'body'),header=header)
palette=[
('header','white','dark red','bold'),
('body','black','light gray','black')
]
def unhandled(key):
if key == 'f8':
raise urwid.ExitMainLoop()
urwid.MainLoop(frame,palette,unhandled_input=unhandled).run()
def __init__(self, options, server):
super().__init__(options, server)
self.view = view.View()
self.stream_path = None
# This line is just for type hinting
self.options = self.options # type: Options
self.options.errored.connect(self.options_error)
self.palette = options.palette
self.palette_transparent = options.palette_transparent
self.logbuffer = urwid.SimpleListWalker([])
self.view_stack = []
signals.call_in.connect(self.sig_call_in)
signals.pop_view_state.connect(self.sig_pop_view_state)
signals.replace_view_state.connect(self.sig_replace_view_state)
signals.push_view_state.connect(self.sig_push_view_state)
signals.sig_add_log.connect(self.sig_add_log)
self.addons.add(*addons.default_addons())
self.addons.add(intercept.Intercept(), self.view)
def build_board(self, kanban: Kanban):
"""Display Kanban board."""
column_list = []
for count, col in enumerate(kanban.columns):
list_content = []
# TODO title mejor en un objeto customizado
list_content.append(
urwid.AttrMap(urwid.Text(f'{count + 1}. {col.name}'),
'list_title'), )
for card in col.cards:
subtasks = None
if card.subtasks:
subtasks = (card.subtasks_completed(), len(card.subtasks))
list_content.append(
UICard(f'{card.name}',
desc=card.description,
subtasks=subtasks), )
col_content = urwid.SimpleListWalker(list_content)
listbox = urwid.ListBox(col_content)
column_list.append(listbox)
self.cols = MyColumns(column_list, dividechars=4, min_width=30)
padding = urwid.Padding(self.cols, left=2, right=2)
header = urwid.AttrMap(
urwid.Text('DAS: Android Final Project\n', align=urwid.CENTER),
'board_title')
footer = urwid.AttrMap(
urwid.Text([
# ('footer_text', u"Total cards: "),
# ('footer_item', u"11"),
# ('footer_separator', u" | "),
('footer_text', u"Help "),
('footer_item', u"?"),
]),
'footer')
# self.frame = urwid.Frame(body=padding, footer=footer)
self.frame = urwid.Frame(body=padding,
header=header,
footer=footer)
def build_interface(self):
"""
Call the widget methods to build the UI
"""
self.main_loop = None
self.header = urwid.Text(_("BlackHole Chat:"))
self.footer = urwid.Edit(u"> ")
self.divider = urwid.Text("Initializing.")
self.generic_output_walker = urwid.SimpleListWalker([])
self.body = ExtendedListBox(self.generic_output_walker)
self.header = urwid.AttrWrap(self.header, "divider")
self.footer = urwid.AttrWrap(self.footer, "footer")
self.divider = urwid.AttrWrap(self.divider, "divider")
self.body = urwid.AttrWrap(self.body, "body")
self.footer.set_wrap_mode("space")
main_frame = urwid.Frame(self.body,
header=self.header,
footer=self.divider)
self.context = urwid.Frame(main_frame, footer=self.footer)
self.divider.set_text(
("divider", (_("Send Message: Press [ESC] to quit."))))
self.context.set_focus("footer")
def __init__(self, data):
self.data = data
self.datak = list(data.keys())
self.list = urwid.SimpleListWalker([
urwid.AttrWrap(SelectableText(' - ' + x), 'normal', 'reveal focus')
for x in data.keys()
])
self.listbox = urwid.ListBox(self.list)
self.listbox.offset_rows = 1
self.columns = urwid.Columns(
[self.listbox,
urwid.Filler(urwid.Text(str(time())), 'top')])
self.header = urwid.Text("")
self.footer = urwid.AttrWrap(urwid.Text(self.footer_text), 'foot')
self.view = urwid.Frame(urwid.AttrWrap(self.columns, 'body'),
header=urwid.AttrWrap(self.header, 'head'),
footer=self.footer)
def __init__(self, srvapi, keymap, columns=None, sort=None, title=None):
self._srvapi = srvapi
self._keymap = keymap
if self.focusable_items:
self._ListItemClass = keymap.wrap(self.ListItemClass,
context=self.keymap_context)
else:
self._ListItemClass = self.ListItemClass
self._items = ()
self._marked = set()
self._columns = columns or []
self._sort = sort
self._sort_orig = sort
self._title_name = title
self.title_updater = None
self._table = Table(**self.tuicolumns)
self._table.columns = self._columns
if self.focusable_items:
walker = urwid.SimpleFocusListWalker([])
else:
walker = urwid.SimpleListWalker([])
self._listbox = keymap.wrap(urwid.ListBox,
context=self.keymap_context +
'list')(walker)
listbox_sb = urwid.AttrMap(
ScrollBar(urwid.AttrMap(self._listbox, self.palette_name)),
'scrollbar')
pile = urwid.Pile([('pack',
urwid.AttrMap(self._table.headers,
self.palette_name + '.header')),
listbox_sb])
super().__init__(pile)
def update_stories(self, stories):
""" Reload listbox and walker with new stories """
items = []
item_ids = []
for story in stories:
if story.id is not None and story.id in item_ids:
story.title = "- %s" % story.title
items.append(
ItemWidget(story, self.show_published_time,
self.show_score, self.show_comments))
else:
items.append(
ItemWidget(story, self.show_published_time,
self.show_score, self.show_comments))
item_ids.append(story.id)
if self.already_build:
self.walker[:] = items
self.update()
else:
self.walker = urwid.SimpleListWalker(items)
self.listbox = urwid.ListBox(self.walker)
def buildFrame(self):
boardButtons = []
for board in self.boardList:
if self.uFilter:
if self.uFilter.lower() in board.lower():
boardButtons.append(
urwid.LineBox(
urwid.AttrWrap(
urwid.Button(board, self.changeFrameBoard),
'center')))
else:
boardButtons.append(
urwid.LineBox(
urwid.AttrWrap(
urwid.Button(board, self.changeFrameBoard),
'center')))
self.parsedItems = len(boardButtons)
buttonGrid = urwid.GridFlow(boardButtons, 12, 2, 2, 'center')
listbox_content = [buttonGrid]
return urwid.ListBox(urwid.SimpleListWalker(listbox_content))
def __init__(self):
self.submitted = Event()
self.text_changed = Event()
self.auto_encrypt_toggled = Event()
self.title_map = urwid.AttrMap(
urwid.Text('Caesar Cipher', align='center'), 'title')
self.help_map = urwid.AttrMap(
urwid.Text('Esc: quit Up/Down: shift between fields'), 'title')
self.text_edit = urwid.Edit(caption='Text: ')
urwid.connect_signal(self.text_edit, 'change',
self._text_input_changed)
self.text_edit_map = field_attr(self.text_edit)
self.key_edit = urwid.IntEdit(caption='Key: ')
self.key_edit_map = field_attr(self.key_edit)
self.auto_encrypt_checkbox = urwid.CheckBox(label='Auto-Encrypt',
has_mixed=False)
urwid.connect_signal(self.auto_encrypt_checkbox, 'change',
self._auto_encrypt_state_changed)
self.auto_encrypt_map = field_attr(self.auto_encrypt_checkbox)
self.result_text = urwid.Text('')
self.result_text_map = field_attr(self.result_text)
self.encode_button = urwid.Button('Encode')
self.encode_button_map = field_attr(self.encode_button)
urwid.connect_signal(self.encode_button, 'click', self._submit_clicked)
self.body_content = urwid.SimpleListWalker([
self.text_edit_map,
urwid.Divider(), self.key_edit_map,
urwid.Divider(), self.auto_encrypt_map,
urwid.Divider(), self.result_text_map,
urwid.Divider(), self.encode_button_map
])
self.body_listbox = urwid.ListBox(self.body_content)
self.overlay_bottom = urwid.Frame(urwid.SolidFill(),
header=self.title_map,
footer=self.help_map)
self.overlay_bottom_map = urwid.AttrMap(self.overlay_bottom, 'bg')
self.top = urwid.Overlay(self.body_listbox, self.overlay_bottom_map,
'center', ('relative', 50), 'middle',
('relative', 50))
def keystroke(self, input):
if input in ('q', 'Q'):
raise urwid.ExitMainLoop()
elif input in ['esc', ':']:
self.focus = self.listbox.get_focus()
self.set_command()
elif input in ["c"]:
self.focus = self.listbox.get_focus()
self.type_comment()
elif input in ["enter"]:
self.focus = self.listbox.get_focus()
#if focus is "---Load More News---", load more stories
if isinstance(self.run_time_list[self.focus[1]], StoryWidget):
self.storyList = self.r.load_more()
self.load_stories(self.storyList)
self.listbox = urwid.ListBox(urwid.SimpleListWalker(
self.items))
self.view = urwid.Frame(urwid.AttrWrap(self.listbox, 'body'))
self.loop.widget = self.view
self.view.get_body().set_focus(len(self.storyList.stories))
#if focus is on the title of news, show or close comment page
elif isinstance(self.items[self.focus[1]], StoryWidget):
now_focus = self.focus[1]
#if comment page is open, close it
if self.focus[0].opened:
self.close_comment(self.focus[1])
self.view.get_body().set_focus(now_focus)
self.focus[0].opened = False
#if comment page not open, open it
else:
item = self.run_time_list[self.focus[1]]
if isinstance(item, base.Story):
storyID = item.storyID
self.run_time_list[
self.focus[1]] = self.r.load_comments(storyID)
self.showComment(self.focus[1])
self.view.get_body().set_focus(now_focus)
self.focus[0].opened = True
def screenUI(self):
#Define your text labels, text fields, and buttons first
text1 = TextLabel(u"Choose repo mirrors to use.\n"
u"Note: Refer to Fuel documentation on how to set "
u" up a custom mirror.")
choice_list = [u"Default", u"Custom"]
self.choices = ChoicesGroup(self, choice_list)
self.repochoice = "Default"
self.edit1 = TextField("custom_mirror", "Custom URL:", 15,
DEFAULTS["custom_mirror"], "URL goes here",
self.parent.footer)
self.edit2 = TextField("parent_proxy", "Squid parent proxy:", 20,
DEFAULTS["parent_proxy"],
"Squid proxy URL (include http://)",
self.parent.footer)
self.edit3 = TextField("port", "Port:", 5, DEFAULTS["parent_proxy"],
"Squid Proxy port (usually 3128)",
self.parent.footer)
self.proxyedits = Columns([('weight', 3, self.edit2), self.edit3])
#Button to check
button_check = Button("Check", self.check)
#Button to apply (and check again)
button_apply = Button("Apply", self.apply)
#Wrap into Columns so it doesn't expand and look ugly
check_col = Columns([button_check, button_apply, ('weight', 7, blank)])
#Build all of these into a list
self.listbox_content = [
text1, blank, blank, self.choices, blank, self.edit1, blank,
self.proxyedits, blank, blank, check_col
]
#Add everything into a ListBox and return it
walker = urwid.SimpleListWalker(self.listbox_content)
#urwid.connect_signal(walker, 'modified', self.displayTooltip)
self.myscreen = urwid.ListBox(walker)
return self.myscreen
