コード例 #1
0
    def __init__(self):
        self.screen = Screen()
        self.screen.set_input_timeouts(max_wait=0)
        self.steps = GridFlow([], 20, 2, 1, 'left')
        self.progress = SimpleFocusListWalker([])
        self.log = SimpleFocusListWalker([])

        self.widget = AttrMap(
            LineBox(Pile([
                ('fixed', 6, AttrMap(Filler(self.steps), 'default')),
                ('fixed', 1, Filler(Divider('\u2500'))),
                ('fixed', 3, ListBox(self.progress)),
                AttrMap(LineBox(ListBox(self.log), title='Message log'),
                        'default')
            ]),
                    title='Indico 1.2 -> 2.0 migration'), 'global_frame')

        self.screen.register_palette(
            [('green', 'light green', ''), ('white', 'white', ''),
             ('red', 'dark red', ''), ('yellow', 'yellow', ''),
             ('progress_empty', 'black',
              'light gray'), ('progress_progress', 'light cyan', 'light gray'),
             ('progress_done', 'black', 'light cyan'),
             ('box', 'white', 'dark gray'), ('step_done', 'light green', ''),
             ('step_working', 'dark gray',
              ''), ('global_frame', 'light cyan',
                    ''), ('fill', 'light cyan', 'dark cyan'),
             ('done', 'white', 'dark green'), ('eta', 'yellow', 'dark gray')] +
            generate_urwid_palette(PALETTE))
コード例 #2
0
    def create_interface(self):
        self.screen = Screen()
        self.screen.start()

        self.screen.register_palette([
            ("title", "white", "dark blue", "standout"),
            ("line", "light gray", "black"),
            ("help", "white", "dark blue")]
        )

        self.body = ListBox(SimpleListWalker([]))
        self.lines = self.body.body

        self.title = Text(MAIN_TITLE)
        self.header = AttrWrap(self.title, "title")

        self.help = AttrWrap(
            Text(HELP_STRINGS["main"]),
            "help"
        )

        self.input = Edit(caption="%s> " % self.ircchannel)
        self.footer = Pile([self.help, self.input])

        self.top = Frame(self.body, self.header, self.footer)
コード例 #3
0
 def __init__(self, device=None, footer=False, name=None):
     Screen.__init__(self)
     self.device = device
     self.footer_display = footer
     self._define_log()
     self._define_screen()
     self._connect_louie()
     self._start_network()
コード例 #4
0
 def __init__(self, stopperFunction):
     """Constructor"""
     self.running = False
     self.stopperFunction = stopperFunction
     self.id_counter = 0
     # A screen is useful right away
     self.screen = Screen()
     self.screen.register_palette(self.palette)
     self.screen.set_mouse_tracking(True)
コード例 #5
0
 def __init__(self, max_visible=4, min_columns=36):
     self.screen = Screen()
     self.max_visible = max_visible
     self.min_cols = min_columns
     self.contents = []
     self.deleted = []
     self.index = 0
     self.focus = 0
     self.visible = 0
     self.filter = ''
     self.group = ''
コード例 #6
0
ファイル: shell.py プロジェクト: eevee/dywypi
    def __init__(self, reader, writer, encoding='utf8'):
        self.reader = reader
        self.writer = writer
        self.encoding = encoding

        # Allow using the defaults of stdin and stdout, so the screen size and
        # whatnot are still detected correctly
        Screen.__init__(self)

        self.colors = 256
        self.bright_is_bold = False
        self.register_palette_entry(None, 'default', 'default')
コード例 #7
0
ファイル: shell.py プロジェクト: hydrapheetz/dywypi
    def __init__(self, transport):
        self.transport = transport

        Screen.__init__(self)
        self.colors = 256
        self.bright_is_bold = True
        self.register_palette_entry(None, "default", "default")

        # Don't let urwid mess with stdin/stdout directly; give it these dummy
        # objects instead
        self._term_input_file = UrwidDummyInput()
        self._term_output_file = ProtocolFileAdapter(self.transport)
コード例 #8
0
 def __init__(self, device=None, footer=True, loglevel="Info", user_path=".", config_path=None):
     Screen.__init__(self)
     self.device = device
     self.footer_display = footer
     self.loglevel = logging.INFO
     self.loglevel_ow = loglevel
     self.user_path = user_path
     self.config_path = config_path
     self._define_log()
     self._define_screen()
     self._connect_louie()
     self._start_network()
コード例 #9
0
 def __init__(self, terminalProtocol):
     # We will need these later
     self.terminalProtocol = terminalProtocol
     self.terminal = terminalProtocol.terminal
     Screen.__init__(self)
     self.colors = 16
     self._pal_escape = {}
     self.bright_is_bold = True
     self.register_palette_entry(None, 'black', 'white')
     urwid.signals.connect_signal(self, urwid.UPDATE_PALETTE_ENTRY,
                                  self._on_update_palette_entry)
     # Don't need to wait for anything to start
     self._started = True
