Beispiel #1
0
    def __init__(self, dict, title):
        self.selectedCmd = None
        self.dict = dict
        self.main = urwid.Padding(self.__menu(title), left=2, right=2)
        top = urwid.Overlay(self.main,
                            urwid.SolidFill(u'\N{MEDIUM SHADE}'),
                            align='center',
                            width=('relative', 80),
                            valign='middle',
                            height=('relative', 80),
                            min_width=20,
                            min_height=9)

        self.txt = urwid.Text(u"Hello World", align='center')
        fill = urwid.Filler(self.txt, valign='middle')
        box = urwid.LineBox(fill, title='Information')

        widget_list = []

        widget_list.append(top)
        widget_list.append(box)

        self.col = urwid.Columns(widget_list, 0, None, 1, None)
        self.mainLoop = urwid.MainLoop(self.col,
                                       palette=[('reversed', 'standout', '')],
                                       unhandled_input=show_or_exit)
Beispiel #2
0
    def run(self):
        if not sys.stdout.isatty():
            print(
                "Error: mitmproxy's console interface requires a tty. "
                "Please run mitmproxy in an interactive shell environment.",
                file=sys.stderr)
            sys.exit(1)

        self.ui = window.Screen()
        self.ui.set_terminal_properties(256)
        self.set_palette(self.options, None)
        self.options.subscribe(
            self.set_palette,
            ["console_palette", "console_palette_transparent"])
        self.loop = urwid.MainLoop(
            urwid.SolidFill("x"),
            event_loop=urwid.AsyncioEventLoop(loop=asyncio.get_event_loop()),
            screen=self.ui,
            handle_mouse=self.options.console_mouse,
        )
        self.window = window.Window(self)
        self.loop.widget = self.window
        self.window.refresh()

        if self.start_err:

            def display_err(*_):
                self.sig_add_log(None, self.start_err)
                self.start_err = None

            self.loop.set_alarm_in(0.01, display_err)

        super().run_loop(self.loop.run)
Beispiel #3
0
 def decorate(self, pos, widget, is_first=True):
     line = None
     indent = self._tree.depth(pos) * self._indent
     cols = [(indent, urwid.SolidFill(' ')), widget]
     # construct a Columns, defining all spacer as Box widgets
     line = urwid.Columns(cols, box_columns=range(len(cols))[:-1])
     return line
Beispiel #4
0
    def test_overlay(self):
        s1 = urwid.SolidFill(u'1')
        s2 = urwid.SolidFill(u'2')
        o = urwid.Overlay(s1, s2, 'center', ('relative', 50), 'middle',
                          ('relative', 50))
        self.assertEqual(o.focus, s1)
        self.assertEqual(o.focus_position, 1)
        self.assertRaises(IndexError,
                          lambda: setattr(o, 'focus_position', None))
        self.assertRaises(IndexError, lambda: setattr(o, 'focus_position', 2))

        self.assertEqual(o.contents[0],
                         (s2, urwid.Overlay._DEFAULT_BOTTOM_OPTIONS))
        self.assertEqual(o.contents[1],
                         (s1, ('center', None, 'relative', 50, None, 0, 0,
                               'middle', None, 'relative', 50, None, 0, 0)))
Beispiel #5
0
    def run(self):
        self.ui = urwid.raw_display.Screen()
        self.ui.set_terminal_properties(256)
        self.set_palette(self.options, None)
        self.options.subscribe(
            self.set_palette,
            ["console_palette", "console_palette_transparent"])
        self.loop = urwid.MainLoop(
            urwid.SolidFill("x"),
            screen=self.ui,
            handle_mouse=self.options.console_mouse,
        )
        self.ab = statusbar.ActionBar()

        self.loop.set_alarm_in(0.01, self.ticker)
        self.loop.set_alarm_in(0.0001, lambda *args: self.view_flowlist())

        self.start()
        try:
            self.loop.run()
        except Exception:
            self.loop.stop()
            sys.stdout.flush()
            print(traceback.format_exc(), file=sys.stderr)
            print("mitmproxy has crashed!", file=sys.stderr)
            print("Please lodge a bug report at:", file=sys.stderr)
            print("\thttps://github.com/mitmproxy/mitmproxy", file=sys.stderr)
            print("Shutting down...", file=sys.stderr)
        finally:
            sys.stderr.flush()
            super().shutdown()
