Пример #1
0
    def _stop(self):
        """
        Restore the screen.
        """
        self.clear()

        signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)

        self.signal_restore()

        fd = self._term_input_file.fileno()
        if os.isatty(fd):
            termios.tcsetattr(fd, termios.TCSADRAIN,
        self._old_termios_settings)

        self._mouse_tracking(False)

        move_cursor = ""
        if self._alternate_buffer:
            move_cursor = escape.RESTORE_NORMAL_BUFFER
        elif self.maxrow is not None:
            move_cursor = escape.set_cursor_position(
                0, self.maxrow)
        self.write(
            self._attrspec_to_escape(AttrSpec('',''))
            + escape.SI
            + move_cursor
            + escape.SHOW_CURSOR)

        if self._old_signal_keys:
            self.tty_signal_keys(*(self._old_signal_keys + (fd,)))

        super(Screen, self)._stop()
Пример #2
0
    def _encode_gpm_event( self ):
        self.gpm_event_pending = False
        s = self.gpm_mev.stdout.readline().decode('ascii')
        l = s.split(",")
        if len(l) != 6:
            # unexpected output, stop tracking
            self._stop_gpm_tracking()
            signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)
            return []
        ev, x, y, ign, b, m = s.split(",")
        ev = int( ev.split("x")[-1], 16)
        x = int( x.split(" ")[-1] )
        y = int( y.lstrip().split(" ")[0] )
        b = int( b.split(" ")[-1] )
        m = int( m.split("x")[-1].rstrip(), 16 )

        # convert to xterm-like escape sequence

        last = next = self.last_bstate
        l = []
        
        mod = 0
        if m & 1:    mod |= 4 # shift
        if m & 10:    mod |= 8 # alt
        if m & 4:    mod |= 16 # ctrl

        def append_button( b ):
            b |= mod
            l.extend([ 27, ord('['), ord('M'), b+32, x+32, y+32 ])

        if ev == 20: # press
            if b & 4 and last & 1 == 0:
                append_button( 0 )
                next |= 1
            if b & 2 and last & 2 == 0:
                append_button( 1 )
                next |= 2
            if b & 1 and last & 4 == 0:
                append_button( 2 )
                next |= 4
        elif ev == 146: # drag
            if b & 4:
                append_button( 0 + escape.MOUSE_DRAG_FLAG )
            elif b & 2:
                append_button( 1 + escape.MOUSE_DRAG_FLAG )
            elif b & 1:
                append_button( 2 + escape.MOUSE_DRAG_FLAG )
        else: # release
            if b & 4 and last & 1:
                append_button( 0 + escape.MOUSE_RELEASE_FLAG )
                next &= ~ 1
            if b & 2 and last & 2:
                append_button( 1 + escape.MOUSE_RELEASE_FLAG )
                next &= ~ 2
            if b & 1 and last & 4:
                append_button( 2 + escape.MOUSE_RELEASE_FLAG )
                next &= ~ 4
            
        self.last_bstate = next
        return l
Пример #3
0
    def start(self, alternate_buffer=True):
        """
        Initialize the screen and input mode.

        alternate_buffer -- use alternate screen buffer
        """
        assert not self._started
        if alternate_buffer:
            self._term_output_file.write(escape.SWITCH_TO_ALTERNATE_BUFFER)
            self._rows_used = None
        else:
            self._rows_used = 0

        fd = self._term_input_file.fileno()
        if os.isatty(fd):
            self._old_termios_settings = termios.tcgetattr(fd)
            tty.setcbreak(fd)

        self.signal_init()
        self._alternate_buffer = alternate_buffer
        self._input_iter = self._run_input_iter()
        self._next_timeout = self.max_wait

        if not self._signal_keys_set:
            self._old_signal_keys = self.tty_signal_keys(fileno=fd)

        super(Screen, self).start()

        signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)
        # restore mouse tracking to previous state
        self._mouse_tracking(self._mouse_tracking_enabled)
