← Back to branch summary

~ubuntu-branches/ubuntu/utopic/tdb/utopic-proposed

« back to all changes in this revision

Viewing changes to buildtools/wafadmin/ansiterm.py

  • Committer: Package Import Robot
  • Author(s): Andrew Bartlett
  • Date: 2013-02-12 20:43:55 UTC
  • mfrom: (1.4.6)
  • mto: (1.4.7) (3.3.7 experimental)
  • mto: This revision was merged to the branch mainline in revision 28.
  • Revision ID: package-import@ubuntu.com-20130212204355-6q6jvxshtoie7ex5
Import upstream version 1.2.11

Show diffs side-by-side

added added

removed removed

Lines of Context:
buildtools/wafadmin/ansiterm.py
 
1
import sys, os
 
2
try:
 
3
        if (not sys.stderr.isatty()) or (not sys.stdout.isatty()):
 
4
                raise ValueError('not a tty')
 
5
 
 
6
        from ctypes import *
 
7
 
 
8
        class COORD(Structure):
 
9
                _fields_ = [("X", c_short), ("Y", c_short)]
 
10
 
 
11
        class SMALL_RECT(Structure):
 
12
                _fields_ = [("Left", c_short), ("Top", c_short), ("Right", c_short), ("Bottom", c_short)]
 
13
 
 
14
        class CONSOLE_SCREEN_BUFFER_INFO(Structure):
 
15
                _fields_ = [("Size", COORD), ("CursorPosition", COORD), ("Attributes", c_short), ("Window", SMALL_RECT), ("MaximumWindowSize", COORD)]
 
16
 
 
17
        class CONSOLE_CURSOR_INFO(Structure):
 
18
                _fields_ = [('dwSize',c_ulong), ('bVisible', c_int)]
 
19
 
 
20
        sbinfo = CONSOLE_SCREEN_BUFFER_INFO()
 
21
        csinfo = CONSOLE_CURSOR_INFO()
 
22
        hconsole = windll.kernel32.GetStdHandle(-11)
 
23
        windll.kernel32.GetConsoleScreenBufferInfo(hconsole, byref(sbinfo))
 
24
        if sbinfo.Size.X < 10 or sbinfo.Size.Y < 10: raise Exception('small console')
 
25
        windll.kernel32.GetConsoleCursorInfo(hconsole, byref(csinfo))
 
26
except Exception:
 
27
        pass
 
28
else:
 
29
        import re, threading
 
30
 
 
31
        to_int = lambda number, default: number and int(number) or default
 
32
        wlock = threading.Lock()
 
33
 
 
34
        STD_OUTPUT_HANDLE = -11
 
35
        STD_ERROR_HANDLE = -12
 
36
 
 
37
        class AnsiTerm(object):
 
38
                def __init__(self):
 
39
                        self.hconsole = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
 
40
                        self.cursor_history = []
 
41
                        self.orig_sbinfo = CONSOLE_SCREEN_BUFFER_INFO()
 
42
                        self.orig_csinfo = CONSOLE_CURSOR_INFO()
 
43
                        windll.kernel32.GetConsoleScreenBufferInfo(self.hconsole, byref(self.orig_sbinfo))
 
44
                        windll.kernel32.GetConsoleCursorInfo(hconsole, byref(self.orig_csinfo))
 
45
 
 
46
 
 
47
                def screen_buffer_info(self):
 
48
                        sbinfo = CONSOLE_SCREEN_BUFFER_INFO()
 
49
                        windll.kernel32.GetConsoleScreenBufferInfo(self.hconsole, byref(sbinfo))
 
50
                        return sbinfo
 
51
 
 
52
                def clear_line(self, param):
 
53
                        mode = param and int(param) or 0
 
54
                        sbinfo = self.screen_buffer_info()
 
55
                        if mode == 1: # Clear from begining of line to cursor position
 
56
                                line_start = COORD(0, sbinfo.CursorPosition.Y)
 
57
                                line_length = sbinfo.Size.X
 
58
                        elif mode == 2: # Clear entire line
 
59
                                line_start = COORD(sbinfo.CursorPosition.X, sbinfo.CursorPosition.Y)
 
60
                                line_length = sbinfo.Size.X - sbinfo.CursorPosition.X
 
61
                        else: # Clear from cursor position to end of line
 
62
                                line_start = sbinfo.CursorPosition
 
63
                                line_length = sbinfo.Size.X - sbinfo.CursorPosition.X
 
64
                        chars_written = c_int()
 
65
                        windll.kernel32.FillConsoleOutputCharacterA(self.hconsole, c_char(' '), line_length, line_start, byref(chars_written))
 
