432 lines
13 KiB
Python
432 lines
13 KiB
Python
'''This implements a virtual screen. This is used to support ANSI terminal
|
|
emulation. The screen representation and state is implemented in this class.
|
|
Most of the methods are inspired by ANSI screen control codes. The
|
|
:class:`~pexpect.ANSI.ANSI` class extends this class to add parsing of ANSI
|
|
escape codes.
|
|
|
|
PEXPECT LICENSE
|
|
|
|
This license is approved by the OSI and FSF as GPL-compatible.
|
|
http://opensource.org/licenses/isc-license.txt
|
|
|
|
Copyright (c) 2012, Noah Spurrier <noah@noah.org>
|
|
PERMISSION TO USE, COPY, MODIFY, AND/OR DISTRIBUTE THIS SOFTWARE FOR ANY
|
|
PURPOSE WITH OR WITHOUT FEE IS HEREBY GRANTED, PROVIDED THAT THE ABOVE
|
|
COPYRIGHT NOTICE AND THIS PERMISSION NOTICE APPEAR IN ALL COPIES.
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
'''
|
|
|
|
import codecs
|
|
import copy
|
|
import sys
|
|
|
|
import warnings
|
|
|
|
warnings.warn(("pexpect.screen and pexpect.ANSI are deprecated. "
|
|
"We recommend using pyte to emulate a terminal screen: "
|
|
"https://pypi.python.org/pypi/pyte"),
|
|
stacklevel=2)
|
|
|
|
NUL = 0 # Fill character; ignored on input.
|
|
ENQ = 5 # Transmit answerback message.
|
|
BEL = 7 # Ring the bell.
|
|
BS = 8 # Move cursor left.
|
|
HT = 9 # Move cursor to next tab stop.
|
|
LF = 10 # Line feed.
|
|
VT = 11 # Same as LF.
|
|
FF = 12 # Same as LF.
|
|
CR = 13 # Move cursor to left margin or newline.
|
|
SO = 14 # Invoke G1 character set.
|
|
SI = 15 # Invoke G0 character set.
|
|
XON = 17 # Resume transmission.
|
|
XOFF = 19 # Halt transmission.
|
|
CAN = 24 # Cancel escape sequence.
|
|
SUB = 26 # Same as CAN.
|
|
ESC = 27 # Introduce a control sequence.
|
|
DEL = 127 # Fill character; ignored on input.
|
|
SPACE = u' ' # Space or blank character.
|
|
|
|
PY3 = (sys.version_info[0] >= 3)
|
|
if PY3:
|
|
unicode = str
|
|
|
|
def constrain (n, min, max):
|
|
|
|
'''This returns a number, n constrained to the min and max bounds. '''
|
|
|
|
if n < min:
|
|
return min
|
|
if n > max:
|
|
return max
|
|
return n
|
|
|
|
class screen:
|
|
'''This object maintains the state of a virtual text screen as a
|
|
rectangular array. This maintains a virtual cursor position and handles
|
|
scrolling as characters are added. This supports most of the methods needed
|
|
by an ANSI text screen. Row and column indexes are 1-based (not zero-based,
|
|
like arrays).
|
|
|
|
Characters are represented internally using unicode. Methods that accept
|
|
input characters, when passed 'bytes' (which in Python 2 is equivalent to
|
|
'str'), convert them from the encoding specified in the 'encoding'
|
|
parameter to the constructor. Methods that return screen contents return
|
|
unicode strings, with the exception of __str__() under Python 2. Passing
|
|
``encoding=None`` limits the API to only accept unicode input, so passing
|
|
bytes in will raise :exc:`TypeError`.
|
|
'''
|
|
def __init__(self, r=24, c=80, encoding='latin-1', encoding_errors='replace'):
|
|
'''This initializes a blank screen of the given dimensions.'''
|
|
|
|
self.rows = r
|
|
self.cols = c
|
|
self.encoding = encoding
|
|
self.encoding_errors = encoding_errors
|
|
if encoding is not None:
|
|
self.decoder = codecs.getincrementaldecoder(encoding)(encoding_errors)
|
|
else:
|
|
self.decoder = None
|
|
self.cur_r = 1
|
|
self.cur_c = 1
|
|
self.cur_saved_r = 1
|
|
self.cur_saved_c = 1
|
|
self.scroll_row_start = 1
|
|
self.scroll_row_end = self.rows
|
|
self.w = [ [SPACE] * self.cols for _ in range(self.rows)]
|
|
|
|
def _decode(self, s):
|
|
'''This converts from the external coding system (as passed to
|
|
the constructor) to the internal one (unicode). '''
|
|
if self.decoder is not None:
|
|
return self.decoder.decode(s)
|
|
else:
|
|
raise TypeError("This screen was constructed with encoding=None, "
|
|
"so it does not handle bytes.")
|
|
|
|
def _unicode(self):
|
|
'''This returns a printable representation of the screen as a unicode
|
|
string (which, under Python 3.x, is the same as 'str'). The end of each
|
|
screen line is terminated by a newline.'''
|
|
|
|
return u'\n'.join ([ u''.join(c) for c in self.w ])
|
|
|
|
if PY3:
|
|
__str__ = _unicode
|
|
else:
|
|
__unicode__ = _unicode
|
|
|
|
def __str__(self):
|
|
'''This returns a printable representation of the screen. The end of
|
|
each screen line is terminated by a newline. '''
|
|
encoding = self.encoding or 'ascii'
|
|
return self._unicode().encode(encoding, 'replace')
|
|
|
|
def dump (self):
|
|
'''This returns a copy of the screen as a unicode string. This is similar to
|
|
__str__/__unicode__ except that lines are not terminated with line
|
|
feeds.'''
|
|
|
|
return u''.join ([ u''.join(c) for c in self.w ])
|
|
|
|
def pretty (self):
|
|
'''This returns a copy of the screen as a unicode string with an ASCII
|
|
text box around the screen border. This is similar to
|
|
__str__/__unicode__ except that it adds a box.'''
|
|
|
|
top_bot = u'+' + u'-'*self.cols + u'+\n'
|
|
return top_bot + u'\n'.join([u'|'+line+u'|' for line in unicode(self).split(u'\n')]) + u'\n' + top_bot
|
|
|
|
def fill (self, ch=SPACE):
|
|
|
|
if isinstance(ch, bytes):
|
|
ch = self._decode(ch)
|
|
|
|
self.fill_region (1,1,self.rows,self.cols, ch)
|
|
|
|
def fill_region (self, rs,cs, re,ce, ch=SPACE):
|
|
|
|
if isinstance(ch, bytes):
|
|
ch = self._decode(ch)
|
|
|
|
rs = constrain (rs, 1, self.rows)
|
|
re = constrain (re, 1, self.rows)
|
|
cs = constrain (cs, 1, self.cols)
|
|
ce = constrain (ce, 1, self.cols)
|
|
if rs > re:
|
|
rs, re = re, rs
|
|
if cs > ce:
|
|
cs, ce = ce, cs
|
|
for r in range (rs, re+1):
|
|
for c in range (cs, ce + 1):
|
|
self.put_abs (r,c,ch)
|
|
|
|
def cr (self):
|
|
'''This moves the cursor to the beginning (col 1) of the current row.
|
|
'''
|
|
|
|
self.cursor_home (self.cur_r, 1)
|
|
|
|
def lf (self):
|
|
'''This moves the cursor down with scrolling.
|
|
'''
|
|
|
|
old_r = self.cur_r
|
|
self.cursor_down()
|
|
if old_r == self.cur_r:
|
|
self.scroll_up ()
|
|
self.erase_line()
|
|
|
|
def crlf (self):
|
|
'''This advances the cursor with CRLF properties.
|
|
The cursor will line wrap and the screen may scroll.
|
|
'''
|
|
|
|
self.cr ()
|
|
self.lf ()
|
|
|
|
def newline (self):
|
|
'''This is an alias for crlf().
|
|
'''
|
|
|
|
self.crlf()
|
|
|
|
def put_abs (self, r, c, ch):
|
|
'''Screen array starts at 1 index.'''
|
|
|
|
r = constrain (r, 1, self.rows)
|
|
c = constrain (c, 1, self.cols)
|
|
if isinstance(ch, bytes):
|
|
ch = self._decode(ch)[0]
|
|
else:
|
|
ch = ch[0]
|
|
self.w[r-1][c-1] = ch
|
|
|
|
def put (self, ch):
|
|
'''This puts a characters at the current cursor position.
|
|
'''
|
|
|
|
if isinstance(ch, bytes):
|
|
ch = self._decode(ch)
|
|
|
|
self.put_abs (self.cur_r, self.cur_c, ch)
|
|
|
|
def insert_abs (self, r, c, ch):
|
|
'''This inserts a character at (r,c). Everything under
|
|
and to the right is shifted right one character.
|
|
The last character of the line is lost.
|
|
'''
|
|
|
|
if isinstance(ch, bytes):
|
|
ch = self._decode(ch)
|
|
|
|
r = constrain (r, 1, self.rows)
|
|
c = constrain (c, 1, self.cols)
|
|
for ci in range (self.cols, c, -1):
|
|
self.put_abs (r,ci, self.get_abs(r,ci-1))
|
|
self.put_abs (r,c,ch)
|
|
|
|
def insert (self, ch):
|
|
|
|
if isinstance(ch, bytes):
|
|
ch = self._decode(ch)
|
|
|
|
self.insert_abs (self.cur_r, self.cur_c, ch)
|
|
|
|
def get_abs (self, r, c):
|
|
|
|
r = constrain (r, 1, self.rows)
|
|
c = constrain (c, 1, self.cols)
|
|
return self.w[r-1][c-1]
|
|
|
|
def get (self):
|
|
|
|
self.get_abs (self.cur_r, self.cur_c)
|
|
|
|
def get_region (self, rs,cs, re,ce):
|
|
'''This returns a list of lines representing the region.
|
|
'''
|
|
|
|
rs = constrain (rs, 1, self.rows)
|
|
re = constrain (re, 1, self.rows)
|
|
cs = constrain (cs, 1, self.cols)
|
|
ce = constrain (ce, 1, self.cols)
|
|
if rs > re:
|
|
rs, re = re, rs
|
|
if cs > ce:
|
|
cs, ce = ce, cs
|
|
sc = []
|
|
for r in range (rs, re+1):
|
|
line = u''
|
|
for c in range (cs, ce + 1):
|
|
ch = self.get_abs (r,c)
|
|
line = line + ch
|
|
sc.append (line)
|
|
return sc
|
|
|
|
def cursor_constrain (self):
|
|
'''This keeps the cursor within the screen area.
|
|
'''
|
|
|
|
self.cur_r = constrain (self.cur_r, 1, self.rows)
|
|
self.cur_c = constrain (self.cur_c, 1, self.cols)
|
|
|
|
def cursor_home (self, r=1, c=1): # <ESC>[{ROW};{COLUMN}H
|
|
|
|
self.cur_r = r
|
|
self.cur_c = c
|
|
self.cursor_constrain ()
|
|
|
|
def cursor_back (self,count=1): # <ESC>[{COUNT}D (not confused with down)
|
|
|
|
self.cur_c = self.cur_c - count
|
|
self.cursor_constrain ()
|
|
|
|
def cursor_down (self,count=1): # <ESC>[{COUNT}B (not confused with back)
|
|
|
|
self.cur_r = self.cur_r + count
|
|
self.cursor_constrain ()
|
|
|
|
def cursor_forward (self,count=1): # <ESC>[{COUNT}C
|
|
|
|
self.cur_c = self.cur_c + count
|
|
self.cursor_constrain ()
|
|
|
|
def cursor_up (self,count=1): # <ESC>[{COUNT}A
|
|
|
|
self.cur_r = self.cur_r - count
|
|
self.cursor_constrain ()
|
|
|
|
def cursor_up_reverse (self): # <ESC> M (called RI -- Reverse Index)
|
|
|
|
old_r = self.cur_r
|
|
self.cursor_up()
|
|
if old_r == self.cur_r:
|
|
self.scroll_up()
|
|
|
|
def cursor_force_position (self, r, c): # <ESC>[{ROW};{COLUMN}f
|
|
'''Identical to Cursor Home.'''
|
|
|
|
self.cursor_home (r, c)
|
|
|
|
def cursor_save (self): # <ESC>[s
|
|
'''Save current cursor position.'''
|
|
|
|
self.cursor_save_attrs()
|
|
|
|
def cursor_unsave (self): # <ESC>[u
|
|
'''Restores cursor position after a Save Cursor.'''
|
|
|
|
self.cursor_restore_attrs()
|
|
|
|
def cursor_save_attrs (self): # <ESC>7
|
|
'''Save current cursor position.'''
|
|
|
|
self.cur_saved_r = self.cur_r
|
|
self.cur_saved_c = self.cur_c
|
|
|
|
def cursor_restore_attrs (self): # <ESC>8
|
|
'''Restores cursor position after a Save Cursor.'''
|
|
|
|
self.cursor_home (self.cur_saved_r, self.cur_saved_c)
|
|
|
|
def scroll_constrain (self):
|
|
'''This keeps the scroll region within the screen region.'''
|
|
|
|
if self.scroll_row_start <= 0:
|
|
self.scroll_row_start = 1
|
|
if self.scroll_row_end > self.rows:
|
|
self.scroll_row_end = self.rows
|
|
|
|
def scroll_screen (self): # <ESC>[r
|
|
'''Enable scrolling for entire display.'''
|
|
|
|
self.scroll_row_start = 1
|
|
self.scroll_row_end = self.rows
|
|
|
|
def scroll_screen_rows (self, rs, re): # <ESC>[{start};{end}r
|
|
'''Enable scrolling from row {start} to row {end}.'''
|
|
|
|
self.scroll_row_start = rs
|
|
self.scroll_row_end = re
|
|
self.scroll_constrain()
|
|
|
|
def scroll_down (self): # <ESC>D
|
|
'''Scroll display down one line.'''
|
|
|
|
# Screen is indexed from 1, but arrays are indexed from 0.
|
|
s = self.scroll_row_start - 1
|
|
e = self.scroll_row_end - 1
|
|
self.w[s+1:e+1] = copy.deepcopy(self.w[s:e])
|
|
|
|
def scroll_up (self): # <ESC>M
|
|
'''Scroll display up one line.'''
|
|
|
|
# Screen is indexed from 1, but arrays are indexed from 0.
|
|
s = self.scroll_row_start - 1
|
|
e = self.scroll_row_end - 1
|
|
self.w[s:e] = copy.deepcopy(self.w[s+1:e+1])
|
|
|
|
def erase_end_of_line (self): # <ESC>[0K -or- <ESC>[K
|
|
'''Erases from the current cursor position to the end of the current
|
|
line.'''
|
|
|
|
self.fill_region (self.cur_r, self.cur_c, self.cur_r, self.cols)
|
|
|
|
def erase_start_of_line (self): # <ESC>[1K
|
|
'''Erases from the current cursor position to the start of the current
|
|
line.'''
|
|
|
|
self.fill_region (self.cur_r, 1, self.cur_r, self.cur_c)
|
|
|
|
def erase_line (self): # <ESC>[2K
|
|
'''Erases the entire current line.'''
|
|
|
|
self.fill_region (self.cur_r, 1, self.cur_r, self.cols)
|
|
|
|
def erase_down (self): # <ESC>[0J -or- <ESC>[J
|
|
'''Erases the screen from the current line down to the bottom of the
|
|
screen.'''
|
|
|
|
self.erase_end_of_line ()
|
|
self.fill_region (self.cur_r + 1, 1, self.rows, self.cols)
|
|
|
|
def erase_up (self): # <ESC>[1J
|
|
'''Erases the screen from the current line up to the top of the
|
|
screen.'''
|
|
|
|
self.erase_start_of_line ()
|
|
self.fill_region (self.cur_r-1, 1, 1, self.cols)
|
|
|
|
def erase_screen (self): # <ESC>[2J
|
|
'''Erases the screen with the background color.'''
|
|
|
|
self.fill ()
|
|
|
|
def set_tab (self): # <ESC>H
|
|
'''Sets a tab at the current position.'''
|
|
|
|
pass
|
|
|
|
def clear_tab (self): # <ESC>[g
|
|
'''Clears tab at the current position.'''
|
|
|
|
pass
|
|
|
|
def clear_all_tabs (self): # <ESC>[3g
|
|
'''Clears all tabs.'''
|
|
|
|
pass
|
|
|
|
# Insert line Esc [ Pn L
|
|
# Delete line Esc [ Pn M
|
|
# Delete character Esc [ Pn P
|
|
# Scrolling region Esc [ Pn(top);Pn(bot) r
|
|
|