Пример #4
0
    def _encode_gpm_event(self):
        self.gpm_event_pending = False
        s = self.gpm_mev.stdout.readline()
        l = s.split(",")
        if len(l) != 6:
            # unexpected output, stop tracking
            self._stop_gpm_tracking()
            signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)
            return []
        ev, x, y, ign, b, m = s.split(",")
        ev = int(ev.split("x")[-1], 16)
        x = int(x.split(" ")[-1])
        y = int(y.lstrip().split(" ")[0])
        b = int(b.split(" ")[-1])
        m = int(m.split("x")[-1].rstrip(), 16)

        # convert to xterm-like escape sequence

        last = next = self.last_bstate
        l = []

        mod = 0
        if m & 1: mod |= 4  # shift
        if m & 10: mod |= 8  # alt
        if m & 4: mod |= 16  # ctrl

        def append_button(b):
            b |= mod
            l.extend([27, ord('['), ord('M'), b + 32, x + 32, y + 32])

        if ev == 20:  # press
            if b & 4 and last & 1 == 0:
                append_button(0)
                next |= 1
            if b & 2 and last & 2 == 0:
                append_button(1)
                next |= 2
            if b & 1 and last & 4 == 0:
                append_button(2)
                next |= 4
        elif ev == 146:  # drag
            if b & 4:
                append_button(0 + escape.MOUSE_DRAG_FLAG)
            elif b & 2:
                append_button(1 + escape.MOUSE_DRAG_FLAG)
            elif b & 1:
                append_button(2 + escape.MOUSE_DRAG_FLAG)
        else:  # release
            if b & 4 and last & 1:
                append_button(0 + escape.MOUSE_RELEASE_FLAG)
                next &= ~1
            if b & 2 and last & 2:
                append_button(1 + escape.MOUSE_RELEASE_FLAG)
                next &= ~2
            if b & 1 and last & 4:
                append_button(2 + escape.MOUSE_RELEASE_FLAG)
                next &= ~4

        self.last_bstate = next
        return l
Пример #5
0
    def start(self, alternate_buffer=True):
        """
        Initialize the screen and input mode.

        alternate_buffer -- use alternate screen buffer
        """
        assert not self._started
        if alternate_buffer:
            self._term_output_file.write(escape.SWITCH_TO_ALTERNATE_BUFFER)
            self._rows_used = None
        else:
            self._rows_used = 0

        fd = self._term_input_file.fileno()
        if os.isatty(fd):
            self._old_termios_settings = termios.tcgetattr(fd)
            tty.setcbreak(fd)

        self.signal_init()
        self._alternate_buffer = alternate_buffer
        self._input_iter = self._run_input_iter()
        self._next_timeout = self.max_wait

        if not self._signal_keys_set:
            self._old_signal_keys = self.tty_signal_keys(fileno=fd)

        super(Screen, self).start()

        signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)
        # restore mouse tracking to previous state
        self._mouse_tracking(self._mouse_tracking_enabled)
Пример #6
0
    def stop(self):
        """
        Restore the screen.
        """
        self.clear()
        if not self._started:
            return

        signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)

        self.signal_restore()

        fd = self._term_input_file.fileno()
        if os.isatty(fd):
            termios.tcsetattr(fd, termios.TCSADRAIN,
                              self._old_termios_settings)

        self._mouse_tracking(False)

        move_cursor = ""
        if self._alternate_buffer:
            move_cursor = escape.RESTORE_NORMAL_BUFFER
        elif self.maxrow is not None:
            move_cursor = escape.set_cursor_position(0, self.maxrow)
        self._term_output_file.write(
            self._attrspec_to_escape(AttrSpec('', '')) + escape.SI +
            move_cursor + escape.SHOW_CURSOR)
        self._input_iter = self._fake_input_iter()

        if self._old_signal_keys:
            self.tty_signal_keys(*(self._old_signal_keys + (fd, )))

        super(Screen, self).stop()
Пример #7
0
 def set_position_collapsed(self, pos, is_collapsed):
     if self._initially_collapsed(pos) == is_collapsed:
         if pos in self._divergent_positions:
             self._divergent_positions.remove(pos)
             signals.emit_signal(self, "modified")
     else:
         if pos not in self._divergent_positions:
             self._divergent_positions.append(pos)
             signals.emit_signal(self, "modified")
Пример #8
0
 def set_position_collapsed(self, pos, is_collapsed):
     if self._initially_collapsed(pos) == is_collapsed:
         if pos in self._divergent_positions:
             self._divergent_positions.remove(pos)
             signals.emit_signal(self, "modified")
     else:
         if pos not in self._divergent_positions:
             self._divergent_positions.append(pos)
             signals.emit_signal(self, "modified")