コード例 #10
0
ファイル: twisted_serve_ssh.py プロジェクト: 0x15/urwid
 def __init__(self, terminalProtocol):
     # We will need these later
     self.terminalProtocol = terminalProtocol
     self.terminal = terminalProtocol.terminal
     Screen.__init__(self)
     self.colors = 16
     self._pal_escape = {}
     self.bright_is_bold = True
     self.register_palette_entry(None, 'black', 'white')
     urwid.signals.connect_signal(self, urwid.UPDATE_PALETTE_ENTRY,
         self._on_update_palette_entry)
     # Don't need to wait for anything to start
     self._started = True
コード例 #11
0
 def __init__(self, interval, hosts=[]):
     self.screen = Screen()
     self.screen.set_terminal_properties(256)
     self.models = [
         GraphModel(hosts),
         NodesModel(hosts),
         JobsModel(hosts),
     ]
     # don't allow refresh intervals < 100ms
     self.refresh_interval = max(0.1, interval)
     self.view = MainWindow(self)
     self.view.update_footer(hosts)
     self.loop = None
     self.exit_message = None
コード例 #12
0
ファイル: circ.py プロジェクト: spaceone/circuits
    def create_interface(self):
        self.screen = Screen()
        self.screen.start()

        self.screen.register_palette([
            ("title", "white", "dark blue", "standout"),
            ("line", "light gray", "black"),
            ("help", "white", "dark blue")]
        )

        self.body = ListBox(SimpleListWalker([]))
        self.lines = self.body.body

        self.title = Text(MAIN_TITLE)
        self.header = AttrWrap(self.title, "title")

        self.help = AttrWrap(
            Text(HELP_STRINGS["main"]),
            "help"
        )

        self.input = Edit(caption="%s> " % self.ircchannel)
        self.footer = Pile([self.help, self.input])

        self.top = Frame(self.body, self.header, self.footer)
コード例 #13
0
    def prepare(self):
        """
        Prepare console screen objects, logger, ask for widgets
        """
        super(ConsoleStatusReporter, self).prepare()
        self.disabled = self.settings.get("disable", False)
        if self.disabled:
            return

        if sys.stdout.isatty() and platform.system() != 'Windows':
            self.screen = Screen()
            self.__detect_console_logger()
        else:
            cols = self.settings.get('dummy-cols', self.screen_size[0])
            rows = self.settings.get('dummy-rows', self.screen_size[1])
            self.screen = DummyScreen(cols, rows)

        widgets = []
        if isinstance(self.engine.provisioning, Local):
            for executor in self.engine.provisioning.executors:
                if isinstance(executor, WidgetProvider):
                    widgets.append(executor.get_widget())
            for reporter in self.engine.reporters:
                if isinstance(reporter, WidgetProvider):
                    widgets.append(reporter.get_widget())

        self.console = TaurusConsole(widgets)
        self.screen.register_palette(self.console.palette)
コード例 #14
0
 def __init__(self,
              device=None,
              footer=True,
              loglevel="Info",
              user_path=".",
              config_path=None):
     Screen.__init__(self)
     self.device = device
     self.footer_display = footer
     self.loglevel = logging.INFO
     self.loglevel_ow = loglevel
     self.user_path = user_path
     self.config_path = config_path
     self._define_log()
     self._define_screen()
     self._connect_louie()
     self._start_network()
コード例 #15
0
ファイル: test_gui.py プロジェクト: edsuom/logalyzer
class Display(object):
    lifetime = 5 # seconds
    
    def __init__(self, palette=None):
        # A screen is useful to have right away
        self.screen = Screen()
        if palette is None:
            palette = gui.GUI.palette
        self.screen.register_palette(palette)

    def setWidget(self, widget, useFiller=False):
        def possiblyQuit(key):
            if key in ('q', 'Q'):
                reactor.stop()

        # The widget under test is outline, possibly padded with filler
        outlined = u.LineBox(widget)
        if useFiller:
            height = 'flow' if hasattr(widget, 'rows') else 3
            w = u.Filler(outlined, valign='top', height=height)
        else:
            w = outlined
        main = u.WidgetWrap(w)
        # The loops
        eventLoop = u.TwistedEventLoop(reactor, manage_reactor=False)
        self.loop = u.MainLoop(
            main, screen=self.screen,
            unhandled_input=possiblyQuit,
            event_loop=eventLoop)
        self.loop.start()

    def width(self):
        return self.screen.get_cols_rows()[0] - 2
        
    def update(self):
        self.loop.draw_screen()

    def stop(self):
        self.screen.unhook_event_loop(self.loop)
        self.loop.stop()
コード例 #16
0
	def main(self):
		self.ui = Screen()
		self.ui.set_input_timeouts( max_wait=INTERVAL_DELAY )
		
		self.ui.register_palette(self.palette)
		self.ui.run_wrapper( self.run )
