def apply(self, ui):
logging.debug('HELP')
if self.commandname == 'bindings':
text_att = settings.get_theming_attribute('help', 'text')
title_att = settings.get_theming_attribute('help', 'title')
section_att = settings.get_theming_attribute('help', 'section')
# get mappings
globalmaps, modemaps = settings.get_keybindings(ui.mode)
# build table
maxkeylength = len(
max(list(modemaps.keys()) + list(globalmaps.keys()), key=len))
keycolumnwidth = maxkeylength + 2
linewidgets = []
# mode specific maps
if modemaps:
txt = (section_att, '\n%s-mode specific maps' % ui.mode)
linewidgets.append(urwid.Text(txt))
for (k, v) in modemaps.items():
line = urwid.Columns([('fixed', keycolumnwidth,
urwid.Text((text_att, k))),
urwid.Text((text_att, v))])
linewidgets.append(line)
# global maps
linewidgets.append(urwid.Text((section_att, '\nglobal maps')))
for (k, v) in globalmaps.items():
if k not in modemaps:
line = urwid.Columns([('fixed', keycolumnwidth,
urwid.Text((text_att, k))),
urwid.Text((text_att, v))])
linewidgets.append(line)
body = urwid.ListBox(linewidgets)
titletext = 'Bindings Help (escape cancels)'
box = DialogBox(body,
titletext,
bodyattr=text_att,
titleattr=title_att)
# put promptwidget as overlay on main widget
overlay = urwid.Overlay(box, ui.root_widget, 'center',
('relative', 70), 'middle',
('relative', 70))
ui.show_as_root_until_keypress(overlay, 'esc')
else:
logging.debug('HELP %s', self.commandname)
parser = commands.lookup_parser(self.commandname, ui.mode)
if parser:
ui.notify(parser.format_help(), block=True)
else:
ui.notify('command not known: %s' % self.commandname,
priority='error')
def setup_view(self):
fonts = urwid.get_all_fonts()
# setup mode radio buttons
self.font_buttons = []
group = []
utf8 = urwid.get_encoding_mode() == "utf8"
for name, fontcls in fonts:
font = fontcls()
if font.utf8_required and not utf8:
rb = self.create_disabled_radio_button(name)
else:
rb = self.create_radio_button(group, name, font,
self.set_font_event)
if fontcls == urwid.Thin6x6Font:
chosen_font_rb = rb
exit_font = font
self.font_buttons.append(rb)
# Create BigText
self.bigtext = urwid.BigText("", None)
bt = SwitchingPadding(self.bigtext, 'left', None)
bt = urwid.AttrWrap(bt, 'bigtext')
bt = urwid.Filler(bt, 'bottom', None, 7)
bt = urwid.BoxAdapter(bt, 7)
# Create chars_avail
cah = urwid.Text("Characters Available:")
self.chars_avail = urwid.Text("", wrap='any')
ca = urwid.AttrWrap(self.chars_avail, 'chars')
chosen_font_rb.set_state(True) # causes set_font_event call
# Create Edit widget
edit = self.create_edit("", "Urwid " + urwid.__version__,
self.edit_change_event)
# ListBox
chars = urwid.Pile([cah, ca])
fonts = urwid.Pile([urwid.Text("Fonts:")] + self.font_buttons,
focus_item=1)
col = urwid.Columns([('fixed', 16, chars), fonts], 3, focus_column=1)
bt = urwid.Pile([bt, edit], focus_item=1)
l = [bt, urwid.Divider(), col]
w = urwid.ListBox(l)
# Frame
w = urwid.AttrWrap(w, 'body')
hdr = urwid.Text("Urwid BigText example program - F8 exits.")
hdr = urwid.AttrWrap(hdr, 'header')
w = urwid.Frame(header=hdr, body=w)
# Exit message
exit = urwid.BigText(('exit', " Quit? "), exit_font)
exit = urwid.Overlay(exit, w, 'center', None, 'middle', None)
return w, exit
def error(self, e, title='Error', error=True):
self.pile.contents[self.main_area] = (urwid.Overlay(
DlgError(self, e, title, error),
self.center,
'center',
len(e) + 6,
'middle',
'pack',
), self.pile.options())
self.in_error = True
def draw(self):
"""Main loop to draw the console. This takes into account the fact that
there may be a dialog to display."""
if self._dialog is not None:
o = urwid.Overlay(self._dialog.view(), self._frame, "center",
self._dialog.width(), "middle",
self._dialog.height())
canvas = o.render(self._currentSize, focus=True)
else:
canvas = self._frame.render(self._currentSize, focus=True)
self._ui.draw_screen(self._currentSize, canvas)
def open_dialog(self, dialog, after=None):
ur.connect_signal(dialog, 'close', self.close_dialog)
self.original_widget = ur.Overlay(ur.AttrMap(dialog, 'dialog'),
self.original_widget,
align=dialog.align,
width=dialog.width,
valign=dialog.valign,
height=dialog.height,
min_width=dialog.min_width,
min_height=dialog.min_height)
self.dialogs.append((dialog, after))
def make_view(self, width, height):
view = urwid.Padding(self.frame, (const.FIXED_LEFT, 2),
(const.FIXED_RIGHT, 2))
view = urwid.Filler(view, (const.FIXED_TOP, 1),
(const.FIXED_BOTTOM, 1))
view = urwid.AttrMap(view, self.palette.dialog_body.name)
view = urwid.LineBox(view)
view = urwid.Frame(view)
view = urwid.Overlay(view, self.parent, const.CENTER, width + 2,
const.MIDDLE, height + 2)
return view
def __init__(self, modes):
self.modes = modes
self.background = urwid.Frame(body=urwid.SolidFill())
self.clocktext = urwid.BigText('clock', urwid.HalfBlock7x7Font())
self.modetext = urwid.BigText('mode', urwid.HalfBlock7x7Font())
self.overlay = urwid.Overlay(self.clocktext, self.background, 'center',
None, 'middle', None)
self.overlay = urwid.Overlay(self.modetext,
self.overlay,
'center',
None,
'middle',
None,
top=20)
self.loop = urwid.MainLoop(self.overlay,
unhandled_input=self.unhandled_input)
self.mode_index = -1
self.update_mode()
def __init__(self, text, width, host_view, loop=None):
self.loop = loop
self.host_view = host_view
self.overlay = urwid.Overlay(
urwid.LineBox(urwid.Text(text)),
host_view, #urwid.SolidFill(),
'center',
width,
'middle',
None)
urwid.Frame.__init__(self, self.overlay)
def on_create_namespace_menu_open(self, w):
"""
Execute once 'Create Namespace' button pressed,
init the 'CreateNamespaceMenu' class, and perform an overlay to that class
:param w:
:return:
"""
create_namespace_menu = CreateNamespaceMenu(self.on_namespace_menu_closed)
self.original_widget = urwid.Overlay(create_namespace_menu.main_window, self.original_widget,
align='center', width=120, valign='middle', height=30)
def on_repo_add_menu_open(self, w):
"""
Execute once 'Add repository' button pressed,
init the 'InstallChartsMenu' class, and perform an overlay to that class
:param w:
:return:
"""
add_repo_menu = AddRepoMenu(self.on_repos_menu_closed)
self.original_widget = urwid.Overlay(add_repo_menu.main_window, self.original_widget,
align='center', width=120, valign='middle', height=30)
def on_chart_install_open(self, w):
"""
Execute once 'Install Charts' button pressed,
init the 'InstallChartsMenu' class, and perform an overlay to that class
:param w:
:return:
"""
install_charts_menu = InstallChartsMenu(self.on_charts_menu_close, supported_helm_deployments, values_dir_path)
self.original_widget = urwid.Overlay(install_charts_menu.main_window, self.original_widget,
align='center', width=120, valign='middle', height=30)
def show_help(self) -> None:
cols, rows = self.loop.screen.get_cols_rows()
help_view = HelpView(self)
self.loop.widget = urwid.Overlay(
urwid.LineBox(help_view, title="Help Menu (up/down scrolls)"),
self.view,
align='center',
valign='middle',
# +2 to both of the following, due to LineBox
width=help_view.width + 2,
height=min(3 * rows // 4, help_view.number_of_actions) + 2)
def main(self):
palette = [
('banner', 'black', 'light gray'),
('default', 'default', 'default'),
('active', 'yellow', 'default'),
('opened', 'black', 'yellow'), ]
lb = uA(uLB([uB("New Game", self.newGame)]),"default")
menu = uA(uLineB(lb),"active")
bg = urwid.SolidFill('\N{MEDIUM SHADE}')
self.loop = urwid.MainLoop(urwid.Overlay(menu, bg , "center", ('relative', 60), "middle", ('relative', 60)), palette,unhandled_input=self.basicInput)
self.loop.run()
def open_box(self, box, title, width_, height_):
self.original_widget = urwid.Overlay(urwid.LineBox(box, title),
self.original_widget,
align='left', width=width_,
valign='top', height=height_,
min_width=8, min_height=8,
left=(self.box_position%4)*20 + self.box_position + 1,
# right=(self.max_box_levels - self.box_position-1)*3,
top=(self.box_position/4) * 20 + 1)
# bottom=(self.max_box_levels - self.box_position -1 )*2)
self.box_position+=1
def _handle_input(self, input):
if input == "enter": # View Answers
url, answer_count = self._get_selected_link()
if url != None:
self.viewing_answers = True
answer_result = get_question_and_answers(url, answer_count)
question_stats = answer_result[
"votes"] + " Votes | " + answer_result[
"asked"] + " asked | " + answer_result["viewed"]
count = int(answer_result['total answer']) - 1 if int(
answer_result['total answer']) - 1 > 0 else 0
answer_left = urwid.Text(
("no answers", str(count) + " More Answer Left"))
pile = urwid.Pile(
self._stylize_question(
answer_result['title'], answer_result["question_desc"],
question_stats) + [urwid.Divider('*')] +
interleave([answer_result['answer']],
[urwid.Divider('-')] + [answer_left]))
padding = ScrollBar(
Scrollable(urwid.Padding(pile, left=2, right=2)))
linebox = urwid.LineBox(padding)
menu = urwid.Text([
("menu", u" ENTER "),
("light gray", u" View answers "),
("menu", u" B "),
("light gray", u" Open browser "),
("menu", u" Q "),
("light gray", u" Quit "),
])
# linebox.base_widget.set_text(("no answers", "Getting answer"))
# linebox.draw_screen()
self.main_loop.widget = urwid.Frame(body=urwid.Overlay(
linebox, self.content_container, "center",
("relative", 90), "middle", ("relative", 100), 10),
footer=menu)
elif input in ('b', 'B'): # Open link
url, _ = self._get_selected_link()
if url != None:
webbrowser.open(url)
elif input == "esc": # Close window
if self.viewing_answers:
self.main_loop.widget = self.original_widget
self.viewing_answers = False
else:
raise urwid.ExitMainLoop()
elif input in ('q', 'Q'): # Quit
raise urwid.ExitMainLoop()
def _handle_input(self, input):
if input == "enter": # View answers
url = self._get_selected_link()
if url != None:
self.viewing_answers = True
question_title, question_desc, question_stats, answers = get_question_and_answers(
url)
pile = urwid.Pile(
self._stylize_question(question_title, question_desc,
question_stats) +
[urwid.Divider('*')] +
interleave(answers, [urwid.Divider('-')] *
(len(answers) - 1)))
padding = ScrollBar(
Scrollable(urwid.Padding(pile, left=2, right=2)))
#filler = urwid.Filler(padding, valign="top")
linebox = urwid.LineBox(padding)
menu = urwid.Text([
u'\n',
("menu", u" ESC "),
("light gray", u" Go back "),
("menu", u" B "),
("light gray", u" Open browser "),
("menu", u" Q "),
("light gray", u" Quit"),
])
# highlight the selected answer
_, idx = self.content_container.get_focus()
txt = self.content[idx].original_widget.text
self.content[idx] = urwid.AttrMap(SelectableText(txt),
'viewed',
'reveal viewed focus')
self.main_loop.widget = urwid.Frame(body=urwid.Overlay(
linebox, self.content_container, "center",
("relative", 60), "middle", 23),
footer=menu)
elif input in ('b', 'B'): # Open link
url = self._get_selected_link()
if url != None:
webbrowser.open(url)
elif input == "esc": # Close window
if self.viewing_answers:
self.main_loop.widget = self.original_widget
self.viewing_answers = False
else:
raise urwid.ExitMainLoop()
elif input in ('q', 'Q'): # Quit
raise urwid.ExitMainLoop()
def view_controller_remote_overlay(self, console):
self.return_to_details_menu()
bottom = self.view_stack[-1]
edit = urwid.Edit('Press Q to quit\n'
'View: <tab>, Menu: <, Nexus: #\n'
'DPad: <Arrow keys>, Button: A-B-X-Y\n')
view = ControllerRemote(self, console, edit)
top = urwid.LineBox(view, title='Controller Remote')
overlay = urwid.Overlay(top, bottom, 'center', ('relative', 25),
'middle', ('relative', 25))
self.push_view(self, overlay)
def on_delete_namespace_menu_open(self, w):
"""
Execute once 'Delete Namespace' button pressed,
init the 'DeleteReposMenu' class, and perform an overlay to that class
:param w:
:return:
"""
delete_namespace_menu = DeleteNamespacesMenu(self.on_namespace_menu_closed, parse_cluster_namespaces_output(identify_cluster_namespaces()['value']))
self.original_widget = urwid.Overlay(delete_namespace_menu.main_window, self.original_widget,
align='center', width=120, valign='middle', height=30)
def _show_menu(self):
"""Show the overlay menu."""
# If the current widget in the TabbedWindowWidget has a menu,
# overlay it on the TabbedWindowWidget.
current_widget = self._tabbed_window.get_current_widget()
if hasattr(current_widget, 'get_menu_widget'):
menu_widget = current_widget.get_menu_widget(self._hide_menu)
overlay = urwid.Overlay(menu_widget, self._tabbed_window,
align='center', width=('relative', 80),
valign='middle', height=('relative', 80))
self._urwid_loop.widget = overlay
def prompt_delete(self):
self.deleting = True
prompt = ConfPrompt('list')
urwid.connect_signal(prompt, 'close', self.confirm_delete)
overlay = urwid.Overlay(top_w=urwid.LineBox(prompt),
bottom_w=self.tlist,
align='center',
width=21,
valign='middle',
height=3)
self.original_widget = overlay
def View(self):
## TODO: The size should be computed in run time
self.overlay = urwid.Overlay(urwid.LineBox(self,
title=str(self.label),
title_align='center'),
self.main_frame.main_view,
align='center',
width=150,
valign='middle',
height=40)
return self.overlay
def open_box(self, box):
self.original_widget = urwid.Overlay(urwid.LineBox(box),
self.original_widget,
align='center', width=('relative', 80),
valign='middle', height=('relative', 80),
min_width=24, min_height=8,
left=self.box_level * 3,
right=(self.max_box_levels - self.box_level - 1) * 3,
top=self.box_level * 2,
bottom=(self.max_box_levels - self.box_level - 1) * 2)
self.box_level += 1
def prompt(self, prefix, text=u'', completer=None, tab=0, history=[]):
"""prompt for text input
:param prefix: text to print before the input field
:type prefix: str
:param text: initial content of the input field
:type text: str
:param completer: completion object to use
:type completer: :meth:`alot.completion.Completer`
:param tab: number of tabs to press initially
(to select completion results)
:type tab: int
:param history: history to be used for up/down keys
:type history: list of str
:returns: a :class:`twisted.defer.Deferred`
"""
d = defer.Deferred() # create return deferred
oldroot = self.inputwrap.get_root()
def select_or_cancel(text):
# restore main screen and invoke callback
# (delayed return) with given text
self.inputwrap.set_root(oldroot)
self.inputwrap.select_cancel_only = False
d.callback(text)
prefix = prefix + settings.get('prompt_suffix')
#set up widgets
leftpart = urwid.Text(prefix, align='left')
editpart = widgets.CompleteEdit(completer, on_exit=select_or_cancel,
edit_text=text, history=history)
for i in range(tab): # hit some tabs
editpart.keypress((0,), 'tab')
# build promptwidget
both = urwid.Columns(
[
('fixed', len(prefix), leftpart),
('weight', 1, editpart),
])
att = settings.get_theming_attribute('global', 'prompt')
both = urwid.AttrMap(both, att)
# put promptwidget as overlay on main widget
overlay = urwid.Overlay(both, oldroot,
('fixed left', 0),
('fixed right', 0),
('fixed bottom', 1),
None)
self.inputwrap.set_root(overlay)
self.inputwrap.select_cancel_only = True
return d # return deferred
def begin(self, button=None):
#好友列表栏
import cat_box
self.cat_list_pad = urwid.Padding(self.categories_list(),
left=2,
right=2)
self.cat_list_overlay = cat_box.cat_box(
urwid.Overlay(self.cat_list_pad,
urwid.SolidFill(u'\N{MEDIUM SHADE}'),
align='left',
width=40,
valign='top',
height=40,
min_width=20,
min_height=9), self)
#消息栏
import msg_box
self.msg_bubble_pad = urwid.Padding(self.msg_bubble(), left=2, right=2)
self.msg_bubble_overlay = msg_box.msg_box(
urwid.Overlay(self.msg_bubble_pad,
urwid.SolidFill(u'\N{MEDIUM SHADE}'),
align='left',
width=40,
valign='top',
height=40,
min_width=20,
min_height=1), self)
self.left_bar_pile = urwid.Pile(
[self.cat_list_overlay, self.msg_bubble_overlay])
#test = urwid.Button('test')
#self.msg_bubble_listBox.body.insert(0, test)
self.base = urwid.Columns([self.left_bar_pile],
dividechars=1,
min_width=10)
self.loop = urwid.MainLoop(self.base,
palette=[('reversed', 'standout', '')])
self.loop.run()
def scan(self, _loop=object, _data=[False]):
hidden = _data[0]
# scanning popup
if hidden is False:
if self.scan_times_current < self.scan_times:
_text = urwid.Text('\nScanning. Please wait (%s/%s)' %
(self.scan_times_current, self.scan_times),
align='center')
else:
_text = urwid.Text('\nScanning. Please wait...',
align='center')
_text = urwid.AttrMap(_text, 'scanning')
_body = urwid.Pile([_text])
_body = urwid.Filler(_body)
_body = urwid.AttrMap(_body, 'scanning')
else:
if self.scan_times_current < self.scan_times:
_text = urwid.Text(
'\nScanning HIDDEN networks. Please wait (%s/%s)' %
(self.scan_times_current, self.scan_times),
align='center')
else:
_text = urwid.Text(
'\nScanning HIDDEN networks. Please wait...',
align='center')
_text = urwid.AttrMap(_text, 'scanning_hidden')
_body = urwid.Pile([_text])
_body = urwid.Filler(_body)
_body = urwid.AttrMap(_body, 'scanning_hidden')
_connect_box = urwid.Frame(_body,
header=urwid.Divider(' '),
focus_part='body')
# store actual widget
self.last_widget = self.loop.widget
# Create a popup
overlay = urwid.Overlay(_connect_box,
self.loop.widget,
align='center',
valign='middle',
width=('relative', 40),
height=('relative', 12))
self.loop.widget = overlay
self.loop.set_alarm_in(0.1,
self.__network_scan_list,
user_data=[hidden])
def notify(self, message, priority='normal', timeout=0, block=False):
"""
opens notification popup
:param message: message to print
:type message: str
:param priority: priority string, used to format the popup: currently,
'normal' and 'error' are defined. If you use 'X' here,
the attribute 'global_notify_X' is used to format the
popup.
:type priority: str
:param timeout: seconds until message disappears. Defaults to the value
of 'notify_timeout' in the general config section.
A negative value means never time out.
:type timeout: int
:param block: this notification blocks until a keypress is made
:type block: bool
:returns: an urwid widget (this notification) that can be handed to
:meth:`clear_notify` for removal
"""
def build_line(msg, prio):
cols = urwid.Columns([urwid.Text(msg)])
att = settings.get_theming_attribute('global', 'notify_' + prio)
return urwid.AttrMap(cols, att)
msgs = [build_line(message, priority)]
if not self.notificationbar:
self.notificationbar = urwid.Pile(msgs)
else:
newpile = self.notificationbar.widget_list + msgs
self.notificationbar = urwid.Pile(newpile)
self.update()
def clear(*args):
self.clear_notify(msgs)
if block:
# put "cancel to continue" widget as overlay on main widget
txt = urwid.Text('(cancel continues)')
overlay = urwid.Overlay(txt, self.mainframe,
('fixed left', 0),
('fixed right', 0),
('fixed bottom', 0),
None)
self.show_as_root_until_keypress(overlay, 'cancel',
relay_rest=False,
afterwards=clear)
else:
if timeout >= 0:
if timeout == 0:
timeout = settings.get('notify_timeout')
self.mainloop.set_alarm_in(timeout, clear)
return msgs[0]
def __init__(self, title):
self.title = title
self.main = urwid.Padding(self.confirm(), left=2, right=2)
top = urwid.Overlay(self.main,
urwid.SolidFill(u'\N{MEDIUM SHADE}'),
align='center',
width=('relative', 60),
valign='middle',
height=('relative', 60),
min_width=20,
min_height=9)
urwid.MainLoop(top, palette=[('reversed', 'standout', '')]).run()
def __init__(self, title, body, escape_key, previous_widget):
self.escape_key = escape_key
self.previous_widget = previous_widget
if type(body) in [str, unicode]:
body = urwid.Text(body)
self.title = title
body = urwid.LineBox(body, title)
overlay = urwid.Overlay(body, previous_widget, 'center',
('relative', 100), 'bottom', ('relative', 100))
overlay_attrmap = urwid.AttrMap(overlay, "plugin.widget.dialog")
super(ModalDialog, self).__init__(overlay_attrmap)
def reset_root_widget(self, top_w):
self.root = urwid.Overlay(top_w,
urwid.SolidFill(' '),
align='center',
width=('relative', 80),
valign='middle',
height=('relative', 90),
min_width=20,
min_height=9)
if self.mainloop is not None:
self.mainloop.widget = self.root
def open_cancelable(self, title, message, on_cancel): try: self.center.focus.force_focus() except AttributeError: pass self.pile.contents[self.main_area] = (urwid.Overlay(DlgCancelable(self, title, message, on_cancel), self.center, 'center', len(message) + 6, 'middle', 'pack', ), self.pile.options()) self.in_error = True
