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, title):
self.title_text = urwid.Text(('title', title))
self.status_label = urwid.Text('Status: ')
self.status_text = urwid.Text('new')
self.exit_label = urwid.Text('Exitcode: ')
self.exit_text = urwid.Text('n/a')
self.wait_text = urwid.Text('Every ')
self.output_text = urwid.Text('')
self.header_pack = urwid.Columns(widget_list=[
('pack', self.status_label),
(8, self.status_text),
('pack', self.exit_label),
(5, self.exit_text),
('pack', self.wait_text),
])
self.overall_pack = urwid.Pile(widget_list=[
('pack', self.header_pack),
('pack', self.output_text),
])
self.linebox = urwid.LineBox(self.overall_pack, title=title)
urwid.WidgetWrap.__init__(self, self.linebox)
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 create(self) -> urwid.Widget:
# Add simple default button that can be oberridden by adding custom
# buttons.
default_btn_text = "Close"
btn = widget.PlainButton(default_btn_text)
self.btn_width = len(default_btn_text) + 2
urwid.connect_signal(btn,
"click",
self._on_button_clicked,
user_args=[lambda: True])
self.buttons = urwid.GridFlow(
[btn],
cell_width=11,
h_sep=2,
v_sep=1,
align="center",
)
content = urwid.Pile([self.message, urwid.Divider(), self.buttons])
view = urwid.LineBox(content, self.title)
return view
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 __init__(self, controller: Any, question: Any,
success_callback: Callable[[], bool]):
self.controller = controller
self.success_callback = success_callback
yes = urwid.Button('Yes', self.exit_popup_yes)
no = urwid.Button('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 __init__(self, autocomplete_engine=None):
editor = QueryEditor(autocomplete_engine)
container = urwid.Filler(urwid.AttrMap(editor, ''), valign='top')
title = u'[F9: Run. Ctrl-F9: Clear. Esc: Close. Ctrl-P/Ctrl-N: Query history. Ctrl-Shift-Up/Down: Resize editor.]'
self._suggestions_widget = SuggestionsWidget()
frame = urwid.Frame(body=container, footer=self._suggestions_widget)
line_box = urwid.LineBox(frame, title=title, title_align='right')
urwid.connect_signal(editor, editor.SIGNAL_LOADING_SUGGESTIONS,
self._loading_suggestions)
urwid.connect_signal(editor, editor.SIGNAL_SHOW_SUGGESTIONS,
self._show_suggestions)
urwid.connect_signal(editor, editor.SIGNAL_HIDE_SUGGESTIONS,
self._hide_suggestions)
super().__init__(line_box, 'linebox')
urwid.register_signal(
self.__class__,
[self.SIGNAL_LOADING_SUGGESTIONS, self.SIGNAL_LOADED_SUGGESTIONS])
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,
body,
actions,
height=None,
line_box=False,
line_box_title=''):
self._actions = []
self._actions_to_signals = {}
self._body = body
self._status_bar = urwid.Text('')
self._prepare_actions_and_signals(actions)
self._action_bar = urwid.AttrMap(ActionBar(self._actions),
'action_bar')
self._container = self._make_container(height=height)
if line_box is True:
self._container = urwid.LineBox(self._container,
title=line_box_title)
super().__init__(urwid.AttrMap(self._container, 'linebox'))
self._register_signals()
def topics_view(self, stream_button: Any) -> Any:
stream_id = stream_button.stream_id
topics_btn_list = [
TopicButton(
stream_id=stream_id,
topic=topic,
controller=self.controller,
width=self.width,
count=self.model.unread_counts['unread_topics'].
get((stream_id, topic), 0)
) for topic in self.model.index['topics'][stream_id]]
self.view.topic_w = TopicsView(topics_btn_list, self.view,
stream_button)
w = urwid.LineBox(
self.view.topic_w, title="Topics",
tlcorner=u'━', tline=u'━', lline=u'',
trcorner=u'━', blcorner=u'', rline=u'',
bline=u'', brcorner=u'─'
)
return w
def __init__(self, milestone):
self.milestone = milestone
content = [
urwid.Columns([
(3, self._is_closed_widget()),
("weight", 0.8, self._name_widget()),
("weight", 0.2, self._progress_status_widget()),
]),
urwid.Columns([
(3, urwid.Text("")),
("weight", 0.4, self._finish_date_widget()),
("weight", 0.4, self._total_points_widget()),
("weight", 0.4, self._closed_points_widget()),
])
]
self.widget = urwid.Pile(content)
super().__init__(
urwid.AttrMap(urwid.LineBox(urwid.AttrMap(self.widget, "default")),
"default", "focus"))
def setup_section(self, coin_name, price_value):
text_color = 'normal'
prev_price = self.prices.get(coin_name)
if price_value is not None:
if prev_price and price_value > prev_price:
text_color = 'price_higher'
elif prev_price and price_value < prev_price:
text_color = 'price_lower'
self.prices[coin_name] = price_value
price_formatted = '{:10.2f} {}'.format(
price_value,
self.output_currency[1],
).rjust(10)
else:
price_formatted = 'N/A'
price_text = urwid.Text([
' {0}:'.format(coin_name),
(text_color, price_formatted),
])
return urwid.LineBox(urwid.Filler(price_text, valign='top', top=1))
def __init__(self, main_frame):
## This is a window && window name
self.window = True
self.label = 'TLS Logger'
self.main_frame = main_frame
self.isOver = False
self.actionM = ActionMenu(self)
## Create new queue
self.queue = queue.Queue()
self.main_frame.plugin_queue['TLSP'] = self.queue
self.connections = {}
self.urw_conn = urwid.SimpleFocusListWalker([])
self.listBox_conn = urwid.ListBox(self.urw_conn)
connection_status = urwid.LineBox(self.listBox_conn)
self.cont = urwid.SimpleFocusListWalker([])
self.cc = urwid.ListBox(self.cont)
super(TLS_connection,
self).__init__([('weight', 0.2, connection_status),
('weight', 0.8, self.cc)])
self.runner = TLS_runner(self)
self.runner.start()
def private_box_view(self, button: Any=None, email: str='') -> None:
self.set_editor_mode()
if email == '' and button is not None:
email = button.email
self.to_write_box = ReadlineEdit("To: ", edit_text=email)
self.msg_write_box = ReadlineEdit(multiline=True)
self.msg_write_box.enable_autocomplete(
func=self.generic_autocomplete,
key=keys_for_command('AUTOCOMPLETE').pop(),
key_reverse=keys_for_command('AUTOCOMPLETE_REVERSE').pop()
)
to_write_box = urwid.LineBox(
self.to_write_box, tlcorner='─', tline='─', lline='',
trcorner='─', blcorner='─', rline='',
bline='─', brcorner='─'
)
self.contents = [
(to_write_box, self.options()),
(self.msg_write_box, self.options()),
]
self.focus_position = 1
def open_torrent_options_window(self):
torrent_name = self.cached_torrent.get("name", "")
self.main.torrent_options_window = uw.Overlay(
top_w=uw.LineBox(
TorrentOptionsDialog(
torrent_list_box_w=self.torrent_list_box_w,
torrent_hash=self.get_torrent_hash(),
torrent=self.cached_torrent,
),
title=torrent_name,
),
bottom_w=self.torrent_list_box_w.main.app_window,
align=uw.CENTER,
width=(uw.RELATIVE, 50),
valign=uw.MIDDLE,
height=25,
min_width=75,
)
self.main.loop.widget = self.main.torrent_options_window
def __init__(self, body, loop, width=0, height=0):
self.body = body
self.loop = loop
self.parent = loop.widget
if body is None:
body = urwid.Filler(urwid.Divider(), 'top')
self.frame = urwid.Frame(body, focus_part='footer')
widget = self.frame
# decoration
widget = urwid.Padding(widget, ('fixed left',2), ('fixed right',2))
widget = urwid.Filler(widget, ('fixed top',1), ('fixed bottom',1))
if self.linebox == True:
widget = urwid.LineBox(widget)
if self.overlay == True:
widget = urwid.Overlay(widget, self.parent, 'center', width + 2, ('relative', 30), height + 2)
super(ModalWindow, self).__init__(widget)
def show_log_file(self, log_path, title):
if isfile(log_path):
log = self.comp_log_map.get(title, None)
if log:
self.logger.info("Closing '%s' log" % title)
self.additional_content_grid.contents.remove(
(log, self.additional_content_grid.options()))
self.comp_log_map[title] = None
else:
self.logger.info("Opening '%s' log" % title)
log = urwid.AttrMap(urwid.LineBox(
urwid.BoxAdapter(
urwid.ListBox(LogTextWalker(log_path, title)), 10),
'%s Log' % title),
None,
focus_map='simple_button')
self.comp_log_map[title] = log
self.additional_content_grid.contents.append(
(log, self.additional_content_grid.options()))
else:
self.logger.error("Log file '%s' does not exist!" % log_path)
def streams_view(self) -> Any:
streams_btn_list = [
StreamButton(stream,
controller=self.controller,
view=self.view,
width=self.width,
count=self.model.unread_counts.get(stream[1], 0))
for stream in self.view.pinned_streams
]
if len(streams_btn_list):
unpinned_divider = urwid.Divider("-")
# FIXME Necessary since the divider is treated as a StreamButton
unpinned_divider.stream_id = -1
unpinned_divider.caption = ''
streams_btn_list += [unpinned_divider]
streams_btn_list += [
StreamButton(stream,
controller=self.controller,
view=self.view,
width=self.width,
count=self.model.unread_counts.get(stream[1], 0))
for stream in self.view.unpinned_streams
]
self.view.stream_w = StreamsView(streams_btn_list, self.view)
w = urwid.LineBox(self.view.stream_w,
title="Streams",
tlcorner=u'─',
tline=u'─',
lline=u'',
trcorner=u'─',
blcorner=u'',
rline=u'',
bline=u'',
brcorner=u'─')
return w
def show(self, loop):
# Header
header_text = urwid.Text('Remove Connection: ' + self.target.name, align='center')
header = urwid.AttrMap(header_text, 'dialog')
# Footer
ok_btn = urwid.Button('Ok', self.on_ok)
ok_btn = urwid.AttrWrap(ok_btn, 'dialog_button', 'dialog_button_focus')
cancel_btn = urwid.Button('Cancel', self.on_cancel)
cancel_btn = urwid.AttrWrap(cancel_btn, 'dialog_button', 'dialog_button_focus')
footer = urwid.GridFlow([ok_btn, cancel_btn], 12, 1, 1, 'center')
body = urwid.Filler(
urwid.Pile([
urwid.Text("Are you sure?"),
urwid.Text(""),
footer
])
)
# Layout
layout = urwid.Frame(
body,
header=header
)
w = DialogOverlay(
on_close=lambda: self.on_close(self.target),
on_enter=lambda: self.on_ok(None),
top_w=urwid.AttrMap(urwid.LineBox(layout), "dialog"),
bottom_w=loop.widget,
align='center',
width=40,
valign='middle',
height=10
)
loop.widget = w
def draw(self):
content_frame = urwid.Frame(body=None)
top = urwid.Text(self.text)
top = urwid.Padding(top, align='left', width='pack')
top = urwid.AttrMap(urwid.Filler(top, valign='top'), 'wcolor')
rbgroup = []
buttons = [
urwid.AttrMap(urwid.RadioButton(rbgroup, d), 'focus', 'selectable')
for d in self.disks
]
self.rbuttons = buttons
buttons = urwid.Pile(buttons, focus_item=0)
buttons = urwid.Padding(buttons, align='left', width='pack')
buttons = urwid.AttrMap(urwid.Filler(buttons, valign='top'), 'wcolor')
ok = urwid.AttrMap(urwid.Button('OK', self.handle_input), 'focus',
'selectable')
ok = urwid.GridFlow([ok], 10, 3, 1, 'center')
bottom = urwid.Padding(ok, align='left', width='pack')
bottom = urwid.AttrMap(urwid.Filler(bottom, valign='bottom'), 'wcolor')
content = DiskSelectionDialog.TabPile([top, buttons, bottom],
self,
focus_item=1)
content = urwid.AttrMap(urwid.LineBox(content), 'wcolor')
content = urwid.Overlay(content,
urwid.AttrMap(urwid.SolidFill(gli.SFILL),
'bgcolor'),
align='center',
valign='middle',
width=50,
height=10)
content_frame.body = content
self._w = content_frame
def __init__(self, db, top_frame, sub_id):
self.db = db
self.top_frame = top_frame
self.subs_id = sub_id
self.subs = self.db.get_subs_to_align(sub_id, SUBS_CNT_FOR_ALIGN)
bg_lt = []
bg_rt = []
bg_lb = []
bg_rb = []
self.left_top = [
urwid.RadioButton(bg_lt, x.content) for x in self.subs[0]
]
self.right_top = [
urwid.RadioButton(bg_rt, x.content) for x in self.subs[1]
]
self.left_bot = [
urwid.RadioButton(bg_lb, x.content) for x in self.subs[2]
]
self.right_bot = [
urwid.RadioButton(bg_rb, x.content) for x in self.subs[3]
]
left_top_box = urwid.ListBox(urwid.SimpleFocusListWalker(
self.left_top))
right_top_box = urwid.ListBox(
urwid.SimpleFocusListWalker(self.right_top))
left_bot_box = urwid.ListBox(urwid.SimpleFocusListWalker(
self.left_bot))
right_bot_box = urwid.ListBox(
urwid.SimpleFocusListWalker(self.right_bot))
c_top = urwid.Columns([left_top_box, right_top_box])
c_bot = urwid.Columns([left_bot_box, right_bot_box])
p = urwid.Pile(
[c_top, urwid.Filler(urwid.Divider('-'), 'middle'), c_bot])
self.app_box = urwid.LineBox(p)
self.app_but = urwid.Padding(urwid.Button('Align'), 'center', 10)
super().__init__(self.app_box, footer=self.app_but, focus_part='body')
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 _game_screen(app_state, callback):
"""Create game screen of board, AI view, and status"""
buttons = [
_move_btn(0, 0, callback),
_move_btn(1, 0, callback),
_move_btn(2, 0, callback),
_move_btn(0, 1, callback),
_move_btn(1, 1, callback),
_move_btn(2, 1, callback),
_move_btn(0, 2, callback),
_move_btn(1, 2, callback),
_move_btn(2, 2, callback)
]
# Create game column
grid = uw.GridFlow(buttons, 5, 2, 2, 'center')
padded_grid = uw.Padding(grid, align='center', width=20)
header = uw.Text('Tic Tac Toe', align='center')
game_column = uw.ListBox([uw.Divider(), header, uw.Divider(), padded_grid])
# Describe AI view
ai_description = uw.Text('Waiting for first move...', align='center')
ai_column = uw.ListBox([
uw.Divider(),
uw.Text('AI Brain', align='center'),
uw.Divider(),
uw.LineBox(ai_description)
])
# Assemble composite screen
status = uw.Text('Status: Your Move', align='center')
columns = uw.Columns([game_column, ai_column])
screen = uw.Pile([('weight', 1, columns), ('pack', status),
('pack', uw.Divider())])
# Assign elements to UI state for later updating
app_state.ui[BUTTONS] = buttons
app_state.ui[STATUS] = status
app_state.ui[AI_DESCRIPTION] = ai_description
return (screen, app_state)
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 display():
# body
body_text = urwid.Text('''
The available controls:
arrows navigate
r mark as read
u mark as unread
enter open on browser,
select source
space show unread of source
f fetch
a add source
e edit source
d delete source
q quit
''',
align='left')
body_filler = urwid.Filler(body_text, valign='top')
body_padding = urwid.Padding(body_filler, left=1, right=1)
state.body = urwid.LineBox(body_padding)
# footer
footer = urwid.Button('OK', close)
footer = urwid.AttrWrap(footer, 'selectable', 'focus')
footer = urwid.GridFlow([footer], 6, 1, 1, 'center')
# layout
layout = urwid.Frame(state.body, footer=footer, focus_part='footer')
state.body = state.loop.widget
pile = urwid.Pile([layout])
over = urwid.Overlay(pile,
state.body,
align='center',
valign='middle',
width=41,
height=18)
state.loop.widget = over
def __init__(self, tui_frame):
self.tui_frame = tui_frame
self.doingit = False
self.disconnect = urwid.CheckBox('Close active sessions.', False)
self.close_button = CloseButton(lambda x: self._emit('close'))
if self.tui_frame.was_locked:
self.old_pass = urwid.Edit('Old passphrase: ',
multiline=True,
mask='*',
allow_tab=False,
wrap='clip')
else:
self.old_pass = urwid.Text(
'App does not currently require a passphrase.')
self.new_pass1 = urwid.Edit('New passphrase: ',
multiline=True,
mask='*',
allow_tab=False,
wrap='clip')
self.new_pass2 = urwid.Edit(' (repeated): ',
multiline=True,
mask='*',
allow_tab=False,
wrap='clip')
for w in (self.old_pass, self.new_pass1, self.new_pass2):
if not isinstance(w, urwid.Edit):
continue
urwid.connect_signal(w, 'change', lambda b, t: self.doit(t))
urwid.connect_signal(w, 'postchange', lambda b, t: self.cleanup())
self.pile = urwid.Pile([])
self.update_pile()
super().__init__(
urwid.LineBox(urwid.AttrWrap(urwid.Filler(self.pile), 'popbg')))
def _handle_input(self, input):
if input == "enter" or (input[0]=='meta mouse press' and input[1]==1): # View answers Either press Enter or "ALT + Left Click"
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') or (input[0]=='ctrl mouse press' and input[1]==1): # Open link Either press (B or b) or "CTRL + Left Click"
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 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 create_pop(self, user, msg):
user_label = uw.Text(user, )
if user == 'you':
user_label = uw.AttrMap(user_label, 'sender_client')
else:
user_label = uw.AttrMap(user_label, 'sender_user')
text = uw.Text(msg)
text = uw.Padding(text, left=1, right=1)
text = uw.LineBox(text,
tlcorner=u'\u2502',
blcorner=u'\u2502',
tline='',
bline='',
rline='',
trcorner='',
brcorner='')
div = uw.Divider()
w_cols = [(len(user), user_label), text]
w = uw.Columns(w_cols, dividechars=1)
w = uw.Padding(w, left=1)
w = uw.Pile([div, w])
return w
def __init__(self):
# file nme of this file (used for logging)
self.fileName = os.path.basename(__file__)
separator = urwid.Text("")
self.description = urwid.Text("Sensor 'PLACEHOLDER' " +
"in state 'PLACEHOLDER'.",
align="center")
option1 = urwid.Text("1. Continue", align="center")
option2 = urwid.Text("2. Abort", align="center")
instruction = urwid.Text("Please, choose an option.", align="center")
warningPile = urwid.Pile([
self.description, separator, option1, option2, separator,
instruction
])
warningBox = urwid.LineBox(warningPile, title="Warning")
self.warningMap = urwid.AttrMap(warningBox, "redColor")
