Debian Codegraph @

winterm/api.go

raw
1 // +build windows
2
3 package winterm
4
5 import (
6 "fmt"
7 "syscall"
8 "unsafe"
9 )
10
11 //===========================================================================================================
12 // IMPORTANT NOTE:
13 //
14 // The methods below make extensive use of the "unsafe" package to obtain the required pointers.
15 // Beginning in Go 1.3, the garbage collector may release local variables (e.g., incoming arguments, stack
16 // variables) the pointers reference *before* the API completes.
17 //
18 // As a result, in those cases, the code must hint that the variables remain in active by invoking the
19 // dummy method "use" (see below). Newer versions of Go are planned to change the mechanism to no longer
20 // require unsafe pointers.
21 //
22 // If you add or modify methods, ENSURE protection of local variables through the "use" builtin to inform
23 // the garbage collector the variables remain in use if:
24 //
25 // -- The value is not a pointer (e.g., int32, struct)
26 // -- The value is not referenced by the method after passing the pointer to Windows
27 //
28 // See http://golang.org/doc/go1.3.
29 //===========================================================================================================
30
31 var (
32 kernel32DLL = syscall.NewLazyDLL("kernel32.dll")
33
34 getConsoleCursorInfoProc = kernel32DLL.NewProc("GetConsoleCursorInfo")
35 setConsoleCursorInfoProc = kernel32DLL.NewProc("SetConsoleCursorInfo")
36 setConsoleCursorPositionProc = kernel32DLL.NewProc("SetConsoleCursorPosition")
37 setConsoleModeProc = kernel32DLL.NewProc("SetConsoleMode")
38 getConsoleScreenBufferInfoProc = kernel32DLL.NewProc("GetConsoleScreenBufferInfo")
39 setConsoleScreenBufferSizeProc = kernel32DLL.NewProc("SetConsoleScreenBufferSize")
40 scrollConsoleScreenBufferProc = kernel32DLL.NewProc("ScrollConsoleScreenBufferA")
41 setConsoleTextAttributeProc = kernel32DLL.NewProc("SetConsoleTextAttribute")
42 setConsoleWindowInfoProc = kernel32DLL.NewProc("SetConsoleWindowInfo")
43 writeConsoleOutputProc = kernel32DLL.NewProc("WriteConsoleOutputW")
44 readConsoleInputProc = kernel32DLL.NewProc("ReadConsoleInputW")
45 waitForSingleObjectProc = kernel32DLL.NewProc("WaitForSingleObject")
46 )
47
48 // Windows Console constants
49 const (
50 // Console modes
51 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx.
52 ENABLE_PROCESSED_INPUT = 0x0001
53 ENABLE_LINE_INPUT = 0x0002
54 ENABLE_ECHO_INPUT = 0x0004
55 ENABLE_WINDOW_INPUT = 0x0008
56 ENABLE_MOUSE_INPUT = 0x0010
57 ENABLE_INSERT_MODE = 0x0020
58 ENABLE_QUICK_EDIT_MODE = 0x0040
59 ENABLE_EXTENDED_FLAGS = 0x0080
60 ENABLE_AUTO_POSITION = 0x0100
61 ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
62
63 ENABLE_PROCESSED_OUTPUT = 0x0001
64 ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
65 ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
66 DISABLE_NEWLINE_AUTO_RETURN = 0x0008
67 ENABLE_LVB_GRID_WORLDWIDE = 0x0010
68
69 // Character attributes
70 // Note:
71 // -- The attributes are combined to produce various colors (e.g., Blue + Green will create Cyan).
72 // Clearing all foreground or background colors results in black; setting all creates white.
73 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms682088(v=vs.85).aspx#_win32_character_attributes.
74 FOREGROUND_BLUE uint16 = 0x0001
75 FOREGROUND_GREEN uint16 = 0x0002
76 FOREGROUND_RED uint16 = 0x0004
77 FOREGROUND_INTENSITY uint16 = 0x0008
78 FOREGROUND_MASK uint16 = 0x000F
79
80 BACKGROUND_BLUE uint16 = 0x0010
81 BACKGROUND_GREEN uint16 = 0x0020
82 BACKGROUND_RED uint16 = 0x0040
83 BACKGROUND_INTENSITY uint16 = 0x0080
84 BACKGROUND_MASK uint16 = 0x00F0
85
86 COMMON_LVB_MASK uint16 = 0xFF00
87 COMMON_LVB_REVERSE_VIDEO uint16 = 0x4000
88 COMMON_LVB_UNDERSCORE uint16 = 0x8000
89
90 // Input event types
91 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683499(v=vs.85).aspx.
92 KEY_EVENT = 0x0001
93 MOUSE_EVENT = 0x0002
94 WINDOW_BUFFER_SIZE_EVENT = 0x0004
95 MENU_EVENT = 0x0008
96 FOCUS_EVENT = 0x0010
97
98 // WaitForSingleObject return codes
99 WAIT_ABANDONED = 0x00000080
100 WAIT_FAILED = 0xFFFFFFFF
101 WAIT_SIGNALED = 0x0000000
102 WAIT_TIMEOUT = 0x00000102
103
104 // WaitForSingleObject wait duration
105 WAIT_INFINITE = 0xFFFFFFFF
106 WAIT_ONE_SECOND = 1000
107 WAIT_HALF_SECOND = 500
108 WAIT_QUARTER_SECOND = 250
109 )
110
111 // Windows API Console types
112 // -- See https://msdn.microsoft.com/en-us/library/windows/desktop/ms682101(v=vs.85).aspx for Console specific types (e.g., COORD)
113 // -- See https://msdn.microsoft.com/en-us/library/aa296569(v=vs.60).aspx for comments on alignment
114 type (
115 CHAR_INFO struct {
116 UnicodeChar uint16
117 Attributes uint16
118 }
119
120 CONSOLE_CURSOR_INFO struct {
121 Size uint32
122 Visible int32
123 }
124
125 CONSOLE_SCREEN_BUFFER_INFO struct {
126 Size COORD
127 CursorPosition COORD
128 Attributes uint16
129 Window SMALL_RECT
130 MaximumWindowSize COORD
131 }
132
133 COORD struct {
134 X int16
135 Y int16
136 }
137
138 SMALL_RECT struct {
139 Left int16
140 Top int16
141 Right int16
142 Bottom int16
143 }
144
145 // INPUT_RECORD is a C/C++ union of which KEY_EVENT_RECORD is one case, it is also the largest
146 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683499(v=vs.85).aspx.
147 INPUT_RECORD struct {
148 EventType uint16
149 KeyEvent KEY_EVENT_RECORD
150 }
151
152 KEY_EVENT_RECORD struct {
153 KeyDown int32
154 RepeatCount uint16
155 VirtualKeyCode uint16
156 VirtualScanCode uint16
157 UnicodeChar uint16
158 ControlKeyState uint32
159 }
160
161 WINDOW_BUFFER_SIZE struct {
162 Size COORD
163 }
164 )
165
166 // boolToBOOL converts a Go bool into a Windows int32.
167 func boolToBOOL(f bool) int32 {
168 if f {
169 return int32(1)
170 } else {
171 return int32(0)
172 }
173 }
174
175 // GetConsoleCursorInfo retrieves information about the size and visiblity of the console cursor.
176 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683163(v=vs.85).aspx.
177 func GetConsoleCursorInfo(handle uintptr, cursorInfo *CONSOLE_CURSOR_INFO) error {
178 r1, r2, err := getConsoleCursorInfoProc.Call(handle, uintptr(unsafe.Pointer(cursorInfo)), 0)
179 return checkError(r1, r2, err)
180 }
181
182 // SetConsoleCursorInfo sets the size and visiblity of the console cursor.
183 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686019(v=vs.85).aspx.
184 func SetConsoleCursorInfo(handle uintptr, cursorInfo *CONSOLE_CURSOR_INFO) error {
185 r1, r2, err := setConsoleCursorInfoProc.Call(handle, uintptr(unsafe.Pointer(cursorInfo)), 0)
186 return checkError(r1, r2, err)
187 }
188
189 // SetConsoleCursorPosition location of the console cursor.
190 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686025(v=vs.85).aspx.
191 func SetConsoleCursorPosition(handle uintptr, coord COORD) error {
192 r1, r2, err := setConsoleCursorPositionProc.Call(handle, coordToPointer(coord))
193 use(coord)
194 return checkError(r1, r2, err)
195 }
196
197 // GetConsoleMode gets the console mode for given file descriptor
198 // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683167(v=vs.85).aspx.
199 func GetConsoleMode(handle uintptr) (mode uint32, err error) {
200 err = syscall.GetConsoleMode(syscall.Handle(handle), &mode)
201 return mode, err
202 }
203
204 // SetConsoleMode sets the console mode for given file descriptor
205 // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx.
206 func SetConsoleMode(handle uintptr, mode uint32) error {
207 r1, r2, err := setConsoleModeProc.Call(handle, uintptr(mode), 0)
208 use(mode)
209 return checkError(r1, r2, err)
210 }
211
212 // GetConsoleScreenBufferInfo retrieves information about the specified console screen buffer.
213 // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683171(v=vs.85).aspx.
214 func GetConsoleScreenBufferInfo(handle uintptr) (*CONSOLE_SCREEN_BUFFER_INFO, error) {
215 info := CONSOLE_SCREEN_BUFFER_INFO{}
216 err := checkError(getConsoleScreenBufferInfoProc.Call(handle, uintptr(unsafe.Pointer(&info)), 0))
217 if err != nil {
218 return nil, err
219 }
220 return &info, nil
221 }
222
223 func ScrollConsoleScreenBuffer(handle uintptr, scrollRect SMALL_RECT, clipRect SMALL_RECT, destOrigin COORD, char CHAR_INFO) error {
224 r1, r2, err := scrollConsoleScreenBufferProc.Call(handle, uintptr(unsafe.Pointer(&scrollRect)), uintptr(unsafe.Pointer(&clipRect)), coordToPointer(destOrigin), uintptr(unsafe.Pointer(&char)))
225 use(scrollRect)
226 use(clipRect)
227 use(destOrigin)
228 use(char)
229 return checkError(r1, r2, err)
230 }
231
232 // SetConsoleScreenBufferSize sets the size of the console screen buffer.
233 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686044(v=vs.85).aspx.
234 func SetConsoleScreenBufferSize(handle uintptr, coord COORD) error {
235 r1, r2, err := setConsoleScreenBufferSizeProc.Call(handle, coordToPointer(coord))
236 use(coord)
237 return checkError(r1, r2, err)
238 }
239
240 // SetConsoleTextAttribute sets the attributes of characters written to the
241 // console screen buffer by the WriteFile or WriteConsole function.
242 // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms686047(v=vs.85).aspx.
243 func SetConsoleTextAttribute(handle uintptr, attribute uint16) error {
244 r1, r2, err := setConsoleTextAttributeProc.Call(handle, uintptr(attribute), 0)
245 use(attribute)
246 return checkError(r1, r2, err)
247 }
248
249 // SetConsoleWindowInfo sets the size and position of the console screen buffer's window.
250 // Note that the size and location must be within and no larger than the backing console screen buffer.
251 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686125(v=vs.85).aspx.
252 func SetConsoleWindowInfo(handle uintptr, isAbsolute bool, rect SMALL_RECT) error {
253 r1, r2, err := setConsoleWindowInfoProc.Call(handle, uintptr(boolToBOOL(isAbsolute)), uintptr(unsafe.Pointer(&rect)))
254 use(isAbsolute)
255 use(rect)
256 return checkError(r1, r2, err)
257 }
258
259 // WriteConsoleOutput writes the CHAR_INFOs from the provided buffer to the active console buffer.
260 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms687404(v=vs.85).aspx.
261 func WriteConsoleOutput(handle uintptr, buffer []CHAR_INFO, bufferSize COORD, bufferCoord COORD, writeRegion *SMALL_RECT) error {
262 r1, r2, err := writeConsoleOutputProc.Call(handle, uintptr(unsafe.Pointer(&buffer[0])), coordToPointer(bufferSize), coordToPointer(bufferCoord), uintptr(unsafe.Pointer(writeRegion)))
263 use(buffer)
264 use(bufferSize)
265 use(bufferCoord)
266 return checkError(r1, r2, err)
267 }
268
269 // ReadConsoleInput reads (and removes) data from the console input buffer.
270 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms684961(v=vs.85).aspx.
271 func ReadConsoleInput(handle uintptr, buffer []INPUT_RECORD, count *uint32) error {
272 r1, r2, err := readConsoleInputProc.Call(handle, uintptr(unsafe.Pointer(&buffer[0])), uintptr(len(buffer)), uintptr(unsafe.Pointer(count)))
273 use(buffer)
274 return checkError(r1, r2, err)
275 }
276
277 // WaitForSingleObject waits for the passed handle to be signaled.
278 // It returns true if the handle was signaled; false otherwise.
279 // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx.
280 func WaitForSingleObject(handle uintptr, msWait uint32) (bool, error) {
281 r1, _, err := waitForSingleObjectProc.Call(handle, uintptr(uint32(msWait)))
282 switch r1 {
283 case WAIT_ABANDONED, WAIT_TIMEOUT:
284 return false, nil
285 case WAIT_SIGNALED:
286 return true, nil
287 }
288 use(msWait)
289 return false, err
290 }
291
292 // String helpers
293 func (info CONSOLE_SCREEN_BUFFER_INFO) String() string {
294 return fmt.Sprintf("Size(%v) Cursor(%v) Window(%v) Max(%v)", info.Size, info.CursorPosition, info.Window, info.MaximumWindowSize)
295 }
296
297 func (coord COORD) String() string {
298 return fmt.Sprintf("%v,%v", coord.X, coord.Y)
299 }
300
301 func (rect SMALL_RECT) String() string {
302 return fmt.Sprintf("(%v,%v),(%v,%v)", rect.Left, rect.Top, rect.Right, rect.Bottom)
303 }
304
305 // checkError evaluates the results of a Windows API call and returns the error if it failed.
306 func checkError(r1, r2 uintptr, err error) error {
307 // Windows APIs return non-zero to indicate success
308 if r1 != 0 {
309 return nil
310 }
311
312 // Return the error if provided, otherwise default to EINVAL
313 if err != nil {
314 return err
315 }
316 return syscall.EINVAL
317 }
318
319 // coordToPointer converts a COORD into a uintptr (by fooling the type system).
320 func coordToPointer(c COORD) uintptr {
321 // Note: This code assumes the two SHORTs are correctly laid out; the "cast" to uint32 is just to get a pointer to pass.
322 return uintptr(*((*uint32)(unsafe.Pointer(&c))))
323 }
324
325 // use is a no-op, but the compiler cannot see that it is.
326 // Calling use(p) ensures that p is kept live until that point.
327 func use(p interface{}) {}