Beispiel #6
0
def display(loop, news_items):
    terminal_size = os.get_terminal_size()

    unread_count = get_node_unread_count(state.selected_node_id)
    unread_count_txt = urwid.Text('Unread: {}'.format(unread_count))
    last_update_txt = urwid.Text('Updated: {}'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S')), align='right')
    columns_info = urwid.Columns([(round(terminal_size.columns / 2), unread_count_txt), last_update_txt])

    sources_list = generate_sources_list()
    news_list = generate_news_list(news_items)

    elements_list = urwid.ListBox(news_list)
    sources_list = urwid.ListBox(sources_list)

    if state.list_with_focus == 'news_list':
        selected_list = elements_list
    else:
        selected_list = sources_list

    if len(selected_list.body) == 0:
        pass
    elif len(selected_list.body) > state.index_with_focus:
        selected_list.set_focus(state.index_with_focus)
    elif len(selected_list.body) == state.index_with_focus:
        selected_list.set_focus((state.index_with_focus - 1))

    columns_news = urwid.Columns([(28, sources_list), (1, urwid.SolidFill(' ')), ((terminal_size.columns - 29), elements_list)])
    columns_news.set_focus(selected_list)

    pile = urwid.Pile([columns_info, urwid.Divider(), (terminal_size.lines - 2, columns_news)])
    widget = urwid.Filler(pile, valign='top')

    state.loop.widget = widget
Beispiel #7
0
    def on_unicode_checkbox(self, w=None, state=False):
        """Enable smooth edges if utf-8 is supported"""
        logging.debug("unicode State is %s", state)

        # Update the controller to the state of the checkbox
        self.controller.smooth_graph_mode = state
        if state:
            self.hline = urwid.AttrWrap(
                urwid.SolidFill(u'\N{LOWER ONE QUARTER BLOCK}'), 'line')
        else:
            self.hline = urwid.AttrWrap(urwid.SolidFill(u' '), 'line')

        for graph in self.graphs.values():
            graph.set_smooth_colors(state)

        self.show_graphs()
Beispiel #8
0
    def __init__(self, master):
        self.master = master
        body = [urwid.Divider()]
        new_game_button = urwid.Button("New Game")
        new_game_button._label.align = "center"
        urwid.connect_signal(new_game_button, "click", self.new_game)
        body.append(urwid.AttrMap(new_game_button, None, focus_map="line"))
        quick_game_button = urwid.Button("Quick Start")
        quick_game_button._label.align = "center"
        urwid.connect_signal(quick_game_button, "click", self.quick_game)
        body.append(urwid.AttrMap(quick_game_button, None, focus_map="line"))
        help_button = urwid.Button("Help")
        help_button._label.align = "center"
        urwid.connect_signal(help_button, "click", self.help)
        body.append(urwid.AttrMap(help_button, None, focus_map="line"))
        quit_button = urwid.Button("Quit")
        quit_button._label.align = "center"
        urwid.connect_signal(quit_button, "click", self.exit_program)
        body.append(urwid.AttrMap(quit_button, None, focus_map="line"))

        listbox = urwid.ListBox(urwid.SimpleFocusListWalker(body))
        super(StartScreen, self).__init__(listbox,
                                          urwid.SolidFill(u"\N{MEDIUM SHADE}"),
                                          align="center",
                                          width=("relative", 60),
                                          valign="middle",
                                          height=("relative", 60),
                                          min_width=40,
                                          min_height=16)
Beispiel #9
0
    def render(self, size, focus=False):
        if not self._connected:
            size = self.pack(size)
            return urwid.AttrMap(urwid.SolidFill(' '), 'bottombar').render(size)

        canv_up_tail = self._mk_tail_canv('up', '↑')
        canv_dn_tail = self._mk_tail_canv('down', '↓')

        # List of (canvas, position, focus) tuples
        combinelist = []

        # Download
        canv_dn = self._attr_dn.render((self._RATE_WIDTH,))
        combinelist.append((canv_dn, None, False, self._RATE_WIDTH))
        if self._dn_limit_width > 0:
            canv_dn_limit = self._attr_dn_limit.render((self._dn_limit_width,))
            combinelist.append((canv_dn_limit, None, False, self._dn_limit_width))
        combinelist.append((canv_dn_tail, None, False, self._TAIL_WIDTH))

        combinelist.append((self._spacer_canvas, None, False, self._SPACER_WIDTH))

        # Upload
        canv_up = self._attr_up.render((self._RATE_WIDTH,))
        combinelist.append((canv_up, None, False, self._RATE_WIDTH))
        if self._up_limit_width > 0:
            canv_up_limit = self._attr_up_limit.render((self._up_limit_width,))
            combinelist.append((canv_up_limit, None, False, self._up_limit_width))
        combinelist.append((canv_up_tail, None, False, self._TAIL_WIDTH))

        return urwid.CanvasJoin(combinelist)
Beispiel #10
0
    def build(self):
        """
        Composes child views and components into a single object to be rendered.

        Parameters
        ----------
        None

        Returns
        -------
        None

        Raises
        ------
        None
        """
        self.controls = DashboardControls(self.model)
        self.liveDashboard = LiveDashboardData(self.model)
        self.prerecordedDashboard = PrerecordedDashboardData(self.model)
        self.emptyDashboard = urwid.Pile([])

        self.data = urwid.WidgetPlaceholder(self.emptyDashboard)
        vline = urwid.AttrWrap(urwid.SolidFill(u'\u2502'), 'line')

        body = urwid.Columns([
            (30, self.controls),  # 30 is number of columns wide
            ('fixed', 1, vline),  # fixed means it can't move
            self.data
        ],
            dividechars=1)
        return body
Beispiel #11
0
    def __init__(self, master):
        self.master = master

        text = """
write me, help!
help!
        
"""
        utext = urwid.Text(text)

        body = [utext]

        back_button = urwid.Button("Back")
        back_button._label.align = "center"
        urwid.connect_signal(back_button, "click", self.back)
        body.append(urwid.AttrMap(back_button, None, focus_map="line"))
        listbox = urwid.ListBox(urwid.SimpleFocusListWalker(body))
        super(HelpScreen, self).__init__(listbox,
                                         urwid.SolidFill(u"\N{MEDIUM SHADE}"),
                                         align="center",
                                         width=("relative", 60),
                                         valign="middle",
                                         height=("relative", 60),
                                         min_width=40,
                                         min_height=16)
Beispiel #12
0
    def __init__(self, controller):

        self.controller = controller
        self.hline = urwid.AttrWrap(urwid.SolidFill(u'_'), 'line')

        clock_text = seconds_to_text(self.controller.stress_time)
        self.clock_view = urwid.Text(('bold text', clock_text), align="center")

        self.mode_buttons = []
        self.refresh_rate_ctrl = urwid.Edit(('bold text', u'Refresh[s]:'),
                                            self.controller.refresh_rate)

        # Visible graphs are the graphs currently displayed, this is a
        # subset of the available graphs for display
        self.visible_graphs = {}
        self.graph_place_holder = urwid.WidgetPlaceholder(urwid.Pile([]))

        self.main_window_w = []

        self.stress_menu = StressMenu(self.on_menu_close)
        self.help_menu = HelpMenu(self.on_menu_close)
        self.about_menu = AboutMenu(self.on_menu_close)
        self.temp_sensors_menu = TempSensorsMenu(self.on_sensors_menu_close)
        self.global_data = GlobalData(is_admin)

        self.stress_menu.sqrt_workers = str(self.global_data.num_cpus)
        self.left_margin = 0
        self.top_margin = 0

        urwid.WidgetPlaceholder.__init__(self, self.main_window())
        urwid.connect_signal(self.refresh_rate_ctrl, 'change',
                             self.update_refresh_rate)
Beispiel #13
0
    def __init__(self, top_widget, *args, **kw):
        super(SSHDialog, self).__init__(top_widget, *args, **kw)
        self.top_widget = top_widget

        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')

        yes = urwid.AttrMap(urwid.Button('Yes', self.handle_input), 'focus',
                            'selectable')
        no = urwid.AttrMap(urwid.Button('No', self.handle_input), 'focus',
                           'selectable')

        buttons = urwid.GridFlow([no, yes], 10, 3, 1, 'center')

        bottom = urwid.Padding(buttons, align='right', width='pack')
        bottom = urwid.AttrMap(urwid.Filler(bottom, valign='bottom'), 'wcolor')

        content = urwid.Pile([top, bottom], 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 main():
    palette = [
        ("banner", "", "", "", "#ffa", "#60d"),
        ("streek", "", "", "", "g50", "#60a"),
        ("in", "", "", "", "g38", "#808"),
        ("out", "", "", "", "g27", "#a06"),
        ("bg", "", "", "", "g7", "#d06"),
    ]

    placeholder = urwid.SolidFill()
    loop = urwid.MainLoop(placeholder, palette, unhandled_input=show_or_exit)
    loop.screen.set_terminal_properties(colors=256)
    loop.widget = urwid.AttrMap(placeholder, "bg")
    loop.widget.original_widget = urwid.Filler(urwid.Pile([]))

    div = urwid.Divider()
    outside = urwid.AttrMap(div, "out")
    inside = urwid.AttrMap(outside, "in")
    txt = urwid.Text(("banner", u"Hello World)"), align="center")
    streek = urwid.AttrMap(txt, "streek")
    pile = loop.widget.base_widget  #this skips decorations
    for item in (outside, inside, streek, inside, outside):
        pile.contents.append((item, pile.options()))

    loop.run()
Beispiel #15
0
 def __get_screen(self):
     arena = urwid.AttrMap(urwid.SolidFill(' '), 'arena')
     arena = self.player.render(arena)
     for e in self.entities:
         arena = e.render(arena)
     return urwid.Overlay(arena, self.background, 'center',
                          Config.ARENA_WIDTH, 'middle', Config.ARENA_HEIGHT)
Beispiel #16
0
    def _build_container(self, ui_container):
        assert ui.ContainerElement in type(ui_container).mro()
        widgets = []

        for element in ui_container.children:
            widget = self.build(element)
            if type(ui_container) is ui.ConfirmedEntry:
                # Special handling of the special widget, but why?
                # Why? Because nested Pile's need to be taken care of.
                # FIXME Generalize this (to cover other widgets too)
                widgets.append(widget)
            else:
                widgets.append(("pack", widget))

        # Add buttons
        if hasattr(ui_container, "buttons") and ui_container.buttons:
            widgets.append(self._build_button_bar(ui_container.buttons))

        if not any(type(t) is not tuple or t[0] == "weight" for t in widgets):
            # Add a weighted dummy if no weigthed dummy is in the Pile,
            # to fullfill urwid's assumptions
            # FIXME this whole function can be cleaned up!
            widgets.append(urwid.SolidFill())

        if ui.Page in type(ui_container).mro():
            page = uw.PageWidget(widgets, ui_container.title)
        else:
            page = uw.TabablePile(widgets)

        return page
Beispiel #17
0
    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')

        yes = urwid.AttrMap(urwid.Button('Yes', self.handle_input), 'focus',
                            'selectable')
        no = urwid.AttrMap(urwid.Button('No', self.handle_input), 'focus',
                           'selectable')

        buttons = urwid.GridFlow([yes, no], 10, 3, 1, 'center')

        bottom = urwid.Padding(buttons, align='right', width='pack')
        bottom = urwid.AttrMap(urwid.Filler(bottom, valign='bottom'), 'wcolor')

        content = urwid.Pile([top, bottom], 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=60,
                                height=20)
        content_frame.body = content

        self._w = content_frame
Beispiel #18
0
def test_urwid(terminal_colors):
    import urwid

    def exit_on_q(key):
        if key.casefold() == 'q':
            raise urwid.ExitMainLoop()

    palette = [
        ('banner', '', '', '', '#ffa', '#60d'),
        ('streak', '', '', '', 'g50', '#60a'),
        ('inside', '', '', '', 'g38', '#808'),
        ('outside', '', '', '', 'g27', '#a06'),
        ('bg', '', '', '', 'g7', '#d06'),]

    placeholder = urwid.SolidFill()
    loop = urwid.MainLoop(placeholder, palette, unhandled_input=exit_on_q)
    loop.screen.set_terminal_properties(colors=256 if terminal_colors else 16)
    loop.widget = urwid.AttrMap(placeholder, 'bg')
    loop.widget.original_widget = urwid.Filler(urwid.Pile([]))

    div = urwid.Divider()
    outside = urwid.AttrMap(div, 'outside')
    inside = urwid.AttrMap(div, 'inside')
    txt = urwid.Text(('banner', u" KalCI == Here For U "), align='center')
    streak = urwid.AttrMap(txt, 'streak')
    pile = loop.widget.base_widget # .base_widget skips the decorations
    for item in [outside, inside, streak, inside, outside]:
        pile.contents.append((item, pile.options()))

    try:
        loop.run()
    except KeyboardInterrupt:
        pass
Beispiel #19
0
 def _get_arrowhead_aligner(self):
     if self.message.has_replies():
         aligner = u'\u2502'
     else:
         aligner = ' '
     aligner = urwid.SolidFill(aligner)
     return ('fixed', 1, urwid.AttrMap(aligner, self.arrow_bars_att))
Beispiel #20
0
def ssid_widget(ssids):
    main = urwid.Padding(menu(u'Select SSID:', ssids), left=2, right=2)
    top = urwid.Overlay(main, urwid.SolidFill(u'\N{MEDIUM SHADE}'),
                        align='center', width=('relative', 60),
                        valign='middle', height=('relative', 60),
                        min_width=20, min_height=9)
    return top
Beispiel #21
0
    def main_window(self):
        # Initiating the data
        self.graph_cpu = self.bar_graph('util light', 'util dark', 'CPU Utilization Across all workers[%]', [], [0, 50, 100])
        self.graph_mem = self.bar_graph('temp dark', 'temp light', 'Used Memory', [], [0, 25, 50, 75, 100])
        
        self.graph_data.graph_num_bars = self.graph_cpu.bar_graph.get_size()[1]

        self.graph_cpu.bar_graph.set_bar_width(1)
        self.graph_mem.bar_graph.set_bar_width(1)

        vline = urwid.AttrWrap(urwid.SolidFill(u'\u2502'), 'line')

        self.visible_graphs = [self.graph_cpu, self.graph_mem]
        self.show_graphs()

        graph_controls = self.graph_controls()
        overview_stats = self.init_overview_stats()

        text_col = urwid.ListBox(urwid.SimpleListWalker(overview_stats + [urwid.Divider()] + graph_controls ))

        w = urwid.Columns([('weight', 2, self.graph_place_holder),
                           ('fixed',  1, vline),
                           ('fixed',  20, text_col)],
                          dividechars=1, focus_column=2)

        self.main_window_w = w
        return self.main_window_w
Beispiel #22
0
def password_menu():
    global password_widget
    password_prompt = urwid.Text("Password: "******"", align='center', mask='*')
    txt_password = urwid.AttrMap(password_widget, 'prompt')
    btn_ok = urwid.Button('Ok')
    btn_cancel = urwid.Button('Cancel')


    urwid.connect_signal(btn_cancel, 'click', exit_program)
    urwid.connect_signal(btn_ok, 'click', connect_network)


    filler = urwid.Filler(
        urwid.Pile([
            password_prompt,
            txt_password,
            urwid.AttrMap(btn_ok, None, 'reversed'),
            urwid.AttrMap(btn_cancel, None, 'reversed')
        ]))
    padding = urwid.Padding(filler, left=2, right=2)

    ppadding = urwid.AttrMap(padding, 'banner')
    # prompt = urwid.Edit(u"Password", mask=u'*')
    top = urwid.Overlay(ppadding, urwid.SolidFill(u' '),
                        align='center', width=('relative', 60),
                        valign='middle', height=('relative', 60),
                        min_width=20, min_height=9)
    topp = urwid.AttrMap(top, 'bg')
    return topp
Beispiel #23
0
def main():
    global proc
    name = ' '.join(sys.argv[1:])
    if not name:
        print("Usage: killit <search term>")
        sys.exit()

    processes = get_processes_by_name(name)

    for p in processes:
        _proc[p.pid] = p

    lines = [
        '%s: %s' % (pid, ' '.join(p.cmdline())) for (pid, p) in _proc.items()
    ]

    menu = Menu()
    main = urwid.Padding(menu.menu(APP_BANNER, lines), left=2, right=2)
    top = urwid.Overlay(main,
                        urwid.SolidFill(u'\N{MEDIUM SHADE}'),
                        align='center',
                        width=('relative', 80),
                        valign='middle',
                        height=('relative', 80),
                        min_width=20,
                        min_height=9)
    urwid.MainLoop(top,
                   palette=[('reversed', 'standout', '')],
                   unhandled_input=handle_keys).run()
Beispiel #24
0
    def __init__(self, widget):
        hline = urwid.Divider('─')
        self._vline = urwid.AttrMap(urwid.SolidFill('│'), 'frame')
        self._topline = urwid.AttrMap(
            urwid.Columns([
                ('fixed', 1, urwid.Text('┌')),
                hline,
                ('fixed', 1, urwid.Text('┐')),
            ]), 'frame')
        self._bottomline = urwid.AttrMap(
            urwid.Columns([
                ('fixed', 1, urwid.Text('└')),
                hline,
                ('fixed', 1, urwid.Text('┘')),
            ]), 'frame')

        self._middle = urwid.Columns(
            [('fixed', 1, self._vline), widget, ('fixed', 1, self._vline)],
            focus_column=1,
        )
        self._all = urwid.Pile(
            [('flow', self._topline), self._middle,
             ('flow', self._bottomline)],
            focus_item=1,
        )

        urwid.WidgetWrap.__init__(self, self._all)
        urwid.WidgetDecoration.__init__(self, widget)
Beispiel #25
0
    def rebuild(self):
        try:
            self.thread.refresh()
        except NonexistantObjectError:
            self.body = urwid.SolidFill()
            self.message_count = 0
            return

        self._tree = ThreadTree(self.thread)

        # define A to be the tree to be wrapped by a NestedTree and displayed.
        # We wrap the thread tree into an ArrowTree for decoration if
        # indentation was requested and otherwise use it as is.
        if self._indent_width == 0:
            A = self._tree
        else:
            # we want decoration.
            bars_att = settings.get_theming_attribute('thread', 'arrow_bars')
            # only add arrow heads if there is space (indent > 1).
            heads_char = None
            heads_att = None
            if self._indent_width > 1:
                heads_char = u'\u27a4'
                heads_att = settings.get_theming_attribute(
                    'thread', 'arrow_heads')
            A = ArrowTree(self._tree,
                          indent=self._indent_width,
                          childbar_offset=0,
                          arrow_tip_att=heads_att,
                          arrow_tip_char=heads_char,
                          arrow_att=bars_att)

        self._nested_tree = NestedTree(A, interpret_covered=True)
        self.body = TreeBox(self._nested_tree)
        self.message_count = self.thread.get_total_messages()
Beispiel #26
0
    def __init__(self, mainloop: urwid.MainLoop) -> None:
        self._mainloop = mainloop
        self._main_view = urwid.WidgetPlaceholder(urwid.SolidFill(" "))
        self.layout = self._create_layout()
        self._act_stack: List[ActivityContext] = []

        self._mainloop.widget = self.layout
Beispiel #27
0
 def __init__(self, loop):
     base = urwid.SolidFill("")
     self.loop = urwid.MainLoop(
         base,
         event_loop=urwid.AsyncioEventLoop(loop=loop),
         palette=palettes)
     self.base = base
Beispiel #28
0
    def __init__(self, controller, args):

        self.controller = controller
        self.custom_temp = args.custom_temp
        self.custom_fan = args.custom_fan
        self.args = args
        self.hline = urwid.AttrWrap(urwid.SolidFill(u'_'), 'line')
        self.mode_buttons = []
        self.refresh_rate_ctrl = urwid.Edit(('bold text', u'Refresh[s]:'), self.controller.refresh_rate)


        self.visible_graphs = {}
        self.graph_place_holder = urwid.WidgetPlaceholder(urwid.Pile([]))

        self.main_window_w = []

        self.stress_menu = StressMenu(self.on_menu_close)
        self.help_menu = HelpMenu(self.on_menu_close)
        self.about_menu = AboutMenu(self.on_menu_close)
        self.temp_sensors_menu = TempSensorsMenu(self.on_sensors_menu_close)
        self.global_data = GlobalData(is_admin)

        self.stress_menu.sqrt_workers = str(self.global_data.num_cpus)
        self.left_margin = 0
        self.top_margin = 0
        self.v_relative = 50
        self.h_relative = 50

        urwid.WidgetPlaceholder.__init__(self, self.main_window())
        urwid.connect_signal(self.refresh_rate_ctrl, 'change', self.update_refresh_rate)
Beispiel #29
0
    def __init__(self, walker=None):
        def f(char, attr):
            return urwid.AttrMap(urwid.SolidFill(char), attr)

        self.boxes = [
            urwid.AttrMap(urwid.SolidFill("\N{FULL BLOCK}"), 'scrollbar_bg'),
            urwid.AttrMap(urwid.SolidFill("\N{FULL BLOCK}"), 'scrollbar_fg'),
        ]
        self.bar = Pile([
            ('weight', 1, f("\N{BOX DRAWINGS LIGHT VERTICAL}",
                            'scrollbar_bg')),
            ('weight', 1, self.boxes[0]),
            ('weight', 1, f("\N{BOX DRAWINGS LIGHT VERTICAL}",
                            'scrollbar_bg')),
        ])
        super().__init__(walker)
Beispiel #30
0
    def draw_output(self, tag, text, prefix=None):
        time = datetime.now().strftime("%H:%M:%S")
        time = (len(time), urwid.Text("{}".format(time)))

        tag_width = max([len(tag) for tag in TAG_SYMBOLS.values()])
        tag = (tag_width, urwid.Text(TAG_SYMBOLS[tag]))

        if not prefix:
            prefix = urwid.Text("")
        elif isinstance(prefix, User):
            prefix = self.user_list.get_user_text(prefix)
        else:
            prefix = urwid.Text(prefix)
        prefix.set_align_mode("right")
        prefix = (USER_WIDTH, prefix)

        hline = (1, urwid.SolidFill(u'\u2502'))

        text = urwid.Text(text)

        self.output_box.body.append(
            urwid.Columns([time, tag, prefix, hline, text],
                          dividechars=1,
                          box_columns=[3]))

        # Scroll to bottom
        self.output_box.set_focus(len(self.output_box.body) - 1, "above")

        self._refresh()