def __init__(self):
self.filter_tags = []
self.current_selected = 0
self.listbox = urwid.ListBox(urwid.SimpleFocusListWalker([]))
self._refresh()
self.menu = urwid.BoxAdapter(self.listbox,
height=len(self.listbox.body))
self.menu = urwid.AttrMap(self.menu, 'options', focus_map)
line = urwid.Divider(u'\N{LOWER ONE QUARTER BLOCK}')
header = urwid.Pile([
urwid.AttrMap(urwid.Text([u"\n ", 'Main Menu']), 'heading'),
urwid.AttrMap(line, 'line'),
urwid.Divider()
])
search = urwid.BoxAdapter(self.search_box(), height=9)
widget_list = [header, search, self.menu]
self.alert = None
new_files = getNewScans()
if len(new_files):
alert = urwid.BoxAdapter(self.alert_box(new_files), height=3)
widget_list.insert(2, alert)
self.menu = self._menu(widget_list)
super(DocumentBrowseWindow, self).__init__(MenuButton(['test'], None))
def screenUI(self):
self.text0 = urwid.Text(u'filler是一个在包装的组件上下留空隙的组件')
self.text1 = urwid.Text(u'下面两个text包裹在同一个filler组件中')
self.text2 = urwid.Text(u'')
self.text2 = urwid.AttrWrap(self.text2, 'header')
self.text3 = urwid.Text(u'')
self.text3 = urwid.AttrWrap(self.text3, 'header')
self.list_inner = [self.text2, urwid.Divider(' '), self.text3]
self.inner_list_box = urwid.ListBox(
urwid.SimpleListWalker(self.list_inner))
self.inner_list_box = urwid.BoxAdapter(self.inner_list_box, 3)
self.filler = urwid.Filler(self.inner_list_box,
valign='middle',
top=1,
bottom=2)
self.filler = urwid.AttrWrap(self.filler, 'padding')
self.inner_box = urwid.BoxAdapter(self.filler, 20)
self.text2.set_text(u"该filler的边距模式为%s" %
self.filler.original_widget.valign_type)
self.text3.set_text(u"该filler包装组件后预设的头尾的填充行为%s %s" %
(self.filler.original_widget.top,
self.filler.original_widget.bottom))
self.list_content = [
self.text0, self.text1,
urwid.Divider(' '), self.inner_box
]
listbox = urwid.ListBox(urwid.SimpleListWalker(self.list_content))
return listbox
def submenu(job_id):
# return urwid.Text("Overlay !!! \n")))
back = urwid.Button("Back")
cancel = urwid.Button(f"/!\\ Cancel job {job_id}")
body = [
back,
cancel
]
urwid.connect_signal(back, "click", close_submenu)
urwid.connect_signal(cancel, "click", cancel_job, job_id)
return urwid.LineBox(
urwid.Filler(
urwid.Pile(
[
urwid.BoxAdapter(
urwid.ListBox(urwid.SimpleFocusListWalker(body)), height=2,
),
# urwid.Text(get_job_info(job_id)),
]
)
)
)
return urwid.LineBox(
urwid.Filler(
urwid.BoxAdapter(
urwid.ListBox(urwid.SimpleFocusListWalker(body)), height=10,
)
)
)
def render_page(self):
w = urwid.Pile([
urwid.Padding(urwid.Text(self.text), left=1, right=1),
urwid.Divider(),
urwid.Padding(urwid.Columns([("fixed", 20, self.enable_password),
("fixed", 22, self.common_password)]),
left=1),
urwid.Divider(),
urwid.Padding(urwid.Columns(
[("weight", 3,
urwid.Pile([
self.pending_table_title,
urwid.BoxAdapter(
urwid.Frame(self.pending_table,
header=self.pending_table_headings), 10),
])),
("weight", 1,
urwid.Pile([
self.sshok_table_title,
urwid.BoxAdapter(
urwid.Frame(self.sshok_table,
header=self.sshok_table_headings), 10),
]))],
dividechars=1),
left=1), self.check_btn
])
w.focus_position = 5 # the Check button widget
return urwid.AttrMap(urwid.Filler(w, valign='top', top=1),
"active_step")
def _build_welcome_form(self) -> urwid.Overlay:
login = self._make_btn('Login', lambda: self.to_login_form())
signup = self._make_btn('Signup', lambda: self.to_signup_form())
quit = self._make_btn('Quit', lambda: self.quit())
button_list = [login, signup, quit]
list_box = urwid.ListBox(urwid.SimpleFocusListWalker(button_list))
layout = urwid.Filler(
# Row Start
urwid.Pile([
urwid.Padding(urwid.Text('Welcome to Text Editor Online!',
align='center'),
align='center'),
urwid.Divider(),
urwid.Divider(),
# Column Start
urwid.Columns([
urwid.BoxAdapter(urwid.SolidFill(), height=1),
(11, urwid.BoxAdapter(list_box,
height=3)), # (11, ...) is width
urwid.BoxAdapter(urwid.SolidFill(), height=1),
]),
# Column End
])
# Row End
)
return self._wrap_in_overlay(layout)
def _init_window(self):
header = 'ScapyShark v{version}'.format(version=version)
self._header_box = urwid.BoxAdapter(
urwid.AttrMap(urwid.Filler(urwid.Text(header, align='center')),
'header'), 1)
self._footer_box = urwid.BoxAdapter(
urwid.AttrMap(
urwid.Filler(urwid.Text('No Packets Yet.', align='right')),
'header'), 1)
# Body
self._top_box = ScrollingListBox(
rolling_packet_buffer=self._args.rolling_packet_buffer)
self._middle_box = urwid.ListBox(
urwid.SimpleFocusListWalker([urwid.Text('')]))
self._bottom_box = urwid.ListBox(
urwid.SimpleFocusListWalker([urwid.Text('')]))
divider = (1, urwid.Filler(urwid.Divider('\u2500')))
self._body_pile = urwid.Pile([
self._top_box, divider, self._middle_box, divider, self._bottom_box
],
focus_item=self._top_box)
# Overarching Frame
self.frame = urwid.Frame(self._body_pile,
header=self._header_box,
footer=self._footer_box,
focus_part='body')
# The main loop
self.loop = urwid.MainLoop(urwid.AttrMap(self.frame, 'frame'),
unhandled_input=self.unhandled_input,
palette=palette)
def screenUI(self):
self.text0 = urwid.Text(u'GridFlow 是一个由多个cell组成的流组件，其中每个组件都是流组件，宽度相同')
self.text1 = urwid.Text(u"对于该组件的cell序列，grid会先横向排列，当一行占满时才会使用第二行")
self.text2 = urwid.Text(u'你可以拖动鼠标变化控制台大小查看显示效果')
self.text3 = urwid.Text(u'状态信息看这里')
button_list = []
for i in range(0, 10):
button = MyButton(u"button %s" % i, self.callback_button)
button_list.append(button)
self.button_listbox = urwid.ListBox(
urwid.SimpleListWalker(button_list))
self.button_listbox = urwid.AttrWrap(self.button_listbox, 'header')
self.button_listbox_flo = urwid.BoxAdapter(self.button_listbox, 10)
edit_list = []
for i in range(0, 10):
edit = urwid.Edit((u'edit%s' % i).ljust(12))
urwid.connect_signal(edit, 'change', self.callback_edit, i)
edit_list.append(edit)
self.edit_listbox = urwid.ListBox(urwid.SimpleListWalker(edit_list))
self.edit_listbox = urwid.AttrWrap(self.edit_listbox, 'editbx',
'editfc')
self.edit_listbox_flo = urwid.BoxAdapter(self.edit_listbox, 10)
text_list = []
for i in range(0, 10):
text = urwid.Text(u'text %s' % i)
text_list.append(text)
text_listbox = urwid.ListBox(urwid.SimpleListWalker(text_list))
text_listbox = urwid.AttrWrap(text_listbox, 'padding')
text_listbox_flo = urwid.BoxAdapter(text_listbox, 10)
radiobutton_list = []
self.rgroup = []
for i in range(0, 10):
radiobutton = urwid.RadioButton(self.rgroup, u'radiobutton %s' % i,
False, self.callback_radiobutton,
i)
radiobutton_list.append(radiobutton)
self.radiobutton_listbox = urwid.ListBox(
urwid.SimpleListWalker(radiobutton_list))
self.radiobutton_listbox_flo = urwid.BoxAdapter(
self.radiobutton_listbox, 10)
self.move_button = MyButton(u"点击将焦点设置到第一个组件的起始位置",
self.callback_movebutton)
grid_list = [
self.button_listbox_flo, text_listbox_flo, self.edit_listbox_flo,
self.radiobutton_listbox_flo
]
self.gridflow = urwid.GridFlow(grid_list, 50, 2, 3, 'center')
listbox_content = [
self.text0, self.text1, self.text2, blank, self.gridflow,
self.text3, self.move_button
]
return urwid.ListBox(urwid.SimpleListWalker(listbox_content))
def flowtext(self):
text = []
title = urwid.Text("Flow details")
title = urwid.Padding(title, align="left", width=("relative", 100))
title = urwid.AttrWrap(title, "heading")
text.append(title)
if self.flow.response:
c = self.flow.response.cert
if c:
text.append(urwid.Text([("head", "Server Certificate:")]))
parts = [
["Type", "%s, %s bits" % c.keyinfo],
["SHA1 digest", c.digest("sha1")],
["Valid to", str(c.notafter)],
["Valid from", str(c.notbefore)],
["Serial", str(c.serial)],
]
parts.append([
"Subject",
urwid.BoxAdapter(
urwid.ListBox(
common.format_keyvals(c.subject,
key="highlight",
val="text")), len(c.subject))
])
parts.append([
"Issuer",
urwid.BoxAdapter(
urwid.ListBox(
common.format_keyvals(c.issuer,
key="highlight",
val="text")), len(c.issuer))
])
if c.altnames:
parts.append(["Alt names", ", ".join(c.altnames)])
text.extend(
common.format_keyvals(parts,
key="key",
val="text",
indent=4))
if self.flow.request.client_conn:
text.append(urwid.Text([("head", "Client Connection:")]))
cc = self.flow.request.client_conn
parts = [
["Address", "%s:%s" % tuple(cc.address)],
["Requests", "%s" % cc.requestcount],
["Closed", "%s" % cc.close],
]
text.extend(
common.format_keyvals(parts, key="key", val="text", indent=4))
return text
def main(self):
# this program use frame as the topmost widget, header and footer
# play roles of the top and bottom lines of the frame
self.children = []
# load the modules will be used,
# every module is one child
# you can extend the num of modules by modify modules.__init__.py file
for clsobj in modules.__all__[1:]:
modobj = clsobj(
self, LanguageType.ENGLISH) # default language is chinese
self.children.append(modobj)
if len(self.children) == 0:
log.debug('there is no available modules, dsMenu exit')
sys.exit(1)
# build list of choices
self.choices = [m.name for m in self.children]
# build list of visible choices
self.visiblechoices = []
for child, choice in zip(self.children, self.choices):
if child.visible:
self.visiblechoices.append(choice)
# finish menu box
self.menuitems = self.menu(self.language_field['menu_label'],
self.visiblechoices)
menufill = urwid.Filler(self.menuitems, 'top', 40)
self.menubox = urwid.BoxAdapter(menufill, 40)
# finish child box
self.child = self.children[0] # use DaSone user modules default
self.childpage = self.child.screenUI()
self.child.screen = self.childpage
self.childfill = urwid.Filler(self.childpage, 'top', 22)
self.childbox = urwid.BoxAdapter(self.childfill, 22)
# create col widget contain menubox and child box
self.cols = urwid.Columns(
[('fixed', 20,
urwid.Pile(
[urwid.AttrMap(self.menubox, 'body'),
urwid.Divider(" ")])),
('weight', 3, urwid.Pile([blank, self.childbox, blank]))], 1)
# top second widget -- Listbox
self.listwalker = urwid.SimpleListWalker([self.cols])
self.listbox = urwid.ListBox(self.listwalker)
#topmost widget --Frame
self.frame = urwid.Frame(urwid.AttrMap(self.listbox, 'body'),
header=self.header,
footer=self.footer)
# begin mainloop
self.mainloop.widget = self.frame
def __init__(self, settings, greet, font):
self.group = []
self.gui_items = urwid.SimpleListWalker([])
self.cli_items = urwid.SimpleListWalker([])
#header = urwid.AttrMap(urwid.Text('selected:'), 'head')
self.gui_listbox = urwid.ListBox(self.gui_items)
#add widget for consolekit checkbox
self.cli_listbox = urwid.ListBox(self.cli_items)
#add widget for fbterm checkbox and settings
self.fb_check = urwid.CheckBox("Enable background image", state=False)
self.ck_check = urwid.CheckBox("Enable Consolekit", state=False)
cli_box = urwid.Pile([
urwid.BoxAdapter(self.cli_listbox, 15),
urwid.AttrMap(self.fb_check, 'body', 'body')
])
gui_box = urwid.Pile([
urwid.BoxAdapter(self.gui_listbox, 15),
urwid.AttrMap(self.ck_check, 'body', 'body')
])
tabs = TabColumns([
urwid.AttrWrap(SelText("GUI"), 'tab active', 'focus'),
urwid.AttrWrap(SelText("CLI"), 'body', 'focus')
], [urwid.Filler(gui_box),
urwid.Filler(cli_box)], 'Sessions')
ulabel = urwid.Text("Username")
plabel = urwid.Text("Password")
utext = urwid.Edit()
ptext = urwid.Edit(mask="*")
ustuff = urwid.Columns(
[urwid.AttrWrap(ulabel, 'uname'),
urwid.AttrWrap(utext, 'uname')])
pstuff = urwid.Columns(
[urwid.AttrWrap(plabel, 'pw'),
urwid.AttrWrap(ptext, 'pw')])
ffont = font()
banner = urwid.BigText(greet, ffont)
banner = urwid.AttrWrap(banner, 'banner')
banner = urwid.Padding(banner, 'left', width='clip')
banner = urwid.Filler(banner, height=ffont.height)
#banner = urwid.Padding(banner,align='center')
login_details = urwid.Pile([
ustuff, pstuff,
urwid.AttrWrap(urwid.Text("Press enter to log in"), 'body', 'body')
])
#sessions_box = urwid.Pile([urwid.Text("Sessions"),
# urwid.BoxAdapter(listbox, 40)])
self.__super.__init__(
[banner,
urwid.Columns([urwid.Filler(login_details), tabs])])
self.username = utext
self.password = ptext
urwid.connect_signal(utext, 'change', self.refresh_sessions, settings)
def edit_bridge(self, button):
if len(self.bridge_list) == 0:
dialog.display_dialog(self,
urwid.Text("No bridge could be edited"),
"Error Operation")
return
# back button
self.back_button = widget.Button('BACK', self.back_screen)
back_button_line = urwid.GridFlow([self.back_button], 8, 0, 0, 'left')
## draw a new screen with two lineboxes which used to
## configure net info and eths for bond
# linebox 1
net_info_listbox = modulehelper.ModuleHelper.screenUI(
self, [], self.fields, self.defaults, button_visible=False)
net_info_linebox = urwid.LineBox(net_info_listbox, "Network Address")
# store edit fields for visiting conveniently
self.edits_tmp = self.edits
# linebox 2
bond_for_bridge = widget.ColContainTwoListBox(
"Bond inuse", "Bond usable", self.active_bridge_bond_inuse,
self.active_bridge_bond_usable, self.remove_bond, self.add_bond)
bond_for_bridge_listbox = modulehelper.ModuleHelper.screenUI(
self, [bond_for_bridge], [], {},
button_visible=False,
iblank=False)
bond_for_bridge_linebox = urwid.LineBox(bond_for_bridge_listbox,
"Bond Interface")
# new screen
self.bond_for_bridge_height = max([
len(self.active_bridge_bond_inuse),
len(self.active_bridge_bond_usable)
])
screen_new_header = [
back_button_line,
urwid.BoxAdapter(net_info_linebox, 7), blank,
urwid.BoxAdapter(bond_for_bridge_linebox,
self.bond_for_bridge_height + 7)
]
screen_new = modulehelper.ModuleHelper.screenUI(
self,
screen_new_header, [], {},
button_label=["DEL", "APPLY"],
button_callback=[self.del_bridge_dialog, self.apply])
self.edits = self.edits_tmp
# redraw mod screen
self.parent.draw_child_screen(screen_new)
self.parent.cols.set_focus(1)
self.edit_open = True
def __init__(self, parent, mind):
header = SelectableListBox(urwid.SimpleListWalker([urwid.Text("")]))
self.bodies = {
b: globals()[f"{b}Frame"](self, mind)
for b in ("Status", "Room", "Inventory", "Equipment", "Map",
"Chat")
}
self.active_body = self.bodies["Status"]
screen_btns = [
urwid.LineBox(
urwid.AttrMap(urwid.Text("{:^10}".format(s), align="center"),
None,
focus_map="line")) for s in self.bodies
]
footer = FrameColumns(self, screen_btns)
super(GameFrame,
self).__init__(parent,
mind,
urwid.LineBox(self.active_body, title="Status"),
header=urwid.LineBox(urwid.BoxAdapter(header, 12),
title="Players"),
footer=footer,
focus_part="header")
self.header_widget = self.header.original_widget.box_widget
def uiEditor(command):
edit_buttons = [
urwid.Divider(),
customButton('Save', saveEdit),
urwid.Divider(),
customButton('Cancel', cancelEdit),
urwid.Divider(),
]
app_state['editListBox'] = urwid.ListBox([
urwid.AttrMap(urwid.Text('Edit'), 'header'),
urwid.Divider(),
urwid.Columns([
createEditText('Name', command),
createEditText('Command', command),
]),
createEditText('Description', command, 2),
urwid.Columns([
createEditText('Tags', command),
urwid.Pile([
urwid.Divider(),
urwid.AttrMap(urwid.Columns(edit_buttons), 'editButtons')
])
])
])
return urwid.BoxAdapter(urwid.AttrMap(app_state['editListBox'], 'editor'),
12)
def launch_witch_readonly(self, data):
self.witch_tab.editor.original_widget = urwid.BoxAdapter(
urwid.Filler(urwid.Text(data['code'])),
self.ui_loop.screen_size[1] // 2)
self.witch_tab.refresh(data, self.scope)
self.switch_tab(self.tabs.get('f2'))
def makeFrame(self, data):
"""
Returns a new frame that is formatted correctly with respect to the window's dimensions.
:param data: tuple of (answers, question_title, question_desc, question_stats, question_url)
:return: a new urwid.Frame object
"""
answers, question_title, question_desc, question_stats, question_url = data
self.data = data
self.question_desc = question_desc
self.url = question_url
self.answer_text = AnswerText(answers)
self.screenHeight, screenWidth = subprocess.check_output(
['stty', 'size']).split()
self.question_text = urwid.BoxAdapter(
QuestionDescription(question_desc),
int(max(1, (int(self.screenHeight) - 9) / 2)))
answer_frame = urwid.Frame(
header=urwid.Pile([
header_for_display,
QuestionTitle(question_title), self.question_text,
QuestionStats(question_stats),
urwid.Divider('-')
]),
body=self.answer_text,
footer=urwid.Pile([
QuestionURL(question_url),
UnicodeText(
u'\u2191: previous answer, \u2193: next answer, o: open in browser, \u2190: back'
)
]))
return answer_frame
def refresh(self, keep: gkeepapi.Keep):
self.w_grid.contents = [(urwid.BoxAdapter(widget.note.Note(n),
self.size[1]),
self.w_grid.options())
for n in self.query.filter(keep)]
if self.w_grid.contents:
self.w_grid.focus_position = 0
def build_mainbody_widgets(self):
# Build the left-most group selector list box
groupwalker = urwid.SimpleListWalker(
[SelectGroupButton(name) for _, name in self.readgroups])
urwid.connect_signal(
groupwalker, 'modified',
partial(self.on_group_selection_changed, groupwalker))
group_selector = (urwid.Padding(urwid.Filler(urwid.BoxAdapter(
urwid.ListBox(groupwalker), 7),
'top',
top=1),
left=1))
default_group_title = self.readgroups[0][1]
left_widget, left_elements = self.build_read_stats_widget(
default_group_title)
right_widget, right_elements = self.build_read_stats_widget(
'All Reads')
stats_columns = urwid.Columns([
('fixed', 16, group_selector),
left_widget,
right_widget,
])
self.readstats_left = left_elements
self.readstats_right = right_elements
self.readstatsbox_left = left_widget
return urwid.Filler(stats_columns, 'top', height=('relative', 100))
def show_pop_up(self, to_show: Any, style: str) -> None:
border_lines = dict(tlcorner='▛',
tline='▀',
trcorner='▜',
rline='▐',
lline='▌',
blcorner='▙',
bline='▄',
brcorner='▟')
text = urwid.Text(to_show.title, align='center')
title_map = urwid.AttrMap(urwid.Filler(text), style)
title_box_adapter = urwid.BoxAdapter(title_map, height=1)
title_box = urwid.LineBox(title_box_adapter,
tlcorner='▄',
tline='▄',
trcorner='▄',
rline='',
lline='',
blcorner='',
bline='',
brcorner='')
title = urwid.AttrMap(title_box, 'popup_border')
content = urwid.LineBox(to_show, **border_lines)
self.loop.widget = urwid.Overlay(
urwid.AttrMap(urwid.Frame(header=title, body=content),
'popup_border'),
self.view,
align='center',
valign='middle',
# +2 to both of the following, due to LineBox
# +2 to height, due to title enhancement
width=to_show.width + 2,
height=to_show.height + 4,
)
def __init__(self):
self.screen = urwid.raw_display.Screen()
self.footer = urwid.AttrWrap(urwid.Text(self.footer_text), 'foot')
self.header = urwid.Text("Aursec - TUI")
self.settings = Settings(self)
self.col_desc = urwid.AttrWrap(
urwid.Columns([('fixed', 10, urwid.Text("Nr")),
('fixed', 10, urwid.Text("Hash")),
('fixed', 46, urwid.Text("Miner")),
('fixed', 25, urwid.Text("Time")),
urwid.Text("Transactions")]), 'bold')
self.list = items()
self.body = urwid.BoxAdapter(urwid.ListBox(self.list),
height=self.screen.get_cols_rows()[True] -
4)
self.layout = urwid.Pile([self.settings, self.col_desc, self.body])
self.old_show_all = self.settings.show_all.state
self.old_transactions = self.settings.transactions.state
self.view = urwid.Frame(urwid.AttrWrap(
urwid.Filler(self.layout, valign='top'), 'body'),
header=urwid.AttrWrap(self.header, 'head'),
footer=self.footer)
self.blocks = blocks.Blocks()
self.curr_block = self.blocks.get_curr_block()
self.refresh()
self.thread = Thread(target=self.blocks.run, args=(self.curr_block, ))
self.thread.start()
def add_bond(self, button):
if len(self.bridge_bond_inuse_tmp) == 0 and len(
self.bridge_bond_usable_tmp) == 0:
self.bridge_bond_inuse_tmp = copy.deepcopy(
self.active_bridge_bond_inuse)
self.bridge_bond_usable_tmp = copy.deepcopy(
self.active_bridge_bond_usable)
button_label = button.get_label()
if len(self.bridge_bond_inuse_tmp) > 0:
self.bridge_bond_usable_tmp.append(self.bridge_bond_inuse_tmp[0])
self.bridge_bond_usable_tmp.remove(button_label)
self.bridge_bond_inuse_tmp = [button_label]
self.bridge_bond_usable_tmp = sorted(self.bridge_bond_usable_tmp)
# display new dialog
eths_bond_dialog = widget.ColContainTwoListBox(
'Bond inuse', 'Bond usable', self.bridge_bond_inuse_tmp,
self.bridge_bond_usable_tmp, self.remove_bond, self.add_bond,
button.get_label())
eths_bond_dialog_ltb = urwid.ListBox(
urwid.SimpleListWalker([eths_bond_dialog]))
eths_bond_dialog_lnb = urwid.LineBox(eths_bond_dialog_ltb,
"Bridge Device")
self.listbox_content[3] = urwid.BoxAdapter(
eths_bond_dialog_lnb, self.bond_for_bridge_height + 7)
self.parent.refresh_screen()
def _get_events(self, day):
"""get all events on day, return a DateListBox of `U_Event()`s
:type day: datetime.date
"""
event_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 make_comment_frame(self):
"""
Returns a new frame that is formatted correctly with respect to the window's dimensions.
:return: a new urwid.Frame object
"""
self.screenHeight, screenWidth = subprocess.check_output(
['stty', 'size']).split()
self.question_text = urwid.BoxAdapter(
QuestionDescription(self.question_desc),
int(max(1, (int(self.screenHeight) - 9) / 2)))
comment_frame = urwid.Frame(
header=urwid.Pile([
display_header,
QuestionTitle(self.question_title), self.question_text,
QuestionStats(self.question_stats),
urwid.Divider('-')
]),
body=self.answer_text,
footer=urwid.Pile([
QuestionURL(self.url),
UnicodeText(
'o: open in browser, v: back to answer, \u2190: back, q: quit'
)
]))
return comment_frame
def __init__(self, label, header, items, selected_item, height, enabled):
self.__label = urwid.Text(label)
self.__label_attrmap = urwid.AttrMap(self.__label, self._label_attr)
self.__header = urwid.Text(header)
self.__header_attrmap = urwid.AttrMap(self.__header, self._header_attr)
self.__items = items
self.__walker = urwid.SimpleListWalker(self.__items)
self.__list = urwid.ListBox(self.__walker)
# self.__list_linebox = urwid.LineBox(self.__list)
if selected_item:
self.set_focus(items.index(selected_item))
def __on_item_change():
widget, self._position = self.__list.get_focus()
self._update_scrollbar()
urwid.emit_signal(self, "changed", widget)
urwid.connect_signal(self.__walker, 'modified', __on_item_change)
self.__box = urwid.BoxAdapter(self.__list, height)
self.__box_attrmap = urwid.AttrMap(self.__box, self._table_attr)
self.__position_label = urwid.Text("", align="right")
self.__position_label_attrmap = urwid.AttrMap(self.__position_label,
self._label_attr)
self.__pile = urwid.Pile([
self.__label_attrmap, self.__header_attrmap, self.__box,
self.__position_label_attrmap
])
self._update_scrollbar()
super(TableWidget, self).__init__(self.__pile)
def render_page(self):
table_headings = [(3, urwid.Text('Sel')), (4, urwid.Text('Role')),
(12, urwid.Text('Hostname')),
(4, urwid.Text('CPU ')), (3, urwid.Text('RAM')),
(3, urwid.Text('NIC')), (3, urwid.Text('HDD')),
(3, urwid.Text('SSD')), (4, urwid.Text('Size')),
(8, urwid.Text('Status'))]
table_header = urwid.Columns(table_headings, 1)
self.table = urwid.ListBox(self.table_body)
results = urwid.Padding(urwid.BoxAdapter(
urwid.LineBox(urwid.Frame(self.table,
header=table_header,
footer=self.table_footer),
title="Host Configuration"), 13),
left=1,
right=1)
return urwid.AttrMap(
urwid.Filler(
urwid.Pile([
urwid.Padding(urwid.Text(self.text), left=2, right=2),
# urwid.Divider(),
self.probe_btn,
urwid.Divider(),
results,
# urwid.Divider(),
self.next_btn
]),
valign='top',
top=1),
'active_step')
def __init__(self, title, cred, tests, data):
self.app = None
self.tester = data["tester"]
urn = cred["nodelist"][0][0] + ":" + str(cred["nodelist"][0][1]) + (
"/" + (cred["database"]) if bool(cred["database"]) else "")
self.data = {
"title": title,
"callback": data["callback"],
"urn": urn,
"num_tests": len(tests)
}
self.progress_text = urwid.Text(
('progress', '0/' + str(self.data["num_tests"])))
running_display = urwid.Columns([
(14, urwid.Text(('text', 'Running test'))), self.progress_text
])
self.progress_bar = CustomProgressBar('progress', 'remaining', 0,
self.data["num_tests"])
self.text_running = urwid.Text(('text', ''))
box = urwid.BoxAdapter(urwid.Filler(self.text_running, valign='top'),
2)
pile = urwid.Pile([running_display, self.progress_bar, DIV, box])
urwid.WidgetWrap.__init__(self, pile)
def __init__(self, value=0):
text = urwid.Text("", align="center")
box = urwid.Filler(text, valign="middle")
super().__init__(urwid.BoxAdapter(box, 5), "tile-0")
self._box = box
self._text = text
self.value = value
def __network_scan_list(self, _loop=object, _data=[False]):
hidden_scan = _data[0]
if hidden_scan:
self.network_list = self.scanner.scan_hidden()
else:
self.network_list = self.scanner.scan()
# If we didn't hit the counter of scans, we scan again
if self.scan_times_current < self.scan_times:
# We add count on current scans
self.scan_times_current += 1
# Sleep for a second
time.sleep(2)
# Scan again
self.scan()
else:
# Reset scan loop
#self.scan_times_current = 1
terminal_cols, terminal_rows = urwid.raw_display.Screen(
).get_cols_rows()
# Headers columns
_headers = ["SSID", "%", "Sec", "MAC", "CH", "dBm"]
_network_header = urwid.AttrMap(
urwid.Columns([urwid.Text(c) for c in _headers]),
"network_header")
# clean hidden ssid for UI
networks = self.network_list
for bssid in networks.keys():
__essid = networks[bssid][0]
if '\\x00' in __essid or '?' in __essid or __essid == '':
__essid = '-HIDDEN-'
networks[bssid][0] = __essid
# Networks found
_netlist = [
SelectableRow(networks[bssid], self.__connect_network)
for bssid in networks.keys()
]
_netlist = urwid.ListBox(urwid.SimpleFocusListWalker(_netlist))
pile = urwid.Pile([
urwid.Text('Networks found:'),
urwid.Divider('-'),
_network_header,
urwid.Divider('-'),
urwid.BoxAdapter(_netlist, terminal_rows),
])
widget = urwid.Filler(pile)
widget = self.__get_container(widget)
self.loop.widget = widget
def _setup_GUI(self):
self.body = urwid.SimpleFocusListWalker([])
listbox = urwid.ListBox(self.body)
adapter = urwid.BoxAdapter(listbox, height=10)
linebox = urwid.LineBox(adapter, title='Add Source')
columns = urwid.Columns([(20, linebox)])
super().__init__(columns)
def build(self):
"""
Composes child views and components into a single object to be rendered.
Uses a custom widget PositiveNegativeBarGraph that is a fork of the
urwid BarGraph widget
Parameters
----------
None
Returns
-------
None
Raises
------
None
"""
header = HeaderComponent(f'{self.name.title()} Signal', 'h2')
self.bg = PositiveNegativeBarGraph(['bg background', 'bg 1'])
self.bg.set_bar_width(self.barWidth)
body = urwid.BoxAdapter(self.bg, self.height)
l = [header, body]
w = urwid.Pile(l)
b = urwid.LineBox(w)
return b
def __init__(self, descriptionText, statText, **kwargs):
# Room description widget
self.description = urwid.Filler(urwid.Text(descriptionText),
valign='middle',
height='pack')
# Stat display widget
self._statText = urwid.Text(statText)
# kwargs
directions = kwargs['directions']
actions = kwargs.pop('actions', None)
gameOpts = kwargs.pop('gameOpts', None)
self._controller = kwargs.pop('controller', None)
# Menu stuff
optionMenu = urwid.Pile([
ActionButton(opt, self._controller.optionCallback)
for opt in gameOpts
])
self.walker = urwid.SimpleFocusListWalker([])
cols = urwid.Columns(
[('weight', 20, self.createDirectionMenu(directions)),
('weight', 40, self.createActionMenu(actions)),
('weight', 30, optionMenu)],
dividechars=2)
self.walker.append(cols)
self.menu = urwid.BoxAdapter(urwid.ListBox(self.walker), 6)
self.screen = urwid.Frame(self.description,
header=self._statText,
footer=self.menu,
focus_part='footer')