コード例 #17
0
class CrateStat(object):
    """
    Main entry point of application
    """
    def __init__(self, interval, hosts=[]):
        self.screen = Screen()
        self.screen.set_terminal_properties(256)
        self.models = [
            GraphModel(hosts),
            NodesModel(hosts),
            JobsModel(hosts),
        ]
        # don't allow refresh intervals < 100ms
        self.refresh_interval = max(0.1, interval)
        self.view = MainWindow(self)
        self.view.update_footer(hosts)
        self.loop = None
        self.exit_message = None

    def main(self):
        if not self.fetch_initial():
            return self.quit('Could not connect to {0}'.format(
                self.models[0].hosts))
        self.loop = urwid.MainLoop(self.view,
                                   PALETTE,
                                   screen=self.screen,
                                   unhandled_input=self.handle_input)
        self.loop.set_alarm_in(0.1, self.fetch)
        self.loop.run()

    def __enter__(self):
        return self

    def __exit__(self, ex, msg, trace):
        if self.exit_message:
            print(self.exit_message, file=sys.stderr)
        elif ex:
            for line in traceback.format_tb(trace):
                print(line, file=sys.stderr)

    def quit(self, msg=None):
        self.exit_message = msg
        if self.loop:
            raise urwid.ExitMainLoop()
        return 1

    def handle_input(self, key):
        if key in ('q', 'Q'):
            self.quit()
        elif key == 'f1':
            self.models[2].toggle()
            self.view.set_logging_state(self.models[2].enabled)
        else:
            self.view.handle_input(key)

    def fetch_initial(self):
        try:
            info = self.models[0].refresh()
        except Exception as e:
            return False
        else:
            self.view.update(info=info)
            stats_enabled = self.models[2].get_initial_state()
            self.view.set_logging_state(stats_enabled)
        return True

    def fetch(self, loop, args):
        try:
            # todo: execute HTTP requests asynchronous
            info, nodes, jobs = [m.refresh() for m in self.models]
        except Exception as e:
            self.quit(e)
        else:
            self.view.update(info, nodes, jobs)
        loop.set_alarm_in(self.refresh_interval, self.fetch)
コード例 #18
0
class Client(Component):

    channel = "client"

    def init(self, host, port=6667, opts=None):
        self.host = host
        self.port = port
        self.opts = opts
        self.hostname = gethostname()

        self.nick = opts.nick
        self.ircchannel = opts.channel

        # Add TCPClient and IRC to the system.
        TCPClient(channel=self.channel).register(self)
        IRC(channel=self.channel).register(self)

        self.create_interface()

    def create_interface(self):
        self.screen = Screen()
        self.screen.start()

        self.screen.register_palette([
            ("title", "white", "dark blue", "standout"),
            ("line", "light gray", "black"),
            ("help", "white", "dark blue")]
        )

        self.body = ListBox(SimpleListWalker([]))
        self.lines = self.body.body

        self.title = Text(MAIN_TITLE)
        self.header = AttrWrap(self.title, "title")

        self.help = AttrWrap(
            Text(HELP_STRINGS["main"]),
            "help"
        )

        self.input = Edit(caption="%s> " % self.ircchannel)
        self.footer = Pile([self.help, self.input])

        self.top = Frame(self.body, self.header, self.footer)

    def ready(self, component):
        """Ready Event

        This event is triggered by the underlying ``TCPClient`` Component
        when it is ready to start making a new connection.
        """

        self.fire(connect(self.host, self.port))

    def connected(self, host, port):
        """connected Event

        This event is triggered by the underlying ``TCPClient`` Component
        when a successfully connection has been made.
        """

        nick = self.nick
        hostname = self.hostname
        name = "%s on %s using circuits/%s" % (nick, hostname, systemVersion)

        self.fire(NICK(nick))
        self.fire(USER(nick, hostname, host, name))

    def numeric(self, source, numeric, *args):
        """Numeric Event

        This event is triggered by the ``IRC`` Protocol Component when we have
        received an IRC Numberic Event from server we are connected to.
        """

        if numeric == ERR_NICKNAMEINUSE:
            self.fire(NICK("{0:s}_".format(args[0])))
        elif numeric in (RPL_ENDOFMOTD, ERR_NOMOTD):
            self.fire(JOIN(self.ircchannel))

    @handler("stopped", channel="*")
    def _on_stopped(self, component):
        self.screen.stop()

    @handler("generate_events")
    def _on_generate_events(self, event):
        event.reduce_time_left(0)

        size = self.screen.get_cols_rows()

        if not select(
                self.screen.get_input_descriptors(), [], [], 0.1)[0] == []:
            timeout, keys, raw = self.screen.get_input_nonblocking()

            for k in keys:
                if k == "window resize":
                    size = self.screen.get_cols_rows()
                    continue
                elif k == "enter":
                    self.processCommand(self.input.get_edit_text())
                    self.input.set_edit_text("")
                    continue

                self.top.keypress(size, k)
                self.input.set_edit_text(self.input.get_edit_text() + k)

        self.update_screen(size)

    def unknownCommand(self, command):
        self.lines.append(Text("Unknown command: %s" % command))

    def syntaxError(self, command, args, expected):
        self.lines.append(
            Text("Syntax error ({0:s}): {1:s} Expected: {2:s}".format(
                command, args, expected)
            )
        )

    def processCommand(self, s):  # noqa

        match = CMD_REGEX.match(s)
        if match is not None:

            command = match.groupdict()["command"]
            if not match.groupdict()["args"] == "":
                tokens = match.groupdict()["args"].split(" ")
            else:
                tokens = []

            fn = "cmd" + command.upper()
            if hasattr(self, fn):
                f = getattr(self, fn)
                if callable(f):

                    args, vargs, kwargs, default = getargspec(f)
                    args.remove("self")
                    if len(args) == len(tokens):
                        if len(args) == 0:
                            f()
                        else:
                            f(*tokens)
                    else:
                        if len(tokens) > len(args):
                            if vargs is None:
                                if len(args) > 0:
                                    factor = len(tokens) - len(args) + 1
                                    f(*back_merge(tokens, factor))
                                else:
                                    self.syntaxError(
                                        command, " ".join(tokens),
                                        " ".join(
                                            x for x in args + [vargs]
                                            if x is not None
                                        )
                                    )
                            else:
                                f(*tokens)
                        elif default is not None and \
                                len(args) == (
                                    len(tokens) + len(default)):
                            f(*(tokens + list(default)))
                        else:
                            self.syntaxError(
                                command,
                                " ".join(tokens),
                                " ".join(
                                    x for x in args + [vargs]
                                    if x is not None
                                )
                            )
        else:
            if self.ircchannel is not None:
                self.lines.append(Text("<%s> %s" % (self.nick, s)))
                self.fire(PRIVMSG(self.ircchannel, s))
            else:
                self.lines.append(Text(
                    "No channel joined. Try /join #<channel>"))

    def cmdEXIT(self, message=""):
        self.fire(QUIT(message))
        raise SystemExit(0)

    def cmdSERVER(self, host, port=6667):
        self.fire(connect(host, port))

    def cmdSSLSERVER(self, host, port=6697):
        self.fire(connect(host, port, secure=True))

    def cmdJOIN(self, channel):
        if self.ircchannel is not None:
            self.cmdPART(self.ircchannel, "Joining %s" % channel)
        self.fire(JOIN(channel))
        self.ircchannel = channel

    def cmdPART(self, channel=None, message="Leaving"):
        if channel is None:
            channel = self.ircchannel
        if channel is not None:
            self.fire(PART(channel, message))
            self.ircchannel = None

    def cmdQUOTE(self, message):
        self.fire(request(Message(message)))

    def cmdQUIT(self, message="Bye"):
        self.fire(QUIT(message))

    def update_screen(self, size):
        canvas = self.top.render(size, focus=True)
        self.screen.draw_screen(size, canvas)

    @handler("notice", "privmsg")
    def _on_notice_or_privmsg(self, event, source, target, message):
        nick, ident, host = source

        if event.name == "notice":
            self.lines.append(Text("-%s- %s" % (nick, message)))
        else:
            self.lines.append(Text("<%s> %s" % (nick, message)))