66
                        windll.kernel32.FillConsoleOutputAttribute(self.hconsole, sbinfo.Attributes, line_length, line_start, byref(chars_written))
 
67
 
 
68
                def clear_screen(self, param):
 
69
                        mode = to_int(param, 0)
 
70
                        sbinfo = self.screen_buffer_info()
 
71
                        if mode == 1: # Clear from begining of screen to cursor position
 
72
                                clear_start = COORD(0, 0)
 
73
                                clear_length = sbinfo.CursorPosition.X * sbinfo.CursorPosition.Y
 
74
                        elif mode == 2: # Clear entire screen and return cursor to home
 
75
                                clear_start = COORD(0, 0)
 
76
                                clear_length = sbinfo.Size.X * sbinfo.Size.Y
 
77
                                windll.kernel32.SetConsoleCursorPosition(self.hconsole, clear_start)
 
78
                        else: # Clear from cursor position to end of screen
 
79
                                clear_start = sbinfo.CursorPosition
 
80
                                clear_length = ((sbinfo.Size.X - sbinfo.CursorPosition.X) + sbinfo.Size.X * (sbinfo.Size.Y - sbinfo.CursorPosition.Y))
 
81
                        chars_written = c_int()
 
82
                        windll.kernel32.FillConsoleOutputCharacterA(self.hconsole, c_char(' '), clear_length, clear_start, byref(chars_written))
 
83
                        windll.kernel32.FillConsoleOutputAttribute(self.hconsole, sbinfo.Attributes, clear_length, clear_start, byref(chars_written))
 
84
 
 
85
                def push_cursor(self, param):
 
86
                        sbinfo = self.screen_buffer_info()
 
87
                        self.cursor_history.push(sbinfo.CursorPosition)
 
88
 
 
89
                def pop_cursor(self, param):
 
90
                        if self.cursor_history:
 
91
                                old_pos = self.cursor_history.pop()
 
92
                                windll.kernel32.SetConsoleCursorPosition(self.hconsole, old_pos)
 
93
 
 
94
                def set_cursor(self, param):
 
95
                        x, sep, y = param.partition(';')
 
96
                        x = to_int(x, 1) - 1
 
97
                        y = to_int(y, 1) - 1
 
98
                        sbinfo = self.screen_buffer_info()
 
99
                        new_pos = COORD(
 
100
                                min(max(0, x), sbinfo.Size.X),
 
101
                                min(max(0, y), sbinfo.Size.Y)
 
102
                        )
 
103
                        windll.kernel32.SetConsoleCursorPosition(self.hconsole, new_pos)
 
104
 
 
105
                def set_column(self, param):
 
106
                        x = to_int(param, 1) - 1
 
107
                        sbinfo = self.screen_buffer_info()
 
108
                        new_pos = COORD(
 
109
                                min(max(0, x), sbinfo.Size.X),
 
110
                                sbinfo.CursorPosition.Y
 
111
                        )
 
112
                        windll.kernel32.SetConsoleCursorPosition(self.hconsole, new_pos)
 
113
 
 
114
                def move_cursor(self, x_offset=0, y_offset=0):
 
115
                        sbinfo = self.screen_buffer_info()
 
116
                        new_pos = COORD(
 
117
                                min(max(0, sbinfo.CursorPosition.X + x_offset), sbinfo.Size.X),
 
118
                                min(max(0, sbinfo.CursorPosition.Y + y_offset), sbinfo.Size.Y)
 
119
                        )
 
120
                        windll.kernel32.SetConsoleCursorPosition(self.hconsole, new_pos)
 
121
 
 
122
                def move_up(self, param):
 
123
                        self.move_cursor(y_offset = -to_int(param, 1))
 
124
 
 
125
                def move_down(self, param):
 
126
                        self.move_cursor(y_offset = to_int(param, 1))
 
127
 
 
128
                def move_left(self, param):
 
129
                        self.move_cursor(x_offset = -to_int(param, 1))
 
130
 
 
131
                def move_right(self, param):
 
132
                        self.move_cursor(x_offset = to_int(param, 1))
 
133
 
 
134
                def next_line(self, param):
 
135
                        sbinfo = self.screen_buffer_info()
 
136
                        self.move_cursor(
 
137
                                x_offset = -sbinfo.CursorPosition.X,
 
138
                                y_offset = to_int(param, 1)
 
139
                        )
 
140
 
 
141
                def prev_line(self, param):
 
142
                        sbinfo = self.screen_buffer_info()
 
143
                        self.move_cursor(
 
144
                                x_offset = -sbinfo.CursorPosition.X,
 
145
                                y_offset = -to_int(param, 1)
 
146
                        )
 
