def factory_method():
dialog = urwid.Text(u'\nLoading...', align='center')
dialog = urwid.Filler(dialog)
dialog = urwid.AttrMap(urwid.LineBox(dialog), 'linebox')
return dialog
def render(self, size, focus=False):
"""
Render frame and return it.
"""
(maxcol, maxrow) = size
(htrim, ctrim, ftrim), (hrows, crows, frows) = self.frame_top_bottom(
(maxcol, maxrow), focus)
combinelist = []
depends_on = []
head = None
if htrim and htrim < hrows:
head = urwid.Filler(self.header, 'top').render(
(maxcol, htrim), focus and self.focus_part == 'header')
elif htrim:
head = self.header.render((maxcol, ), focus
and self.focus_part == 'header')
assert head.rows() == hrows, "rows, render mismatch"
if head:
combinelist.append((head, 'header', self.focus_part == 'header'))
depends_on.append(self.header)
if ftrim + htrim + ctrim < maxrow:
body = self.body.render((maxcol, maxrow - ftrim - htrim - ctrim),
focus and self.focus_part == 'body')
combinelist.append((body, 'body', self.focus_part == 'body'))
depends_on.append(self.body)
columns = None
if ctrim and ctrim < crows:
if self.focus_part == 'value':
columns = urwid.Filler(self.columns_pile, 'columns').render(
(maxcol, ftrim),
#TODO Changeit it to return command or result
focus and self.focus_part == 'value')
self.log.debug("render in value %s" %
(self.focus_part == 'value'))
elif self.focus_part == 'result':
columns = urwid.Filler(self.columns_pile, 'columns').render(
(maxcol, ftrim),
#TODO Changeit it to return command or result
focus and self.focus_part == 'result')
self.log.debug("render in result %s" %
(self.focus_part == 'result'))
else:
columns = urwid.Filler(self.columns_pile, 'columns').render(
(maxcol, ftrim),
#TODO Changeit it to return command or result
focus and self.focus_part == 'command')
self.log.debug("render in command %s" %
(self.focus_part == 'command'))
elif ctrim:
if self.focus_part == 'value':
columns = self.columns_pile.render(
(maxcol, ), focus and self.focus_part == 'value')
self.log.debug("render in value %s" %
(self.focus_part == 'value'))
elif self.focus_part == 'result':
columns = self.columns_pile.render(
(maxcol, ), focus and self.focus_part == 'result')
self.log.debug("render in result %s" %
(self.focus_part == 'result'))
else:
columns = self.columns_pile.render(
(maxcol, ), focus and self.focus_part == 'command')
self.log.debug("render in command %s" %
(self.focus_part == 'command'))
assert columns.rows() == crows, "rows, render mismatch"
if columns:
newfocus = "%s" % self.focus_part
combinelist.append((columns, 'columns',
self.focus_part == "command" or self.focus_part == "value" \
or self.focus_part == "result"))
depends_on.append(self.columns_pile)
foot = None
if ftrim and ftrim < frows:
foot = urwid.Filler(self.footer, 'bottom').render(
(maxcol, ftrim), focus and self.focus_part == 'footer')
elif ftrim:
foot = self.footer.render((maxcol, ), focus
and self.focus_part == 'footer')
assert foot.rows() == frows, "rows, render mismatch"
if foot:
combinelist.append((foot, 'footer', self.focus_part == 'footer'))
depends_on.append(self.footer)
return urwid.CanvasCombine(combinelist)
def fetest(self, desc, valign, height):
self.assertRaises(urwid.FillerError, lambda:
urwid.Filler(None, valign, height))
def __init__(self):
# show message in the center of the screen
super().__init__(
urwid.Filler(urwid.Text('Connecting...', align='center')))
def setTrace(self, trace, op_contracts=[], txhash=None, txinput=None):
self.operations = trace
self.op_contracts = op_contracts
ops_view = urwid.Text(self.getOp())
mem_view = urwid.Text(self.getMem())
memref_view = urwid.Text(self.getMemref())
stack_view = urwid.Text(self.getStack())
trace_view = urwid.Text(self.getTrace())
source_view = urwid.Text(self.getSource())
help_view = urwid.Text(self.getHelp())
# palettes are currently not used
palette = [
('banner', 'black', 'light gray'),
('streak', 'black', 'dark red'),
('bg', 'black', 'dark blue'),
]
palette = [
('headings', 'white,underline', 'black',
'bold,underline'), # bold text in monochrome mode
('body_text', 'dark cyan', 'light gray'),
('buttons', 'yellow', 'dark green', 'standout'),
('section_text', 'body_text'), # alias to body_text
('source', 'white', 'black',
'bold'), # bold text in monochrome mode
]
self.ops_view = ops_view
self.mem_view = mem_view
self.memref_view = memref_view
self.stack_view = stack_view
self.trace_view = trace_view
self.source_view = source_view
self.help_view = help_view
# indicate the online lookup with a * at the end of decoded
try:
txinput_decoded = ethereum_input_decoder.AbiMethod.from_input_lookup(
ethereum_input_decoder.Utils.str_to_bytes(txinput)
) if ethereum_input_decoder else "<input decoder not installed>"
except Exception as e: # not going to import from eth_abi to not make the code depending on it
txinput_decoded = "!! DecodingError: %s" % e
inp_view = urwid.Text("""
> tx: %s
> input: %s
> decoded*: %s""" % (txhash, txinput, txinput_decoded))
top = DebugViewer.wrap(
urwid.Pile([
DebugViewer.wrap(inp_view, ""),
urwid.Columns([
urwid.Pile([
DebugViewer.wrap(ops_view, "Op"),
DebugViewer.wrap(trace_view, "Trace")
]),
urwid.Pile([
DebugViewer.wrap(mem_view, "Memory"),
DebugViewer.wrap(memref_view,
"Memory Reference by Opcode"),
DebugViewer.wrap(stack_view, "Stack"),
DebugViewer.wrap(source_view, "Source"),
])
])
]), "Retromix")
horiz = urwid.Pile([top, DebugViewer.wrap(help_view, "Help")])
fill = urwid.Filler(horiz, 'top')
# self.dbg("Loaded %d operations" % len(self.operations) )
loop = urwid.MainLoop(
fill,
palette,
unhandled_input=lambda input: self.show_or_exit(input))
loop.run()
def create_main_view(user_info):
#used to easily insert a blank line widget
blank = urwid.Divider()
#signal handler for the connect button
def db_connect(button):
if user_info.mysql == True:
import mysqlDB as sqlDB # for MySQL
user_info.db_obj = sqlDB.MYsql()
elif user_info.psql == True:
import psqlDB as sqlDB # for PostgreSQL
user_info.db_obj = sqlDB.Psql()
if (user_info.db_name and user_info.db_uname):
# connect to the db
user_info.db_conn = user_info.db_obj.connectdb(
user_info.db_name, user_info.db_uname, user_info.db_pw)
# if connection error returned
if user_info.db_conn == -1:
db_error_box.original_widget = urwid.AttrMap(
urwid.Text(
u" Incorrect username, database name, or password.\n Please try again"
), 'error', 'error')
# if good connection returned
else:
#build out and show the main app view on the screen
mainview.show_main_view(frame, body, user_info)
else:
db_error_box.original_widget = urwid.AttrMap(
urwid.Text(u" Please enter your username and database name"),
'error', 'error')
#signal handler for radio buttons, stores input information from user
def radio_change(self, state):
if self.label == "MySQL":
if state == True:
user_info.mysql = True
user_info.psql = False
elif self.label == "PostgreSQL":
if state == True:
user_info.psql = True
user_info.mysql = False
#signal handler for text input, stores input information from user
def edit_change_event(self, text):
if self.caption == u"Database name: ":
user_info.db_name = text
elif self.caption == u"Database password: "******"Username: "******"First, please use the below radio buttons to select either a MySQL or PostgreSQL database to connect to."
)
text_mainbody_2 = urwid.Text(
u"Now, please enter in the database name and password below in order to connect to the database."
)
#setting up radio elements for MySQL or PostgreSQL choice
radio_list = []
user_info.psql = True # default to PostgreSQL
user_info.mysql = False
mysql_radio = urwid.AttrWrap(
urwid.RadioButton(radio_list,
u"MySQL",
False,
on_state_change=radio_change), 'main_sel',
'main_self')
psql_radio = urwid.AttrWrap(
urwid.RadioButton(radio_list,
u"PostgreSQL",
True,
on_state_change=radio_change), 'main_sel',
'main_self')
#setting up the edit input widgets for database name and password
db_uname_edit = urwid.Edit(u"Username: "******"")
urwid.connect_signal(db_uname_edit, 'change', edit_change_event)
db_uname_edit = urwid.AttrWrap(db_uname_edit, 'main_sel', 'main_self')
db_name_edit = urwid.Edit(u"Database name: ", "")
urwid.connect_signal(db_name_edit, 'change', edit_change_event)
db_name_edit = urwid.AttrWrap(db_name_edit, 'main_sel', 'main_self')
db_pw_edit = urwid.Edit(u"Database password: "******"", mask=u"*")
urwid.connect_signal(db_pw_edit, 'change', edit_change_event)
db_pw_edit = urwid.AttrWrap(db_pw_edit, 'main_sel', 'main_self')
#connect button
db_connect_btn = urwid.AttrWrap(urwid.Button(u"Connect", db_connect),
'main_sel', 'main_self')
#error box
db_error_box = urwid.AttrMap(urwid.Text(u""), 'main_sel')
#This is the pile widget that holds all of the main body widgets
body = urwid.WidgetPlaceholder(
urwid.Filler(urwid.Padding(urwid.Pile([
text_mainbody_1, blank,
urwid.Padding(urwid.Pile([psql_radio, mysql_radio]),
width=14,
left=5), blank, text_mainbody_2, blank,
urwid.Padding(urwid.Pile([db_uname_edit, db_name_edit,
db_pw_edit]),
left=5,
width=45), blank,
urwid.Padding(db_connect_btn, left=5, width=11), blank,
urwid.Padding(db_error_box, left=5, width=50)
]),
left=5,
right=5),
valign='top',
top=3))
#adding color styling to the body widget
body = urwid.AttrWrap(body, 'bg')
#Setting up frame
frame_header = urwid.Padding(urwid.Text(
u"Welcome to viewmydb! 'q' exits the pogram. Use the keyboard arrows to navigate."
),
left=1,
right=1)
frame_header = urwid.AttrWrap(frame_header, 'header')
frame = urwid.Frame(body=body, header=frame_header)
#return the frame all set up with body widget
return frame
import urwid
txt = urwid.Text(u"Hello World, Sandesh Rana welcome to the terminal user\n"
u"we agreed her to use this console until we grab the root \n"
"******Jai Nepal*******")
fill = urwid.Filler(txt, 'top')
loop = urwid.MainLoop(fill)
loop.run()
history = []
current = -1
page = None
palette = []
for x in range(1, sum(formats) + 1):
fgcolor = settings.getColor(x, 'fgcolor')
bg = settings.getColor(x, 'bgcolor')
fgfmts = {
j
for i in formats if x & i and i.name in settings.colors
for j in settings.colors[i.name][0]
}
if fgcolor:
fgfmts.add(fgcolor)
fg = ','.join(fgfmts)
palette.append((x, fg, bg))
urwid.command_map['k'] = 'cursor up'
urwid.command_map['j'] = 'cursor down'
urwid.command_map['ctrl b'] = 'cursor page up'
urwid.command_map['ctrl f'] = 'cursor page down'
ex = Ex()
header = urwid.Text('Wikicurses', align='center')
loading = urwid.Filler(urwid.Text('Loading...'), 'top')
progress = urwid.Text('')
footer = urwid.Columns([ex, ('pack', progress)], 2)
mainwidget = urwid.Frame(loading, urwid.AttrMap(header, formats.h1), footer)
loop = urwid.MainLoop(mainwidget, palette=palette, handle_mouse=settings.mouse)
urwid.Divider(div_char="-"),
output,
urwid.Divider(div_char="-"),
meta,
]
PALLETE = [
("bold", "bold", ""),
("wait", "yellow", ""),
("error", "light red", ""),
("success", "light green", ""),
]
# We use urwid.Filler because it needs to be centered. If we left out urwid.Filler
# then urwid would scream at me. I want to replace urwid.Filler, though.
# - ThatXliner
loop = urwid.MainLoop(urwid.Filler(urwid.Pile(UI, focus_item=1)),
palette=PALLETE)
def main() -> None:
"""The main CLI entry point.
Returns
-------
None
This function does not return anything.
"""
try:
loop.run()
except KeyboardInterrupt:
def __init__(self):
global loop
self.size = ui.get_cols_rows()
# Happy screen saying that you can't do anything because we're scanning
# for networks. :-)
self.screen_locker = urwid.Filler(
urwid.Text(('important', language['scanning_stand_by']),
align='center'))
self.no_wlan = urwid.Filler(
urwid.Text(('important', language['no_wireless_networks_found']),
align='center'))
self.TITLE = language['wicd_curses']
self.WIRED_IDX = 1
self.WLESS_IDX = 3
header = urwid.AttrWrap(urwid.Text(self.TITLE, align='right'),
'header')
self.wiredH = urwid.Filler(urwid.Text("Wired Network(s)"))
self.list_header = urwid.AttrWrap(urwid.Text(gen_list_header()),
'listbar')
self.wlessH = NSelListBox(
[urwid.Text("Wireless Network(s)"), self.list_header])
# Init this earlier to make update_status happy
self.update_tag = None
# FIXME: This should be two variables
self.focusloc = [1, 0]
# These are empty to make sure that things go my way.
wiredL, wlessL = [], []
self.frame = None
self.diag = None
self.wiredCB = urwid.Filler(WiredComboBox(wiredL))
self.wlessLB = urwid.ListBox(wlessL)
self.update_netlist(force_check=True, firstrun=True)
# Keymappings proposed by nanotube in #wicd
keys = [
('H', 'Help', None),
('right', 'Config', None),
#(' ',' ',None),
('K', 'RfKill', None),
('C', 'Connect', None),
('D', 'Disconn', None),
('R', 'Refresh', None),
('P', 'Prefs', None),
('I', 'Hidden', None),
('A', 'About', None),
('Q', 'Quit', loop.quit)
]
self.primaryCols = OptCols(keys, self.handle_keys)
self.status_label = urwid.AttrWrap(urwid.Text(''), 'important')
self.footer2 = urwid.Columns([self.status_label])
self.footerList = urwid.Pile([self.primaryCols, self.footer2])
self.frame = urwid.Frame(self.thePile,
header=header,
footer=self.footerList)
self.wiredCB.get_body().build_combobox(self.frame, ui, 3)
# Init the other columns used in the program
self.init_other_optcols()
self.frame.set_body(self.thePile)
# Booleans gallore!
self.prev_state = False
self.connecting = False
self.screen_locked = False
self.do_diag_lock = False #Whether the screen is locked beneath a dialog
self.diag_type = 'none' # The type of dialog that is up
self.scanning = False
self.pref = None
self.update_status()
# - http://urwid.org/reference/widget.html#text
# - http://urwid.org/manual/displayattributes.html#text-markup
# Note that since we're passing in the attrspec as a text markup parameter, this
# will only color the displayed text, rather than the entire widget. The entire
# widget actually extends the entire width of the terminal.
text_widget = urwid.Text((text_attributes, NAME), align='center')
# Our text widget is a 'Basic' widget and therefore cannot be the topmost widget
# passed to the event loop. Therefore, we have to wrap it in a 'box widget'
# container. The Filler widget is a very simple box widget that can be used for
# this purpose.
container_widget = urwid.Filler(text_widget, valign='middle')
if __name__ == '__main__':
# Urwid runs in an event loop. There are several built-in event loops to
# choose from. For this example, we're using the default MainLoop. This
# method accepts several parameters, those we're using here:
# widget: The topmost widget (must be a box widget).
# palette: The initial palette for the screen instance.
# unhandled_input: If the widget (or widget container) does not handle input
# events, that input will be sent to this hook for processing.
# - http://urwid.org/reference/main_loop.html
loop = urwid.MainLoop(container_widget, unhandled_input=input)
def help_dialog(body):
textT = urwid.Text(('header', 'wicd-curses help'), 'right')
textSH = urwid.Text([
'This is ', ('blue', 'wicd-curses-' + CURSES_REV), ' using wicd ',
unicode(daemon.Hello()), '\n'
])
textH = urwid.Text([
"For more detailed help, consult the wicd-curses(8) man page.\n",
('bold', '->'), ' and ', ('bold', '<-'),
" are the right and left arrows respectively.\n"
])
text1 = urwid.Text([
('bold', ' H h ?'),
": Display this help dialog\n",
('bold', 'enter C'),
": Connect to selected network\n",
('bold', ' D'),
": Disconnect from all networks\n",
('bold', ' ESC'),
": Stop a connection in progress\n",
('bold', ' F5 R'),
": Refresh network list\n",
('bold', ' P'),
": Prefrences dialog\n",
])
text2 = urwid.Text([
('bold', ' I'),
": Scan for hidden networks\n",
('bold', ' S'),
": Select scripts\n",
('bold', ' O'),
": Set up Ad-hoc network\n",
('bold', ' ->'),
": Configure selected network\n",
('bold', ' A'),
": Display 'about' dialog\n",
('bold', ' F8 q Q'),
": Quit wicd-curses\n",
])
textF = urwid.Text('Press any key to return.')
# textJ = urwid.Text(('important','Nobody expects the Spanish Inquisition!'))
blank = urwid.Text('')
cols = urwid.Columns([text1, text2])
pile = urwid.Pile([textH, cols])
fill = urwid.Filler(pile)
frame = urwid.Frame(fill, header=urwid.Pile([textT, textSH]), footer=textF)
dim = ui.get_cols_rows()
while True:
ui.draw_screen(dim, frame.render(dim, True))
keys = ui.get_input()
# Don't stop because someone let go of the mouse on the frame
mouse_release = False
for k in keys:
if urwid.util.is_mouse_event(k) and k[0] == "mouse release":
mouse_release = True
break
if mouse_release:
continue
if 'window resize' in keys:
dim = ui.get_cols_rows()
elif keys:
break
def factory_method():
dialog = InfoDialog(message)
urwid.connect_signal(dialog, dialog.SIGNAL_OK, on_ok_signal)
return urwid.Filler(dialog)
def factory_method():
dialog = ErrorDialog(error)
urwid.connect_signal(dialog, dialog.SIGNAL_OK, on_ok_signal)
return urwid.Filler(dialog)
def update(self, loop=None, user_data=None):
state = self.robot.get_current_state()
r1_pose = self.robot.get_current_pose(self.r1_frame_id).pose
r2_pose = self.robot.get_current_pose(self.r2_frame_id).pose
st = jmsg2dict(state.joint_state)
s = list()
s += [" R1 R2 \n"]
s += [" [rad] [deg] [rad] [deg] \n"]
r1_val = st["r1_joint_s"]
r2_val = st["r2_joint_s"]
s += [
" S: ",
self.format_val("r1_joint_s_rad", r1_val), " ",
self.format_val("r1_joint_s_deg", rad2deg(r1_val)), " S: ",
self.format_val("r2_joint_s_rad", r2_val), " ",
self.format_val("r2_joint_s_deg", rad2deg(r2_val)), '\n'
]
r1_val = st["r1_joint_l"]
r2_val = st["r2_joint_l"]
s += [
" L: ",
self.format_val("r1_joint_l_rad", r1_val), " ",
self.format_val("r1_joint_l_deg", rad2deg(r1_val)), " L: ",
self.format_val("r2_joint_l_rad", r2_val), " ",
self.format_val("r2_joint_l_deg", rad2deg(r2_val)), '\n'
]
r1_val = st["r1_joint_u"]
r2_val = st["r2_joint_u"]
s += [
" U: ",
self.format_val("r1_joint_u_rad", r1_val), " ",
self.format_val("r1_joint_u_deg", rad2deg(r1_val)), " U: ",
self.format_val("r2_joint_u_rad", r2_val), " ",
self.format_val("r2_joint_u_deg", rad2deg(r2_val)), '\n'
]
r1_val = st["r1_joint_r"]
r2_val = st["r2_joint_r"]
s += [
" R: ",
self.format_val("r1_joint_r_rad", r1_val), " ",
self.format_val("r1_joint_r_deg", rad2deg(r1_val)), " R: ",
self.format_val("r2_joint_r_rad", r2_val), " ",
self.format_val("r2_joint_r_deg", rad2deg(r2_val)), '\n'
]
r1_val = st["r1_joint_b"]
r2_val = st["r2_joint_b"]
s += [
" B: ",
self.format_val("r1_joint_b_rad", r1_val), " ",
self.format_val("r1_joint_b_deg", rad2deg(r1_val)), " B: ",
self.format_val("r2_joint_b_rad", r2_val), " ",
self.format_val("r2_joint_b_deg", rad2deg(r2_val)), '\n'
]
r1_val = st["r1_joint_t"]
r2_val = st["r2_joint_t"]
s += [
" T: ",
self.format_val("r1_joint_t_rad", r1_val), " ",
self.format_val("r1_joint_t_deg", rad2deg(r1_val)), " T: ",
self.format_val("r2_joint_t_rad", r2_val), " ",
self.format_val("r2_joint_t_deg", rad2deg(r2_val)), '\n'
]
s += ["\n\n"]
s += [" ", self.r1_frame_id, " ", self.r2_frame_id, "\n"]
s += [
" X: ",
self.format_val("r1_x", r1_pose.position.x), " X: ",
self.format_val("r2_x", r2_pose.position.x), '\n'
]
s += [
" Y: ",
self.format_val("r1_y", r1_pose.position.y), " Y: ",
self.format_val("r2_y", r2_pose.position.y), '\n'
]
s += [
" Z: ",
self.format_val("r1_z", r1_pose.position.z), " Z: ",
self.format_val("r2_z", r2_pose.position.z), '\n'
]
s += [
"QX: ",
self.format_val("r1_qx", r1_pose.orientation.x), " QX: ",
self.format_val("r2_qx", r2_pose.orientation.x), '\n'
]
s += [
"QY: ",
self.format_val("r1_qy", r1_pose.orientation.y), " QY: ",
self.format_val("r2_qy", r2_pose.orientation.y), '\n'
]
s += [
"QZ: ",
self.format_val("r1_qz", r1_pose.orientation.z), " QZ: ",
self.format_val("r2_qz", r2_pose.orientation.z), '\n'
]
s += [
"QW: ",
self.format_val("r1_qw", r1_pose.orientation.w), " QW: ",
self.format_val("r2_qw", r2_pose.orientation.w), '\n'
]
text = urwid.AttrMap(urwid.Text(s), 'body')
self.view.set_body(urwid.Filler(text, 'top'))
self.update_alarm = self.loop.set_alarm_in(self.refresh, self.update)
def exit_on_q(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
palette = [
('text_background', 'black', 'light gray'),
('rowbar', 'black', 'dark red'),
('background', 'black', 'dark blue'),
]
# Specify the line of text
txt = urwid.Text(
('text_background', u" E L E C T R O N A U T C O M P A N Y "),
align='center')
txt2 = urwid.Text(('text_background', u" MAY THIS WILL WORK "), align='center')
# Map the 'rowbar' color attributes to the line of text
map1 = urwid.AttrMap(txt, 'rowbar')
map1b = urwid.AttrMap(txt2, 'rowbar')
# Apply map1 to the filler
fill = urwid.Filler(map1)
fillb = urwid.Filler(map1b)
# Map the 'background' color attributes to the fill
map2 = urwid.AttrMap(fill, 'background')
map2b = urwid.AttrMap(fillb, 'background')
loop = urwid.MainLoop(map2b, palette, unhandled_input=exit_on_q)
loop.run()
def _messageExit(self, message):
# We print the menu data in the middle of the screen
new_widget = urwid.Filler(urwid.Text(message, align='center'))
self._frame.set_body(new_widget)
self.loop.draw_screen()
self._frame.set_focus('header')
tab v tab v tab v tab v tab v tab v tab v tab v tab v tab v tab v tabv tabv
tab w tab wtab wta b wt ab w tab wtab wta b wt ab w tab wta b wtabw tabw
tab x tab x ta x tb x ab xtab xtab3 xta 3 xtb 3 xab xab3 xab x ta x 3
tab y tab y tab y tab y tab y tab y tab y tab y tab y tab y tab y taby3 tay 3
tab z tab z tab z tab z tab z tab z tab z tab z tab z tab z tab z tabz3 taz 3
tab 1 tab 1 tab 1 tab 1 tab 1 tab 1 tab 1 tab 1 tab 1 tab 1 tab 1 tab13 ta1 3
tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab23 ta2 3
tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2 tab 2tab 2 tab 2
tab 3 tab 3 tab 3 tab 3 tab 3 tab 3 tab 3 tab 3 tab 3 tab 3 tab 3 tab3 tab3
tab 4 tab 4 tab 4 tab 4 tab 4 tab 4 tab 4 tab 4 tab 4 tab 4 tab 4 tab4 tab4
tab 5 tab 5 tab 5 tab 5 tab 5 tab 5 tab 5 tab 5 tab 5 tab 5 tab 5 tab5 tab5
tab 6 tab 6 tab 6 tab 6 tab 6 tab 6 tab 6 tab 6 tab 6 tab 6 tab 6 tab6 tab6
tab 7 tab 7 tab 7 tab 7 tab 7 tab 7 tab 7 tab 7 tab 7 tab 7 tab 7 tab7 tab7
tab 8 tab 8 tab 8 tab 8 tab 8 tab 8 tab 8 tab 8 tab 8 tab 8 tab 8 tab8 tab8""" )
f1 = urwid.AttrWrap( urwid.Filler( urwid.AttrWrap( urwid.LineBox( txt1, "body" ), 'dif' ) ), 'body' )
f2 = scrollview.ScrollView(urwid.BigText("Hello World and welcome to my scroll view",
urwid.Thin6x6Font( )), 'scroll')
f3 = scrollview.ScrollView(txt3, 'scroll')
tab_view = tabview.TabView(
'header',
'header1',
[ (u'Hello World', f1, True), (u'Goodbyte', f2, True), (u'test.py', f3) ]
)
split1 = splitview.SplitView(
f1,
tab_view,
False,
0.4,
import urwid
palette = [
('body', 'default', 'default'),
('foot', 'dark cyan', 'dark blue', 'bold'),
('key', 'light cyan', 'dark blue', 'underline'),
]
# txt = urwid.Text(('foot', "Hello World"))
txt = urwid.Text(
('foot', [u"nesting example ", ('key', u"inside"), u" outside"]))
fill = urwid.Filler(txt, 'middle')
loop = urwid.MainLoop(fill, palette=palette)
loop.run()
def main(argv):
""" Main function. """
global ui, frame
if len(argv) < 2:
print('Network id to configure is missing, aborting.')
sys.exit(1)
ui = urwid.curses_display.Screen()
ui.register_palette([
('body', 'default', 'default'),
('focus', 'dark magenta', 'light gray'),
('editcp', 'default', 'default', 'standout'),
('editbx', 'light gray', 'dark blue'),
('editfc', 'white', 'dark blue', 'bold'),
])
network = argv[1]
network_type = argv[2]
script_info = get_script_info(network, network_type)
blank = urwid.Text('')
pre_entry_t = ('body', _('Pre-connection Script') + ': ')
post_entry_t = ('body', _('Post-connection Script') + ': ')
pre_disconnect_entry_t = ('body', _('Pre-disconnection Script') + ': ')
post_disconnect_entry_t = ('body', _('Post-disconnection Script') + ': ')
global pre_entry, post_entry, pre_disconnect_entry, post_disconnect_entry
pre_entry = urwid.AttrWrap(urwid.Edit(pre_entry_t,
none_to_blank(script_info.get('pre_entry'))),
'editbx', 'editfc')
post_entry = urwid.AttrWrap(urwid.Edit(post_entry_t,
none_to_blank(script_info.get('post_entry'))),
'editbx', 'editfc')
pre_disconnect_entry = urwid.AttrWrap(urwid.Edit(pre_disconnect_entry_t,
none_to_blank(script_info.get('pre_disconnect_entry'))),
'editbx', 'editfc')
post_disconnect_entry = urwid.AttrWrap(urwid.Edit(post_disconnect_entry_t,
none_to_blank(script_info.get('post_disconnect_entry'))),
'editbx', 'editfc')
# The buttons
ok_button = urwid.AttrWrap(
urwid.Button(_('OK'), ok_callback),
'body', 'focus'
)
cancel_button = urwid.AttrWrap(
urwid.Button(_('Cancel'), cancel_callback),
'body', 'focus'
)
button_cols = urwid.Columns([ok_button, cancel_button], dividechars=1)
lbox = urwid.Pile([('fixed', 2, urwid.Filler(pre_entry)),
#('fixed', urwid.Filler(blank), 1),
('fixed', 2, urwid.Filler(post_entry)),
('fixed', 2, urwid.Filler(pre_disconnect_entry)),
('fixed', 2, urwid.Filler(post_disconnect_entry)),
#blank, blank, blank, blank, blank,
urwid.Filler(button_cols, 'bottom')
])
frame = urwid.Frame(lbox)
result = ui.run_wrapper(run)
if result:
script_info["pre_entry"] = blank_to_none(pre_entry.get_edit_text())
script_info["post_entry"] = blank_to_none(post_entry.get_edit_text())
script_info["pre_disconnect_entry"] = \
blank_to_none(pre_disconnect_entry.get_edit_text())
script_info["post_disconnect_entry"] = \
blank_to_none(post_disconnect_entry.get_edit_text())
write_scripts(network, network_type, script_info)
import urwid
def exit_on_q(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
palette = [
('banner', 'black', 'light gray'),
('streak', 'black', 'dark red'),
('bg', 'black', 'dark blue'),
]
txt = urwid.Text(('banner', u" Hello World "), align='center')
map1 = urwid.AttrMap(txt, 'streak')
fill = urwid.Filler(map1)
map2 = urwid.AttrMap(fill, 'bg')
loop = urwid.MainLoop(map2, palette, unhandled_input=exit_on_q)
loop.run()
def startConsole(self):
# generate widget to show the status of the alert system
for option in self.options:
if option.type == "alertSystemActive":
if option.value == 0:
self.alertSystemActive = \
StatusUrwid("alert system status",
"Status", "Deactivated")
self.alertSystemActive.turnRed()
else:
self.alertSystemActive = \
StatusUrwid("alert system status",
"Status", "Activated")
self.alertSystemActive.turnGreen()
if self.alertSystemActive == None:
logging.error("[%s]: No alert system status option." %
self.fileName)
return
# generate widget to show the status of the connection
self.connectionStatus = StatusUrwid("connection status", "Status",
"Online")
self.connectionStatus.turnNeutral()
# generate pin field
self.pinEdit = PinUrwid("Enter PIN:\n", multiline=False, mask="*")
self.pinEdit.registerConsoleInstance(self)
# generate menu
option1 = urwid.Text("1. Activate alert system")
option2 = urwid.Text("2. Deactivate alert system")
option3 = urwid.Text("3. Activate alert system in %d seconds" %
self.timeDelayedActivation)
separator = urwid.Text("")
instruction = urwid.Text("Please, choose an option.")
self.menuPile = urwid.Pile(
[option1, option2, option3, separator, instruction])
# generate edit/menu part of the screen
self.editPartScreen = urwid.Pile([self.pinEdit])
boxedEditPartScreen = urwid.LineBox(self.editPartScreen, title="menu")
# initialize warning view urwid
self.warningView = WarningUrwid()
# generate final body object
self.finalBody = urwid.Pile([
self.alertSystemActive.get(),
self.connectionStatus.get(), boxedEditPartScreen
])
fillerBody = urwid.Filler(self.finalBody, "top")
# generate header
header = urwid.Text("alertR keypad manager", align="center")
# build frame for final rendering
self.mainFrame = urwid.Frame(fillerBody, header=header)
# color palette
palette = [
('redColor', 'black', 'dark red'),
('greenColor', 'black', 'dark green'),
('grayColor', 'black', 'light gray'),
('connected', 'black', 'dark green'),
('disconnected', 'black', 'dark red'),
('sensoralert', 'black', 'yellow'),
('connectionfail', 'black', 'light gray'),
('timedout', 'black', 'dark red'),
('neutral', '', ''),
]
# create urwid main loop for the rendering
self.mainLoop = urwid.MainLoop(self.mainFrame,
palette=palette,
unhandled_input=self.handleKeypress)
# create a file descriptor callback to give other
# threads the ability to communicate with the urwid thread
self.screenFd = self.mainLoop.watch_pipe(self.screenCallback)
# set the correct view in which we are
self.inPinView = True
self.inMenuView = False
self.inWarningView = False
# run urwid loop
self.mainLoop.run()
return any(char.islower() for char in password)
def has_symbols(password):
return any(not char.isalpha() and not char.isdigit() for char in password)
def doesnt_consist_of_symbols(password):
return any(char.isalpha() or char.isdigit() for char in password)
def on_ask_change(edit, new_edit_text):
score = 0
for test in password_strength_tests:
if test(new_edit_text):
score = score + 2
reply.set_text('Рейтинг этого пароля:%s' % score)
if __name__ == '__main__':
password_strength_tests = [
is_very_long, has_digit, has_letters, has_upper_letters,
has_lower_letters, has_symbols, doesnt_consist_of_symbols
]
ask = urwid.Edit('Введите пароль: ', mask='*')
reply = urwid.Text('')
menu = urwid.Pile([ask, reply])
menu = urwid.Filler(menu, valign='top')
urwid.connect_signal(ask, 'change', on_ask_change)
urwid.MainLoop(menu).run()
#!/usr/bin/env python
#! -*- coding:utf-8 -*-
import urwid
__author__ = "Paweł Siergiejuk"
__date__ = "08/03/2018"
__version__ = "v0.0"
__email__ = "*****@*****.**"
__status__ = "Development"
if __name__ == "__main__":
txt = urwid.Text(u"Hello World\nAdd new line")
fill = urwid.Filler(txt, "top")
loop = urwid.MainLoop(fill)
loop.run()
def ftest(self, desc, valign, height, maxrow, top, bottom,
min_height=None):
f = urwid.Filler(None, valign, height, min_height)
t, b = f.filler_values((20,maxrow), False)
assert (t,b)==(top,bottom), "%s expected %s but got %s"%(
desc, (top,bottom), (t,b))
def setup_view(self):
self.clock_txt = urwid.BigText(time.strftime('%H:%M:%S'),
urwid.font.HalfBlock5x4Font())
self.view = urwid.Padding(self.clock_txt, 'center', width='clip')
self.view = urwid.AttrMap(self.view, 'body')
self.view = urwid.Filler(self.view, 'middle')
" to quit."])
pile = urwid.Pile([text_arrow_keys,
text_pages,
text_home_end,
urwid.Divider("─"),
urwid.Divider(" "),
columns,
urwid.Divider(" "),
text_challenge,
urwid.Divider(" "),
urwid.Divider("─"),
text_esc])
main_widget = urwid.Filler(pile, "top")
def keypress(key):
if key in ('q', 'Q', 'esc'):
raise urwid.ExitMainLoop()
loop = urwid.MainLoop(main_widget,
PALETTE,
unhandled_input=keypress)
loop.run()
# We'll combine the RadioButton objects in a GridFlow object, which will pack # them as closely as possible. body_gridflow = urwid.GridFlow( button_group, 30, 4, 1, 'center' ) # The frame we use later must have a box object for its body. body_filled = urwid.Filler( body_gridflow, height='pack', valign='top' ) layout = urwid.Frame( body_filled, header=text_header ) loop = urwid.MainLoop(layout, palette) loop.run()
def test_repr(self):
repr(urwid.Filler(urwid.Text(u'hai')))
def create(self) -> urwid.Widget:
msg = urwid.Text(self.message)
haligned = urwid.Padding(msg, width=len(self.message), align="center")
valigned = urwid.Filler(haligned, "middle")
# Wrap in KeySignals to intercept all escape keypresses
return widget.KeySignals(valigned)