コード例 #19
0
ファイル: test_gui.py プロジェクト: edsuom/logalyzer
 def __init__(self, palette=None):
     # A screen is useful to have right away
     self.screen = Screen()
     if palette is None:
         palette = gui.GUI.palette
     self.screen.register_palette(palette)
コード例 #20
0
class ColumnViewportFocusList():

    signals = ['pack']

    def __init__(self, max_visible=4, min_columns=36):
        self.screen = Screen()
        self.max_visible = max_visible
        self.min_cols = min_columns
        self.contents = []
        self.deleted = []
        self.index = 0
        self.focus = 0
        self.visible = 0
        self.filter = ''
        self.group = ''

    def get_viewport(self):
        self._find_visible()
        tlists = self._filter_contents()

        slice_len = len(tlists[self.index:len(tlists)])
        max_index = (len(tlists) - self.visible)
        if max_index < 0: max_index = 0

        if self.visible > slice_len < len(tlists):
            diff = self.visible - slice_len
            self.focus += diff
            self.index -= diff
        if self.focus > (self.visible - 1):
            diff = self.focus - (self.visible - 1)
            self.focus -= diff
            self.index += diff
        elif self.focus < 0:
            self.index += self.focus
            self.focus = 0

        if self.index > max_index:
            self.index = max_index
        elif self.index < 0:
            self.index = 0

        viewport_list = []
        for i in range(self.visible):
            try:
                viewport_list.append(tlists[self.index + i])
            except IndexError:
                pass
        return viewport_list

    def _filter_contents(self):
        group_contents = []
        for holder in self.contents:
            if self.group in holder.tlist.group:
                group_contents.append(holder)
        filtered_contents = []
        for holder in group_contents:
            if self.filter in holder.tlist.name:
                filtered_contents.append(holder)
        return filtered_contents

    def _find_visible(self):
        screen_dims = self.screen.get_cols_rows()
        cols = screen_dims[0]
        self.visible = int(cols / self.min_cols)
        if self.visible > self.max_visible: self.visible = self.max_visible
        if self.visible > len(self._filter_contents()):
            self.visible = len(self._filter_contents())

    def trans_view(self, translation):
        new_index = self.index + translation
        max_index = (len(self.contents) - self.visible)
        if new_index < 0:
            new_index = 0
        elif new_index > max_index:
            new_index = max_index
        self.index = new_index

    def append(self, tlist):
        holder = TListHolder(tlist)
        urwid.connect_signal(holder, 'delete', self.delete)
        self.contents.append(holder)

    def insert(self, tlist):
        holder = TListHolder(tlist)
        urwid.connect_signal(holder, 'delete', self.delete)
        self.contents.insert((self.index + self.focus), holder)

    def prompt_delete(self, tlist):
        tlist.prompt_delete()

    def delete(self, obj):
        self.contents.remove(obj)
        self.deleted.append(obj.tlist.id)
        urwid.emit_signal(self, 'pack')

    def set_filter(self, new_filter):
        self.index = 0
        self.filter = new_filter

    def set_group(self, new_group):
        self.index = 0
        self.group = new_group