Пример #9
0
    def _start(self, alternate_buffer=True):
        """
        Initialize the screen and input mode.

        alternate_buffer -- use alternate screen buffer
        """
        if alternate_buffer:
            self.write(escape.SWITCH_TO_ALTERNATE_BUFFER)
            self._rows_used = None
        else:
            self._rows_used = 0

        fd = self._input_fileno()
        if fd is not None and os.isatty(fd) and not IS_WINDOWS:
            self._old_termios_settings = termios.tcgetattr(fd)
            tty.setcbreak(fd)

        if IS_WINDOWS:
            hOut = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE)
            hIn = win32.GetStdHandle(win32.STD_INPUT_HANDLE)
            self._dwOriginalOutMode = win32.DWORD()
            self._dwOriginalInMode = win32.DWORD()
            win32.GetConsoleMode(hOut, byref(self._dwOriginalOutMode))
            win32.GetConsoleMode(hIn, byref(self._dwOriginalInMode))
            # TODO: Restore on exit

            dwOutMode = win32.DWORD(self._dwOriginalOutMode.value
                                    | win32.ENABLE_VIRTUAL_TERMINAL_PROCESSING
                                    | win32.DISABLE_NEWLINE_AUTO_RETURN)
            dwInMode = win32.DWORD(self._dwOriginalInMode.value
                                   | win32.ENABLE_WINDOW_INPUT
                                   | win32.ENABLE_VIRTUAL_TERMINAL_INPUT)

            ok = win32.SetConsoleMode(hOut, dwOutMode)
            if not ok:
                raise RuntimeError(
                    "Error enabling virtual terminal processing, "
                    "mitmproxy's console interface requires Windows 10 Build 10586 or above."
                )
            ok = win32.SetConsoleMode(hIn, dwInMode)
            assert ok
        else:
            self.signal_init()
        self._alternate_buffer = alternate_buffer
        self._next_timeout = self.max_wait

        if not self._signal_keys_set and not IS_WINDOWS:
            self._old_signal_keys = self.tty_signal_keys(fileno=fd)

        signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)
        # restore mouse tracking to previous state
        self._mouse_tracking(self._mouse_tracking_enabled)

        return super(Screen, self)._start()
Пример #10
0
 def _reset_palette(self, palette: Dict[str, Tuple]):
     # Reset the palette for activity. We use a bit of urwid implementation
     # details here, because of lack of public way to do this.
     self._mainloop.screen._palette = palette.copy()
     for name, entry in palette.items():
         (basic, mono, high_88, high_true) = entry
         signals.emit_signal(
             self._mainloop.screen,
             urwid.UPDATE_PALETTE_ENTRY,
             name,
             basic,
             mono,
             high_88,
             high_true,
         )
     self._mainloop.screen.clear()
Пример #11
0
    def _stop(self):
        """
        Restore the screen.
        """
        self.clear()

        signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)

        if not IS_WINDOWS:
            self.signal_restore()

        fd = self._input_fileno()
        if fd is not None and os.isatty(fd) and not IS_WINDOWS:
            termios.tcsetattr(fd, termios.TCSADRAIN, self._old_termios_settings)

        self._mouse_tracking(False)

        move_cursor = ""
        if self._alternate_buffer:
            move_cursor = escape.RESTORE_NORMAL_BUFFER
        elif self.maxrow is not None:
            move_cursor = escape.set_cursor_position(
                0, self.maxrow)
        self.write(
            self._attrspec_to_escape(AttrSpec('',''))
            + escape.SI
            + move_cursor
            + escape.SHOW_CURSOR)
        self.flush()

        if self._old_signal_keys:
            self.tty_signal_keys(*(self._old_signal_keys + (fd,)))

        if IS_WINDOWS:
            hOut = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE)
            hIn = win32.GetStdHandle(win32.STD_INPUT_HANDLE)
            ok = win32.SetConsoleMode(hOut, self._dwOriginalOutMode)
            assert ok
            ok = win32.SetConsoleMode(hIn, self._dwOriginalInMode)
            assert ok

        super(Screen, self)._stop()
Пример #12
0
 def __init__(self, df, col_widths):
     self._size = None
     self._focused_col = None
     self._walker = DataFrameWalker(df=df, col_widths=col_widths)
     signals.connect_signal(
         self._walker,
         'modified',
         lambda: signals.emit_signal(self, 'focused_row_changed', self.
                                     focus_position),
     )
     super().__init__(self._walker)