147
 
 
148
                escape_to_color = { (0, 30): 0x0,                        #black
 
149
                                                        (0, 31): 0x4,                    #red
 
150
                                                        (0, 32): 0x2,                    #green
 
151
                                                        (0, 33): 0x4+0x2,                #dark yellow
 
152
                                                        (0, 34): 0x1,                    #blue
 
153
                                                        (0, 35): 0x1+0x4,                #purple
 
154
                                                        (0, 36): 0x2+0x4,                #cyan
 
155
                                                        (0, 37): 0x1+0x2+0x4,    #grey
 
156
                                                        (1, 30): 0x1+0x2+0x4,    #dark gray
 
157
                                                        (1, 31): 0x4+0x8,                #red
 
158
                                                        (1, 32): 0x2+0x8,                #light green
 
159
                                                        (1, 33): 0x4+0x2+0x8,    #yellow
 
160
                                                        (1, 34): 0x1+0x8,                #light blue
 
161
                                                        (1, 35): 0x1+0x4+0x8,    #light purple
 
162
                                                        (1, 36): 0x1+0x2+0x8,    #light cyan
 
163
                                                        (1, 37): 0x1+0x2+0x4+0x8, #white
 
164
                                                   }
 
165
 
 
166
                def set_color(self, param):
 
167
                        cols = param.split(';')
 
168
                        attr = self.orig_sbinfo.Attributes
 
169
                        for c in cols:
 
170
                                c = to_int(c, 0)
 
171
                                if c in range(30,38):
 
172
                                        attr = (attr & 0xf0) | (self.escape_to_color.get((0,c), 0x7))
 
173
                                elif c in range(40,48):
 
174
                                        attr = (attr & 0x0f) | (self.escape_to_color.get((0,c), 0x7) << 8)
 
175
                                elif c in range(90,98):
 
176
                                        attr = (attr & 0xf0) | (self.escape_to_color.get((1,c-60), 0x7))
 
177
                                elif c in range(100,108):
 
178
                                        attr = (attr & 0x0f) | (self.escape_to_color.get((1,c-60), 0x7) << 8)
 
179
                                elif c == 1:
 
180
                                        attr |= 0x08
 
181
                        windll.kernel32.SetConsoleTextAttribute(self.hconsole, attr)
 
182
 
 
183
                def show_cursor(self,param):
 
184
                        csinfo.bVisible = 1
 
185
                        windll.kernel32.SetConsoleCursorInfo(self.hconsole, byref(csinfo))
 
186
 
 
187
                def hide_cursor(self,param):
 
188
                        csinfo.bVisible = 0
 
189
                        windll.kernel32.SetConsoleCursorInfo(self.hconsole, byref(csinfo))
 
190
 
 
191
                ansi_command_table = {
 
192
                        'A': move_up,
 
193
                        'B': move_down,
 
194
                        'C': move_right,
 
195
                        'D': move_left,
 
196
                        'E': next_line,
 
197
                        'F': prev_line,
 
198
                        'G': set_column,
 
199
                        'H': set_cursor,
 
200
                        'f': set_cursor,
 
201
                        'J': clear_screen,
 
202
                        'K': clear_line,
 
203
                        'h': show_cursor,
 
204
                        'l': hide_cursor,
 
205
                        'm': set_color,
 
206
                        's': push_cursor,
 
207
                        'u': pop_cursor,
 
208
                }
 
209
                # Match either the escape sequence or text not containing escape sequence
 
210
                ansi_tokans = re.compile('(?:\x1b\[([0-9?;]*)([a-zA-Z])|([^\x1b]+))')
 
211
                def write(self, text):
 
212
                        try:
 
213
                                wlock.acquire()
 
214
                                for param, cmd, txt in self.ansi_tokans.findall(text):
 
215
                                        if cmd:
 
216
                                                cmd_func = self.ansi_command_table.get(cmd)
 
217
                                                if cmd_func:
 
218
                                                        cmd_func(self, param)
 
219
                                        else:
 
220
                                                chars_written = c_int()
 
221
                                                if isinstance(txt, unicode):
 
222
                                                        windll.kernel32.WriteConsoleW(self.hconsole, txt, len(txt), byref(chars_written), None)
 
223
                                                else:
 
224
                                                        windll.kernel32.WriteConsoleA(self.hconsole, txt, len(txt), byref(chars_written), None)
 
225
                        finally:
 
226
                                wlock.release()
 
227
 
 
228
                def flush(self):
 
229
                        pass
 
230
 
 
231
                def isatty(self):
 
232
                        return True
 
233
 
 
234
        sys.stderr = sys.stdout = AnsiTerm()
 
235
        os.environ['TERM'] = 'vt100'
 
236