コード例 #21
0
class GUI(object):
    def __init__(self):
        self.screen = Screen()
        self.screen.set_input_timeouts(max_wait=0)
        self.steps = GridFlow([], 20, 2, 1, 'left')
        self.progress = SimpleFocusListWalker([])
        self.log = SimpleFocusListWalker([])

        self.widget = AttrMap(
            LineBox(Pile([
                ('fixed', 6, AttrMap(Filler(self.steps), 'default')),
                ('fixed', 1, Filler(Divider('\u2500'))),
                ('fixed', 3, ListBox(self.progress)),
                AttrMap(LineBox(ListBox(self.log), title='Message log'),
                        'default')
            ]),
                    title='Indico 1.2 -> 2.0 migration'), 'global_frame')

        self.screen.register_palette(
            [('green', 'light green', ''), ('white', 'white', ''),
             ('red', 'dark red', ''), ('yellow', 'yellow', ''),
             ('progress_empty', 'black',
              'light gray'), ('progress_progress', 'light cyan', 'light gray'),
             ('progress_done', 'black', 'light cyan'),
             ('box', 'white', 'dark gray'), ('step_done', 'light green', ''),
             ('step_working', 'dark gray',
              ''), ('global_frame', 'light cyan',
                    ''), ('fill', 'light cyan', 'dark cyan'),
             ('done', 'white', 'dark green'), ('eta', 'yellow', 'dark gray')] +
            generate_urwid_palette(PALETTE))

    def print_log(self, icon, message, prefix='', event_id=''):
        self.log.append(
            Text([
                color_segments(icon), ' ',
                color_segments(prefix), ' ' if prefix else '',
                color_segments(
                    '%[cyan][%[cyan!]{}%[cyan]]%[reset]'.format(event_id))
                if event_id else '', ' ' if event_id else '',
                color_segments(message)
            ]))
        self.log.set_focus(len(self.log) - 1)
        self.redraw()

    def start(self):
        # don't let Python warnings ruin the GUI
        warnings.filterwarnings('ignore')
        self.screen.start()
        self.redraw()

    def stop(self):
        self.screen.stop()
        warnings.filterwarnings('default')

    def create_progress_bar(self, description):
        if self.progress:
            del self.progress[:]
        return StepProgressBar(self, description)

    def set_success(self):
        if self.progress:
            del self.progress[:]
        self.progress.append(
            AttrMap(Text('Migration finished!', align='center'), 'done'))
        self.progress.append(
            AttrMap(Text('Please press any key...', align='center'), 'done'))
        self.redraw()
        self.wait_for_input()

    def wait_for_input(self):
        self.screen._getch(None)

    def set_step_banner(self, msg):
        if self.progress:
            del self.progress[:]
        self.progress.append(BoxAdapter(AttrMap(SolidFill('#'), 'fill'), 3))

    def redraw(self):
        screen_size = self.screen.get_cols_rows()
        canvas = self.widget.render(screen_size, focus=True)
        self.screen.get_input()
        self.screen.draw_screen(screen_size, canvas)
コード例 #22
0
ファイル: asyncio_socket_server.py プロジェクト: SeesawLiu/py
    def __init__(self, reader, writer, encoding="utf-8"):
        self.reader = reader
        self.writer = writer
        self.encoding = encoding

        Screen.__init__(self, None, None)