Пример #13
0
    def stop(self):
        """
        Restore the screen.
        """
        self.clear()
        if not self._started:
            return

        signals.emit_signal(self, INPUT_DESCRIPTORS_CHANGED)

        self.signal_restore()

        fd = self._term_input_file.fileno()
        if os.isatty(fd):
            termios.tcsetattr(fd, termios.TCSADRAIN,
        self._old_termios_settings)

        move_cursor = ""
        if self.gpm_mev:
            self._stop_gpm_tracking()
        if self._alternate_buffer:
            move_cursor = escape.RESTORE_NORMAL_BUFFER
        elif self.maxrow is not None:
            move_cursor = escape.set_cursor_position( 
                0, self.maxrow)
        self._term_output_file.write(self._attrspec_to_escape(AttrSpec('','')) 
            + escape.SI
            + escape.MOUSE_TRACKING_OFF
            + escape.SHOW_CURSOR
            + move_cursor + "\n" + escape.SHOW_CURSOR )
        self._input_iter = self._fake_input_iter()

        if self._old_signal_keys:
            self.tty_signal_keys(*(self._old_signal_keys + (fd,)))

        super(Screen, self).stop()
Пример #14
0
 def set_collapsed_all(self, is_collapsed):
     self._initially_collapsed = lambda x: is_collapsed
     self._divergent_positions = []
     newfocus = self._walker.first_ancestor(self._focus)
     self.set_focus(newfocus)
     signals.emit_signal(self, "modified")
Пример #15
0
    def register_palette_entry(self, name, foreground, background,
        mono=None, foreground_high=None, background_high=None):
        """Register a single palette entry.

        name -- new entry/attribute name

        foreground -- a string containing a comma-separated foreground
        color and settings

            Color values:
            'default' (use the terminal's default foreground),
            'black', 'dark red', 'dark green', 'brown', 'dark blue',
            'dark magenta', 'dark cyan', 'light gray', 'dark gray',
            'light red', 'light green', 'yellow', 'light blue',
            'light magenta', 'light cyan', 'white'

            Settings:
            'bold', 'underline', 'blink', 'standout'

            Some terminals use 'bold' for bright colors.  Most terminals
            ignore the 'blink' setting.  If the color is not given then
            'default' will be assumed.

        background -- a string containing the background color

            Background color values:
            'default' (use the terminal's default background),
            'black', 'dark red', 'dark green', 'brown', 'dark blue',
            'dark magenta', 'dark cyan', 'light gray'

        mono -- a comma-separated string containing monochrome terminal
        settings (see "Settings" above.)

            None = no terminal settings (same as 'default')

        foreground_high -- a string containing a comma-separated
        foreground color and settings, standard foreground
        colors (see "Color values" above) or high-colors may
        be used

            High-color example values:
            '#009' (0% red, 0% green, 60% red, like HTML colors)
            '#fcc' (100% red, 80% green, 80% blue)
            'g40' (40% gray, decimal), 'g#cc' (80% gray, hex),
            '#000', 'g0', 'g#00' (black),
            '#fff', 'g100', 'g#ff' (white)
            'h8' (color number 8), 'h255' (color number 255)

            None = use foreground parameter value

        background_high -- a string containing the background color,
        standard background colors (see "Background colors" above)
        or high-colors (see "High-color example values" above)
        may be used

            None = use background parameter value
        """
        basic = AttrSpec(foreground, background, 16)

        if type(mono) == tuple:
            # old style of specifying mono attributes was to put them
            # in a tuple.  convert to comma-separated string
            mono = ",".join(mono)
        if mono is None:
            mono = DEFAULT
        mono = AttrSpec(mono, DEFAULT, 1)

        if foreground_high is None:
            foreground_high = foreground
        if background_high is None:
            background_high = background
        high_256 = AttrSpec(foreground_high, background_high, 256)

        # 'hX' where X > 15 are different in 88/256 color, use
        # basic colors for 88-color mode if high colors are specified
        # in this way (also avoids crash when X > 87)
        def large_h(desc):
            if not desc.startswith('h'):
                return False
            if ',' in desc:
            	desc = desc.split(',',1)[0]
            num = int(desc[1:], 10)
            return num > 15
        if large_h(foreground_high) or large_h(background_high):
            high_88 = basic
        else:
            high_88 = AttrSpec(foreground_high, background_high, 88)

        signals.emit_signal(self, UPDATE_PALETTE_ENTRY,
            name, basic, mono, high_88, high_256)
        self._palette[name] = (basic, mono, high_88, high_256)
Пример #16
0
 def set_focused_col(self, focused_col):
     if focused_col != self._focused_col:
         self._focused_col = focused_col
         self.body.set_focused_col(focused_col=focused_col)
         signals.emit_signal(self, 'focused_col_changed', focused_col)
