def menuVAOnlyMenu(
title, avail_stream_VideoO, avail_stream_audioO
): ###menu displaying formats with only audio or video ## must handle cases with audio and video alone ## for 3rd loop
body = [urwid.Text(title), urwid.Divider()]
for x in avail_stream_VideoO:
button = urwid.Button(
str(x).split('@', 1)[0] + "---->" + x.resolution + "----->" +
str((float(x.get_filesize()) / 1024) / 1024))
urwid.connect_signal(button, 'click', chosen_URL, x)
body.append(urwid.AttrMap(button, None, focus_map='reversed'))
for x1 in avail_stream_audioO:
button = urwid.Button(str(x1))
urwid.connect_signal(button, 'click', chosen_URL, x1)
body.append(urwid.AttrMap(button, None, focus_map='reversed'))
button = urwid.Button("EXIT")
urwid.connect_signal(button, 'click', exit_program)
body.append(urwid.AttrMap(button, None, focus_map='reversed'))
return urwid.ListBox(urwid.SimpleFocusListWalker(body))
def __init__(self, conversation, close_callback, keybindings):
rename_dialog = RenameConversationDialog(
conversation,
lambda: frame.contents.__setitem__('body', (list_box, None)),
close_callback)
items = [
urwid.Text('Conversation name: {}'.format(
get_conv_name(conversation))),
urwid.Button('Change Conversation Name',
on_press=lambda _: frame.contents.__setitem__(
'body', (rename_dialog, None))),
urwid.Divider('-'),
urwid.Button('Back', on_press=lambda _: close_callback()),
]
list_walker = urwid.SimpleFocusListWalker(items)
list_box = urwid.ListBox(list_walker)
frame = urwid.Frame(list_box)
padding = urwid.Padding(frame, left=1, right=1)
line_box = urwid.LineBox(padding, title='Conversation Menu')
super().__init__(line_box)
self._keys = keybindings
def quit_prompt(self):
"""Pop-up window that appears when you try to quit."""
text = "Changes have been made. Quit?"
question = ur.Text(("bold", text), "center")
cancel_btn = ur.AttrMap(ur.Button(
"Cancel", self.prompt_answer, "cancel"), "title", None)
save_btn = ur.AttrMap(ur.Button(
"Save", self.prompt_answer, "save"), "title", None)
quit_btn = ur.AttrMap(ur.Button(
"Quit", self.prompt_answer, "quit"), "red", None)
prompt = ur.LineBox(ur.ListBox(ur.SimpleFocusListWalker(
[question, BLANK, BLANK, cancel_btn, save_btn, quit_btn])))
overlay = ur.Overlay(
prompt, self.loop.widget,
"center", 19, "middle", 9,
16, 8)
self.loop.widget = overlay
def __init__(self, streams_btn_list: List[Any], view: Any) -> None:
self.view = view
self.log = urwid.SimpleFocusListWalker(streams_btn_list)
self.streams_btn_list = streams_btn_list
self.focus_index_before_search = 0
list_box = urwid.ListBox(self.log)
self.stream_search_box = PanelSearchBox(self, 'SEARCH_STREAMS')
urwid.connect_signal(self.stream_search_box, 'change',
self.update_streams)
super(StreamsView,
self).__init__(list_box,
header=urwid.LineBox(self.stream_search_box,
tlcorner=u'─',
tline=u'',
lline=u'',
trcorner=u'─',
blcorner=u'─',
rline=u'',
bline=u'─',
brcorner=u'─'))
self.search_lock = threading.Lock()
def __init__(self, app, query, query_desc=None, unreviewed=False):
super(ChangeListView, self).__init__(urwid.Pile([]))
self.app = app
self.query = query
self.query_desc = query_desc or query
self.unreviewed = unreviewed
self.change_rows = {}
self.listbox = urwid.ListBox(urwid.SimpleFocusListWalker([]))
self.display_owner = self.display_project = True
if '_project_key' in query:
self.display_project = False
self.header = ChangeListHeader(self.display_project,
self.display_owner)
self.categories = []
self.refresh()
self._w.contents.append((app.header, ('pack', 1)))
self._w.contents.append((urwid.Divider(), ('pack', 1)))
self._w.contents.append((urwid.AttrWrap(self.header,
'table-header'), ('pack', 1)))
self._w.contents.append((self.listbox, ('weight', 1)))
self._w.set_focus(3)
def _form_inputs(self):
contents = [
self._types_input(),
generic.box_solid_fill(" ", 1),
self._statuses_input(),
generic.box_solid_fill(" ", 1),
self._priorities_input(),
generic.box_solid_fill(" ", 1),
self._severities_input(),
generic.box_solid_fill(" ", 1),
self._assigned_to_input(),
generic.box_solid_fill(" ", 1),
self._created_by_input(),
# TODO
#generic.box_solid_fill(" ", 1),
#self._tags_input(),
]
list_walker = urwid.SimpleFocusListWalker(contents)
list_walker.set_focus(0)
return urwid.BoxAdapter(urwid.ListBox(list_walker), 20)
def __init__(self, controller: Any, question: Any,
success_callback: Callable[[], bool]):
self.controller = controller
self.success_callback = success_callback
yes = urwid.Button(u'Yes', self.exit_popup_yes)
no = urwid.Button(u'No', self.exit_popup_no)
yes._w = urwid.AttrMap(urwid.SelectableIcon(
'Yes', 4), None, 'selected')
no._w = urwid.AttrMap(urwid.SelectableIcon(
'No', 4), None, 'selected')
display_widget = urwid.GridFlow([yes, no], 3, 5, 1, 'center')
wrapped_widget = urwid.WidgetWrap(display_widget)
prompt = urwid.LineBox(
urwid.ListBox(
urwid.SimpleFocusListWalker(
[question, urwid.Divider(), wrapped_widget]
)))
urwid.Overlay.__init__(self, prompt, self.controller.view,
align="left", valign="top",
width=self.controller.view.LEFT_WIDTH+1,
height=8)
def create_tasks_menu(self):
"""Renders title and bottom line and in the middle a scrollable table of tasks with their duration"""
body = [urwid.Text(self.title), urwid.Divider()]
for task in self.taskmanager.tasks_by(self.sort_order):
button = TaskButtonWrap(task)
urwid.connect_signal(button.button, "click",
self.toggle_recording_task, task)
if task == self.current_task:
button = urwid.AttrMap(button, "standout-fg")
else:
button = urwid.AttrMap(button, "normal", "active-bg")
task.button = button
body.append(button)
body += [
urwid.Divider(), self.message_box,
urwid.Divider(),
urwid.Text(help_line)
]
return urwid.Padding(urwid.ListBox(urwid.SimpleFocusListWalker(body)),
left=0,
right=0)
def main():
palette = [
('header', 'light gray', 'black'),
('title', 'white', 'black'),
('focus', 'light gray,standout', 'black'),
]
def exit_on_q(input):
if input in ('q', 'Q'):
raise urwid.ExitMainLoop()
token = fioread.get_token()
statement = fioread.FioConnection(token).last()
info = statement.account
header_text = [
('title', "Fio Statement Viewer"), " for ",
('account', info.accountId + "/" + info.bankId), " ",
('bold', info.dateStart[:10]), "-", ('bold', info.dateEnd[:10]), " ",
"(", ('bold', str(info.openingBalance)), "-", ('bold', str(info.closingBalance)), ")",
]
walker = urwid.SimpleFocusListWalker([])
balance = info.openingBalance
def wrap(text):
w = SelectableText(text)
w = urwid.AttrMap(w, {}, {None: 'focus'})
return w
for transaction in statement.transactions:
transaction['balance'] = balance = balance + transaction.amount
walker.append(wrap("%(date).10s %(balance)10s %(amount)10s %(currency)s %(comment)30s" % fioread.default(transaction)))
header = urwid.AttrMap(urwid.Text(header_text), 'header')
listbox = urwid.ListBox(walker)
view = urwid.Frame(listbox, header=header)
loop = urwid.MainLoop(view, palette, unhandled_input=exit_on_q)
loop.run()
def filter_task_state(app):
"""Return a widget for adjusting the task state filter."""
def toggle(state, *_):
"""Toggle a filter state."""
app.filter_states[state] = not app.filter_states[state]
checkboxes = [
urwid.CheckBox(
get_task_icon(state)
+ [' ' + state],
state=is_on,
on_state_change=partial(toggle, state)
)
for state, is_on in app.filter_states.items()
]
def invert(*_):
"""Invert the state of all filters."""
for checkbox in checkboxes:
checkbox.set_state(not checkbox.state)
widget = urwid.ListBox(
urwid.SimpleFocusListWalker([
urwid.Text('Filter Task States'),
urwid.Divider(),
urwid.Padding(
urwid.Button(
'Invert',
on_press=invert
),
right=19
)
] + checkboxes)
)
return (
widget,
{'width': 35, 'height': 23}
)
def __init__(self, word, pos, definition, all_options, selected):
self._all_options = all_options
self._selected_items = selected
self.footer_text = (
"foot",
[
f"{word} ({pos}) ",
("key", "r"),
" select random ",
("key", "s"),
" save ",
("key", "q"),
" quit",
],
)
title = f"{word} {pos}"
body = []
self._checkboxes = []
for idx in range(len(all_options)):
checkbox = urwid.CheckBox("")
urwid.connect_signal(checkbox, "change", self.item_chosen, idx)
self._checkboxes.append(checkbox)
body.append(checkbox)
self.update_list()
self.listbox = urwid.ListBox(urwid.SimpleFocusListWalker(body))
self.definition = urwid.Text(definition)
self.textbox = urwid.ListBox([self.definition])
self.columns = urwid.Columns([(60, self.textbox), self.listbox],
dividechars=3,
focus_column=1)
self.footer = urwid.AttrWrap(urwid.Text(self.footer_text), "foot")
self.view = urwid.Frame(urwid.AttrWrap(self.columns, "body"),
footer=self.footer)
def select4(self):
select4 = len(self.devices[self.interface]['ip4']) > 1
if select4:
text = urwid.AttrWrap(urwid.Text("Select the IPv4 address to use"), 'header')
content = [text, urwid.Divider()]
for i in self.devices[self.interface]['ip4']:
content.append(self.menu_button("%s %s" % (i['ip'], i['mask']), self.select4_callback, self.devices[self.interface]['ip4'].index(i)))
box = urwid.ListBox(urwid.SimpleFocusListWalker(content))
self.set_body(urwid.Overlay(urwid.LineBox(box),
self.body,
align='center', width=('relative', 80),
valign='middle', height=('relative', 80),
min_width=24, min_height=8))
return
else:
if len(self.devices[self.interface]['ip4']) > 0:
self.ip = self.devices[self.interface]['ip4'][0]['ip']
self.mask = self.devices[self.interface]['ip4'][0]['mask']
else:
self.ip = "0.0.0.0"
self.mask ="0.0.0.0"
self.select6()
def get_history(self):
while self.updateLocked:
time.sleep(0.5)
self.updateLocked = True
self.separator_pos = -1
current_cmd = self.Telegram_ui.current_chan['id']
if current_cmd not in self.prev_date:
self.prev_date[current_cmd] = 1
# deletion of previous messages
self.msg_list = urwid.SimpleFocusListWalker(
[urwid.Text(('top', " "), align='left')])
super().__init__(self.msg_list)
self.pos = 0
if current_cmd not in self.Telegram_ui.msg_buffer:
current_print_name = self.Telegram_ui.current_chan['print_name']
try:
msgList = self.Telegram_ui.sender.history(
current_print_name, 100)
except:
msgList = []
self.Telegram_ui.msg_buffer[current_cmd] = msgList
if current_cmd not in self.Telegram_ui.msg_archive:
self.Telegram_ui.msg_archive[current_cmd] = []
else:
self.print_msg_archive()
for msg in self.Telegram_ui.msg_buffer[current_cmd]:
self.print_msg(msg)
# messages have been printed, deletion form buffer (they are in archive now)
self.Telegram_ui.msg_buffer[current_cmd] = []
self.draw_separator()
self.updateLocked = False
def live_sub(button, m_id):
texts = []
live_list = []
for x in live_scrape():
for y in x['games']:
live_list.append(y)
texts.append(
urwid.Text('Live professional matches being played right now'))
texts.append(urwid.Text(''))
if len(live_list) > 0:
for x in live_list:
r_name = x['radiant_team']['team_name']
d_name = x['dire_team']['team_name']
if r_name == '':
r_name = 'Radiant'
if d_name == '':
d_name = 'Dire'
if x['league']['name'] == '':
league_line = 'Independent'
else:
league_line = x['league']['name']
match_line = "{} vs {}".format(r_name, d_name)
match_id = str(x['id'])
texts.append(
menu_button("{}\n{}".format(league_line, match_line),
callback=item_chosen,
m_id=[match_id]))
texts.append(urwid.Text(''))
done = menu_button('Return to main menu', m_id=m_id, callback=go_back)
texts.append(done)
texts.append(urwid.Text(''))
td_link = urwid.Button('Powered by TrackDota [https://www.trackdota.com]')
texts.append(urwid.AttrMap(td_link, None, focus_map='reversed'))
urwid.connect_signal(td_link,
'click',
open_link,
user_arg='https://www.trackdota.com/')
pile = urwid.ListBox(urwid.SimpleFocusListWalker(texts))
top.open_box(pile, title='dotaticker - Live Matches')
def set_frame(self, focus_part='body'):
"""
Add all widgets into a frame.
"""
if self.text is not None:
self.body = [urwid.Text(self.text), urwid.Divider()] + self.body
self.contents = urwid.SimpleFocusListWalker(self.body)
list_box = urwid.ListBox(self.contents)
frame = urwid.Frame(urwid.LineBox(list_box), focus_part=focus_part)
if self.title is not None:
title_markup = self.title if isinstance(
self.title, tuple) else ('title', self.title)
title_wid = urwid.Text(title_markup, align='center')
frame.header = urwid.Pile([title_wid, urwid.Divider()])
if self.buttons:
button_grid = urwid.GridFlow(self.buttons, 10, 3, 1, 'right')
frame.footer = urwid.Pile([button_grid])
return frame
def __init__(self, config):
self._configure(config)
self._subsources_list_iter = itertools.cycle(self._subsources_list)
self.listbox_w = w = urwid.ListBox(urwid.SimpleFocusListWalker([]))
w._command_map = CommandMap(
{
"k": "cursor up",
"up": "cursor up",
"j": "cursor down",
"down": "cursor down",
}
)
self.content_wrapper = w = urwid.WidgetPlaceholder(w)
w = linebox(w, self._default_title)
self._linebox_w = w.original_widget # XXX: not elegant
urwid.WidgetWrap.__init__(self, w)
self.next_subsource()
def menu(title, text, choices, checkbox, top_level=False):
text = '' if not text else text
body = [
urwid.Text(title),
urwid.Divider(),
urwid.Text(text),
urwid.Divider()
]
body.extend(choices)
if not top_level:
body.append(
menu_btn_group(choices_checkbox=choices,
sel_all_btn=checkbox,
apply_btn=checkbox))
menu_obj = urwid.ListBox(urwid.SimpleFocusListWalker(body))
menu_obj.checkbox = checkbox
if checkbox:
menu_obj.checkbox_group = choices
return menu_obj
def __init__(self, config, search_query=None):
self.__pass_dir = os.environ.get('PASSWORD_STORE', os.path.expanduser('~/.password-store'))
self.current = ''
self.mode = Mode.BASE
self.header = ui.AttrWrap(ui.Text(HEADER_BASE_TEXT), Part.HEADER.value)
listbox_content = ui.SimpleFocusListWalker([ui.Text('')])
self.command_box = CommandBox(("highlight", ": "))
self.box = FancyListBox(listbox_content)
self.box._app = self
self.last_query = search_query or 'gpg'
self.keys = {'q': self._quit,
':': partial(self._set_mode, Mode.COMMAND),
'b': self._revert_state,
'r': self._reload_state,
'esc': partial(self._set_mode, Mode.BASE),
'enter': self._process_command}
self.frame = ui.Frame(self.box, header=self.header, footer=self.command_box)
self.loop = ui.MainLoop(self.frame, self.palette, unhandled_input=self._unhandled)
self._set_mode(mode=Mode.BASE, originator=self)
self._perform_search(search_query)
def _get_events(self, day):
"""get all events on day, return a DateListBox of `U_Event()`s
:type day: datetime.date
"""
event_list = list()
date_header = DateHeader(
day=day,
dateformat=self._conf['locale']['longdateformat'],
conf=self._conf,
)
event_list.append(urwid.AttrMap(date_header, 'date'))
self.events = sorted(self._collection.get_events_on(day))
event_list.extend([
urwid.AttrMap(
U_Event(event, conf=self._conf, this_date=day, delete_status=self.delete_status),
'calendar ' + event.calendar, 'reveal focus')
for event in self.events])
return urwid.BoxAdapter(
DateListBox(urwid.SimpleFocusListWalker(event_list), date=day),
(len(event_list) + 1) if self.events else 1
)
def delete_extension_display(self, button):
body = []
text = urwid.Text(u'Delete Extension')
body.append(text)
body.append(urwid.Divider())
folder = urwid.Text(self.opened_folder)
body.append(folder)
for extension in self.data[self.opened_folder]:
button = urwid.Button(extension)
urwid.connect_signal(button, 'click', self.verify_delete_extension)
body.append(urwid.AttrMap(button, None, focus_map='delete'))
body.append(urwid.Divider())
cancel = urwid.Button(u'Cancel')
urwid.connect_signal(cancel, 'click', self.make_open_folder_display)
body.append(urwid.AttrMap(cancel, None, focus_map='selected'))
self.main_widget.original_widget = urwid.ListBox(
urwid.SimpleFocusListWalker(body))
def pop_sub(button, m_id):
texts = []
pop_list = []
for x in pop_scrape():
pop_list.append(x)
texts.append(
urwid.Text('Matches played within the last 24 hours with\
over 3,000 spectators'))
texts.append(urwid.Text(''))
if len(pop_list) > 0:
for x in pop_list:
r_name = x['radiant_team']['team_name']
d_name = x['dire_team']['team_name']
if r_name == '':
r_name = 'Radiant'
if d_name == '':
d_name = 'Dire'
if x['league']['name'] == '':
league_line = 'Independent'
else:
league_line = x['league']['name']
match_line = "{} vs {}".format(r_name, d_name)
match_id = str(x['id'])
texts.append(
menu_button("{}\n{}".format(league_line, match_line),
callback=item_chosen,
m_id=[match_id]))
texts.append(urwid.Text(''))
done = menu_button('Return to main menu', m_id=m_id, callback=go_back)
texts.append(done)
texts.append(urwid.Text(''))
td_link = urwid.Button('Powered by TrackDota [https://www.trackdota.com]')
texts.append(urwid.AttrMap(td_link, None, focus_map='reversed'))
urwid.connect_signal(td_link,
'click',
open_link,
user_arg='https://www.trackdota.com/')
pile = urwid.ListBox(urwid.SimpleFocusListWalker(texts))
top.open_box(pile, title='dotaticker - Most Popular Matches')
def verify_delete_extension(self, button):
self.extension_to_delete = button.get_label()
text = urwid.Text(u'Delete extension <{}>?'.format(
self.extension_to_delete))
delete = urwid.Button(u'Delete')
urwid.connect_signal(delete, 'click', self.delete_extension)
cancel = urwid.Button(u'Cancel')
urwid.connect_signal(cancel, 'click',
self.back_to_opened_folder_display)
body = [
text,
urwid.Divider(),
urwid.AttrMap(delete, None, focus_map='delete'),
urwid.AttrMap(cancel, None, focus_map='selected')
]
self.main_widget.original_widget = urwid.ListBox(
urwid.SimpleFocusListWalker(body))
def m_welcome():
button_game = urwid.AttrMap(b_game, None, focus_map='reversed')
button_quit = urwid.AttrMap(b_quit, None, focus_map='reversed')
buttons_list = urwid.ListBox(
urwid.SimpleFocusListWalker([button_game, button_quit]))
buttons_flow = urwid.BoxAdapter(buttons_list, 2)
buttons = urwid.Filler(buttons_flow, valign='bottom')
pile = urwid.Pile([('pack', urwid.Divider()), ('weight', 5, title),
('weight', 1, buttons)])
return urwid.Overlay(urwid.LineBox(pile, title='Welcome'),
urwid.SolidFill(' '),
align='center',
width=('relative', 50),
valign='middle',
height=('relative', 50),
min_width=100,
min_height=25)
def __init__(self, main_loop):
self._main_loop = main_loop
self._header = urwid.Text("")
self._list = urwid.ListBox(urwid.SimpleFocusListWalker([]))
self._layout = urwid.BoxAdapter(self._list,
0) # Dynamically change size
self._edit_box = urwid.Edit()
self._queue = Queue()
self._lock = RLock(
) # It's important this is an RLock instead of a Lock
self.previous_prompt = False
# Initialize the pile.
self._pile = urwid.Pile([
urwid.AttrWrap(self._header, "reversed"), self._layout,
self._edit_box
])
self._edit_box.keypress = self.keypress # !
self._pile.focus_item = self._edit_box
def __init__(self, parent, mind):
text = """
write me, help!
help!"""
utext = urwid.Text(text, align="left")
body = [utext]
back_button = urwid.Button("Back")
back_button._label.align = "center"
urwid.connect_signal(back_button, "click", self.back)
body.append(urwid.AttrMap(back_button, None, focus_map="line"))
listbox = urwid.ListBox(urwid.SimpleFocusListWalker(body))
overlay = urwid.Overlay(listbox,
urwid.SolidFill(u"\N{MEDIUM SHADE}"),
align="center",
width=("relative", 60),
valign="middle",
height=("relative", 60),
min_width=40,
min_height=16)
super(HelpFrame, self).__init__(parent, mind, overlay)
async def input_name_version(widget_cb):
result = create_future()
name_edit = urwid.Edit("名称： ")
version_edit = urwid.Edit("版本： ")
submit_button = urwid.Button("确认")
def submit(_):
result.set_result((name_edit.edit_text, version_edit.edit_text))
urwid.connect_signal(submit_button, "click", submit)
widget = urwid.Padding(
urwid.ListBox(
urwid.SimpleFocusListWalker(
[name_edit, version_edit, submit_button])),
align="center",
width=("relative", 30),
)
widget_cb(widget)
return await result
def __init__(self, controller: Any) -> None:
self.controller = controller
widths = [(len(binding['help_text']) + 4,
len(", ".join(binding['keys'])))
for binding in KEY_BINDINGS.values()]
max_widths = [max(width) for width in zip(*widths)]
self.width = sum(max_widths)
self.log = urwid.SimpleFocusListWalker([
urwid.AttrWrap(
urwid.Columns([
urwid.Text(binding['help_text']),
(max_widths[1], urwid.Text(", ".join(binding['keys'])))
],
dividechars=2), None if index % 2 else 'help')
for index, binding in enumerate(KEY_BINDINGS.values())
])
self.height = len(self.log)
super(HelpView, self).__init__(self.log)
def __init__(self, controller: Any) -> None:
self.controller = controller
self.log = urwid.SimpleFocusListWalker([
urwid.Text("Press q to quit.", align='center')
])
for _, binding in KEY_BINDINGS.items():
commands = ", ".join(binding['keys'])
self.log.append(
urwid.Columns([
urwid.LineBox(
urwid.Text(binding['help_text']),
tlcorner=' ', tline=' ', lline=' ', trcorner=' ',
blcorner=' ', rline=' ', bline='-', brcorner=' '
),
urwid.LineBox(
urwid.Text(commands),
tlcorner=' ', tline=' ', lline=' ', trcorner=' ',
blcorner=' ', rline=' ', bline='-', brcorner=' '
)
])
)
super(HelpView, self).__init__(self.log)
def menu_view(self) -> Any:
count = self.model.unread_counts.get('all_msg', 0)
self.view.home_button = HomeButton(self.controller,
count=count,
width=self.width)
count = self.model.unread_counts.get('all_pms', 0)
self.view.pm_button = PMButton(self.controller,
count=count,
width=self.width)
# Starred messages are by definition read already
self.view.starred_button = StarredButton(self.controller,
width=self.width)
menu_btn_list = [
self.view.home_button,
self.view.pm_button,
self.view.starred_button,
]
w = urwid.ListBox(urwid.SimpleFocusListWalker(menu_btn_list))
return w
def __init__(self):
def selectButton(radio_button, new_state, parameter):
if new_state:
closeOverlay()
self._select(parameter)
super().__init__(urwid.SimpleFocusListWalker([]))
buttons = []
for i, item in enumerate(self._items()):
if isinstance(item, urwid.Widget):
self.body.append(item)
continue
elif isinstance(item, tuple):
name, selected, parameter = item
else:
parameter = name = item
selected = False
self.body.append(
urwid.RadioButton(buttons, name, selected, selectButton,
parameter))
if selected:
self.set_focus(i)