コード例 #23
0
class GUI(object):
    """
    I am the main curses interface.
    """
    title = "Logalyzer"
    
    palette = [
        # Name
        # 'fg color,setting', 'background color', 'mono setting'
        ('heading',
         'dark cyan', 'default', 'default'),
        ('heading_current',
         'light cyan,underline', 'default', 'underline'),
        ('message',
         'white', 'default', 'default'),
        ('error_label',
         'light red,underline', 'default', 'underline'),
        ('error',
         'brown', 'default', 'default'),
        ('warning_label',
         'yellow,underline', 'default', 'underline'),
        ('warning',
         'brown', 'default', 'default'),
    ]
    
    def __init__(self, stopperFunction):
        """Constructor"""
        self.running = False
        self.stopperFunction = stopperFunction
        self.id_counter = 0
        # A screen is useful right away
        self.screen = Screen()
        self.screen.register_palette(self.palette)
        self.screen.set_mouse_tracking(True)

    def start(self, fileNames):
        """
        Constructs my widgets and starts my event loop and main loop.
        """
        def possiblyQuit(key):
            if key in ('q', 'Q'):
                if not hasattr(self, '_stopping'):
                    self._stopping = None
                    self.warning("Shutting down, please wait...")
                    if reactor.running:
                        # I trust the stopper function to call my stop
                        # method at the appropriate time
                        reactor.callFromThread(reactor.stop)
                
        # The top-level widgets
        self.m = Messages()
        self.f = Files(fileNames, self._dims()[0])
        p = u.Pile([u.Divider("=", 1, 1), self.f, u.Divider(" ")])
        main = u.WidgetWrap(
            u.LineBox(
                u.Padding(
                    u.Frame(self.m, footer=p),
                    left=1, right=1),
                title=self.title))
        eventLoop = u.TwistedEventLoop(reactor, manage_reactor=False)
        self.formerDims = self._dims()
        self.loop = u.MainLoop(
            main, screen=self.screen,
            unhandled_input=possiblyQuit, event_loop=eventLoop)
        reactor.addSystemEventTrigger('after', 'shutdown', self.stop)
        #sys.stdout = StdSubstitute('STDOUT', self)
        sys.stderr = observer = StdSubstitute('STDERR', self)
        twisted.python.log.addObserver(observer)
        self.running = True
        self.loop.start()
    
    def _dims(self):
        # Deduct 4 from each dimension due to outline and padding
        return [x-4 for x in self.screen.get_cols_rows()]

    def update(self):
        """
        Updates my display, possibly with an updated screen width.
        """
        if not self.running:
            return
        width, height = self._dims()
        # Update for new width
        if width != self.formerDims[0]:
            self.f.updateWidth(width)
        self.loop.draw_screen()

    def stop(self):
        """
        Tears down the GUI display. This will be called by
        L{main.Recorder.shutdown} after all other shutdown steps are
        done, as part of the Twisted reactor shutdown.
        """
        if self.running and not hasattr(self, '_shutdownFlag'):
            self._shutdownFlag = None
            self.running = False
            self.screen.unhook_event_loop(self.loop)
            self.loop.stop()
    
    def msgHeading(self, textProto, *args):
        """
        Sends a new heading to my scrolling message window. You can supply
        a single string, or a string prototype followed by one or more
        formatting arguments.

        Returns a unique integer ID for this heading. Use that when
        supplying lines of message body under this heading.
        """
        self.id_counter += 1
        ID = self.id_counter
        self.m.heading(textProto.format(*args), ID)
        self.update()
        return ID

    def msgBody(self, ID, textProto, *args):
        """
        Adds a new line of message body under heading ID. You can supply a
        single string after the integer ID, or a string prototype
        followed by one or more formatting arguments.
        """
        text = textProto.format(*args)
        self.m.msg(text, ID)
        self.update()

    def msgOrphan(self, textProto, *args):
        """
        Adds a new line of message body under a (possibly blank) orphan
        heading ID. You can supply a single string, or a string
        prototype followed by one or more formatting arguments.
        """
        text = textProto.format(*args)
        self.m.msg(text)
        self.update()

    def warning(self, textProto, *args):
        """
        Adds a distinctive warning message to the message window.
        """
        self.m.distinctMsg('warning', textProto.format(*args))
        self.update()
        
    def error(self, textProto, *args):
        """
        Adds a distinctive error message to the message window.
        """
        self.m.distinctMsg('error', textProto.format(*args))
        self.update()

    def msgProgress(self, ID, N):
        self.m.progress(ID, N)
        self.update()
        
    def fileStatus(self, fileName, *args):
        """
        Updates the status entry for the specified fileName. With no
        further arguments, the progress indicator for the file is
        given a spin. With a string or string prototype followed by
        formatting arguments, the progress indicator is reset and the
        brief status text following the filename is updated.
        """
        if args:
            self.f.setStatus(fileName, *args)
        else:
            self.f.indicator(fileName)
        self.update()
コード例 #24
0
ファイル: asyncio_socket_server.py プロジェクト: andy-z/urwid
    def __init__(self, reader, writer):
        self.reader = reader
        self.writer = writer

        Screen.__init__(self, None, None)