Пример #17
0
 def _modified(self):
     signals.emit_signal(self, "modified")
Пример #18
0
 def _emit(self, event, state):
     signals.emit_signal(self, event, Event(type=event, target=self, data={'state': state}))
Пример #19
0
 def _emit(self, name, *args):
     """
     Convenience function to emit signals with self as first
     argument.
     """
     signals.emit_signal(self, name, self, *args)
Пример #20
0
    def register_palette_entry(self,
                               name,
                               foreground,
                               background,
                               mono=None,
                               foreground_high=None,
                               background_high=None):
        """Register a single palette entry.

        name -- new entry/attribute name

        foreground -- a string containing a comma-separated foreground
        color and settings

            Color values:
            'default' (use the terminal's default foreground),
            'black', 'dark red', 'dark green', 'brown', 'dark blue',
            'dark magenta', 'dark cyan', 'light gray', 'dark gray',
            'light red', 'light green', 'yellow', 'light blue',
            'light magenta', 'light cyan', 'white'

            Settings:
            'bold', 'underline', 'blink', 'standout', 'strikethrough'

            Some terminals use 'bold' for bright colors.  Most terminals
            ignore the 'blink' setting.  If the color is not given then
            'default' will be assumed.

        background -- a string containing the background color

            Background color values:
            'default' (use the terminal's default background),
            'black', 'dark red', 'dark green', 'brown', 'dark blue',
            'dark magenta', 'dark cyan', 'light gray'

        mono -- a comma-separated string containing monochrome terminal
        settings (see "Settings" above.)

            None = no terminal settings (same as 'default')

        foreground_high -- a string containing a comma-separated
        foreground color and settings, standard foreground
        colors (see "Color values" above) or high-colors may
        be used

            High-color example values:
            '#009' (0% red, 0% green, 60% red, like HTML colors)
            '#fcc' (100% red, 80% green, 80% blue)
            'g40' (40% gray, decimal), 'g#cc' (80% gray, hex),
            '#000', 'g0', 'g#00' (black),
            '#fff', 'g100', 'g#ff' (white)
            'h8' (color number 8), 'h255' (color number 255)

            None = use foreground parameter value

        background_high -- a string containing the background color,
        standard background colors (see "Background colors" above)
        or high-colors (see "High-color example values" above)
        may be used

            None = use background parameter value
        """
        basic = AttrSpec(foreground, background, 16)

        if type(mono) == tuple:
            # old style of specifying mono attributes was to put them
            # in a tuple.  convert to comma-separated string
            mono = ",".join(mono)
        if mono is None:
            mono = DEFAULT
        mono = AttrSpec(mono, DEFAULT, 1)

        if foreground_high is None:
            foreground_high = foreground
        if background_high is None:
            background_high = background
        high_88 = AttrSpec(foreground_high, background_high, 88)
        high_256 = AttrSpec(foreground_high, background_high, 256)

        # 'hX' where X > 15 are different in 88/256 color, use
        # basic colors for 88-color mode if high colors are specified
        # in this way (also avoids crash when X > 87)
        def large_h(desc):
            if not desc.startswith('h'):
                return False
            if ',' in desc:
                desc = desc.split(',', 1)[0]
            num = int(desc[1:], 10)
            return num > 15

        if large_h(foreground_high) or large_h(background_high):
            high_88 = basic
        else:
            high_88 = AttrSpec(foreground_high, background_high, 88)

        signals.emit_signal(self, UPDATE_PALETTE_ENTRY, name, basic, mono,
                            high_88, high_256)
        self._palette[name] = (basic, mono, high_88, high_256)
Пример #21
0
 def _modified(self):
     signals.emit_signal(self, "modified")
Пример #22
0
 def _emit(self, event, state):
     signals.emit_signal(self, event, Event(type=event, target=self, data={"state": state}))
Пример #23
0
 def refresh(self):
     self._walker.clear_cache()
     signals.emit_signal(self._walker, "modified")
Пример #24
0
 def _emit(self, name, *args):
     """
     Convenience function to emit signals with self as first
     argument.
     """
     signals.emit_signal(self, name, self, *args)
Пример #25
0
 def set_collapsed_all(self, is_collapsed):
     self._initially_collapsed = lambda x: is_collapsed
     self._divergent_positions = []
     newfocus = self._walker.first_ancestor(self._focus)
     self.set_focus(newfocus)
     signals.emit_signal(self, "modified")
Пример #26
0
 def refresh(self):
     self._walker.clear_cache()
     signals.emit_signal(self._walker, "modified")