コード例 #25
0
ファイル: circ.py プロジェクト: spaceone/circuits
class Client(Component):

    channel = "client"

    def init(self, host, port=6667, opts=None):
        self.host = host
        self.port = port
        self.opts = opts
        self.hostname = gethostname()

        self.nick = opts.nick
        self.ircchannel = opts.channel

        # Add TCPClient and IRC to the system.
        TCPClient(channel=self.channel).register(self)
        IRC(channel=self.channel).register(self)

        self.create_interface()

    def create_interface(self):
        self.screen = Screen()
        self.screen.start()

        self.screen.register_palette([
            ("title", "white", "dark blue", "standout"),
            ("line", "light gray", "black"),
            ("help", "white", "dark blue")]
        )

        self.body = ListBox(SimpleListWalker([]))
        self.lines = self.body.body

        self.title = Text(MAIN_TITLE)
        self.header = AttrWrap(self.title, "title")

        self.help = AttrWrap(
            Text(HELP_STRINGS["main"]),
            "help"
        )

        self.input = Edit(caption="%s> " % self.ircchannel)
        self.footer = Pile([self.help, self.input])

        self.top = Frame(self.body, self.header, self.footer)

    def ready(self, component):
        """Ready Event

        This event is triggered by the underlying ``TCPClient`` Component
        when it is ready to start making a new connection.
        """

        self.fire(connect(self.host, self.port))

    def connected(self, host, port):
        """connected Event

        This event is triggered by the underlying ``TCPClient`` Component
        when a successfully connection has been made.
        """

        nick = self.nick
        hostname = self.hostname
        name = "%s on %s using circuits/%s" % (nick, hostname, systemVersion)

        self.fire(NICK(nick))
        self.fire(USER(nick, hostname, host, name))

    def numeric(self, source, numeric, *args):
        """Numeric Event

        This event is triggered by the ``IRC`` Protocol Component when we have
        received an IRC Numberic Event from server we are connected to.
        """

        if numeric == ERR_NICKNAMEINUSE:
            self.fire(NICK("{0:s}_".format(args[0])))
        elif numeric in (RPL_ENDOFMOTD, ERR_NOMOTD):
            self.fire(JOIN(self.ircchannel))

    @handler("stopped", channel="*")
    def _on_stopped(self, component):
        self.screen.stop()

    @handler("generate_events")
    def _on_generate_events(self, event):
        event.reduce_time_left(0)

        size = self.screen.get_cols_rows()

        if not select(
                self.screen.get_input_descriptors(), [], [], 0.1)[0] == []:
            timeout, keys, raw = self.screen.get_input_nonblocking()

            for k in keys:
                if k == "window resize":
                    size = self.screen.get_cols_rows()
                    continue
                elif k == "enter":
                    self.processCommand(self.input.get_edit_text())
                    self.input.set_edit_text("")
                    continue

                self.top.keypress(size, k)
                self.input.set_edit_text(self.input.get_edit_text() + k)

        self.update_screen(size)

    def unknownCommand(self, command):
        self.lines.append(Text("Unknown command: %s" % command))

    def syntaxError(self, command, args, expected):
        self.lines.append(
            Text("Syntax error ({0:s}): {1:s} Expected: {2:s}".format(
                command, args, expected)
            )
        )

    def processCommand(self, s):  # noqa

        match = CMD_REGEX.match(s)
        if match is not None:

            command = match.groupdict()["command"]
            if not match.groupdict()["args"] == "":
                tokens = match.groupdict()["args"].split(" ")
            else:
                tokens = []

            fn = "cmd" + command.upper()
            if hasattr(self, fn):
                f = getattr(self, fn)
                if callable(f):

                    args, vargs, kwargs, default = getargspec(f)
                    args.remove("self")
                    if len(args) == len(tokens):
                        if len(args) == 0:
                            f()
                        else:
                            f(*tokens)
                    else:
                        if len(tokens) > len(args):
                            if vargs is None:
                                if len(args) > 0:
                                    factor = len(tokens) - len(args) + 1
                                    f(*back_merge(tokens, factor))
                                else:
                                    self.syntaxError(
                                        command, " ".join(tokens),
                                        " ".join(
                                            x for x in args + [vargs]
                                            if x is not None
                                        )
                                    )
                            else:
                                f(*tokens)
                        elif default is not None and \
                                len(args) == (
                                    len(tokens) + len(default)):
                            f(*(tokens + list(default)))
                        else:
                            self.syntaxError(
                                command,
                                " ".join(tokens),
                                " ".join(
                                    x for x in args + [vargs]
                                    if x is not None
                                )
                            )
        else:
            if self.ircchannel is not None:
                self.lines.append(Text("<%s> %s" % (self.nick, s)))
                self.fire(PRIVMSG(self.ircchannel, s))
            else:
                self.lines.append(Text(
                    "No channel joined. Try /join #<channel>"))

    def cmdEXIT(self, message=""):
        self.fire(QUIT(message))
        raise SystemExit(0)

    def cmdSERVER(self, host, port=6667):
        self.fire(connect(host, port))

    def cmdSSLSERVER(self, host, port=6697):
        self.fire(connect(host, port, secure=True))

    def cmdJOIN(self, channel):
        if self.ircchannel is not None:
            self.cmdPART(self.ircchannel, "Joining %s" % channel)
        self.fire(JOIN(channel))
        self.ircchannel = channel

    def cmdPART(self, channel=None, message="Leaving"):
        if channel is None:
            channel = self.ircchannel
        if channel is not None:
            self.fire(PART(channel, message))
            self.ircchannel = None

    def cmdQUOTE(self, message):
        self.fire(request(Message(message)))

    def cmdQUIT(self, message="Bye"):
        self.fire(QUIT(message))

    def update_screen(self, size):
        canvas = self.top.render(size, focus=True)
        self.screen.draw_screen(size, canvas)

    @handler("notice", "privmsg")
    def _on_notice_or_privmsg(self, event, source, target, message):
        nick, ident, host = source

        if event.name == "notice":
            self.lines.append(Text("-%s- %s" % (nick, message)))
        else:
            self.lines.append(Text("<%s> %s" % (nick, message)))
コード例 #26
0
    def __init__(self, reader, writer):
        self.reader = reader
        self.writer = writer

        Screen.__init__(self, None, None)
コード例 #27
0
class MultiGraphDisplay:
	def __init__(self, cols, urwid_ui):
		if urwid_ui == "smoothed":
			smoothed = True
			self.palette = self.smoothed_palette
		else:
			smoothed = False
			self.palette = self.blocky_palette
		self.displays = []
		l = []
		for c in cols:
			a = []
			for tap in c:
				if tap.ftype == 'file_exp':
					d = GraphDisplayProgress(tap, smoothed)
				else:
					d = GraphDisplay(tap, smoothed)
				a.append(d)
				self.displays.append(d)
			l.append(a)
			
		graphs = urwid.Columns( [BoxPile(a) for a in l], 1 )
		graphs = urwid.AttrWrap( graphs, 'background' )
		title = urwid.Text("Speedometer "+__version__)
		title = urwid.AttrWrap( urwid.Filler( title ), 'title' )
		self.top = urwid.Overlay( title, graphs,
			('fixed left', 0), 16, ('fixed top', 0), 1 )

		self.urwid_ui = urwid_ui

	blocky_palette = [
		('background', 'dark gray', 'black'),
		('reading', 'light gray', 'black'),
		('1MB/s',   'dark cyan','light gray','standout'),
		('32KB/s',  'light gray', 'dark cyan','standout'),
		('1KB/s',   'dark blue','dark cyan','standout'),
		('32B/s',   'light cyan','dark blue','standout'),
		('bar:num', 'light gray', 'black' ),
		('ca:background', 'light gray','black'),
		('ca:c',    'yellow','black','standout'),
		('ca:a',    'dark gray','black','standout'),
		('ca:c:num','yellow','black','standout'),
		('ca:a:num','dark gray','black','standout'),
		('title',   'white', 'black','underline'),
		('pr:n',    'white', 'dark blue'),
		('pr:c',    'white', 'dark green','standout'),]
	
	smoothed_palette = [
		('background', 'dark gray', 'black'),
		('reading', 'light gray', 'black'),
		('bar:top', 'dark cyan', 'black' ),
		('bar',     'black', 'dark cyan','standout'),
		('bar:num', 'dark cyan', 'black' ),
		('ca:background', 'light gray','black'),
		('ca:c:top','dark blue','black'),
		('ca:c',    'black','dark blue','standout'),
		('ca:c:num','light blue','black'),
		('ca:a:top','light gray','black'),
		('ca:a',    'black','light gray','standout'),
		('ca:a:num','light gray', 'black'),
		('title',   'white', 'black','underline'),
		('pr:n',    'white', 'dark blue'),
		('pr:c',    'white', 'dark green','standout'),
		('pr:cn',   'dark green', 'dark blue'),
		]
		
		
	def main(self):
		self.ui = Screen()
		self.ui.set_input_timeouts( max_wait=INTERVAL_DELAY )
		
		self.ui.register_palette(self.palette)
		self.ui.run_wrapper( self.run )
	
	def run(self):
		try:
			self.update_readings()
		except EndOfData:
			return
		time.sleep(INITIAL_DELAY)
		resizing = False
		
		size = self.ui.get_cols_rows()
		while True:
			if not resizing:
				try:
					self.update_readings()
				except EndOfData:
					self.end_of_data()
					return
			resizing = False
			
			self.draw_screen(size)

			if isinstance(time,SimulatedTime):
				time.sleep( INTERVAL_DELAY )
				continue
				
			keys = self.ui.get_input()
			for k in keys:
				if k == "window resize":
					size = self.ui.get_cols_rows()
					resizing = True
				else:
					return
	
	def update_readings(self):
		for d in self.displays:
			d.update_readings()
	
	def end_of_data(self):
		# pause for taking screenshot of simulated data
		if isinstance(time, SimulatedTime):
			while not self.ui.get_input():
				pass

	def draw_screen(self, size):
		canvas = self.top.render( size, focus=True )
		self.ui.draw_screen( size, canvas )
コード例 #28
0
ファイル: screen.py プロジェクト: bellyfat/pySSHChat
    def __init__(self, transport):
        self.transport = transport
        self.reader = transport.stdin
        self.writer = transport.stdout

        Screen.__init__(self)