1 /****************************************************************************
2 * Copyright 2020,2021 Thomas E. Dickey *
3 * Copyright 1998-2009,2010 Free Software Foundation, Inc. *
4 * *
5 * Permission is hereby granted, free of charge, to any person obtaining a *
6 * copy of this software and associated documentation files (the *
7 * "Software"), to deal in the Software without restriction, including *
8 * without limitation the rights to use, copy, modify, merge, publish, *
9 * distribute, distribute with modifications, sublicense, and/or sell *
10 * copies of the Software, and to permit persons to whom the Software is *
11 * furnished to do so, subject to the following conditions: *
12 * *
13 * The above copyright notice and this permission notice shall be included *
14 * in all copies or substantial portions of the Software. *
15 * *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
19 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
22 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
23 * *
24 * Except as contained in this notice, the name(s) of the above copyright *
25 * holders shall not be used in advertising or otherwise to promote the *
26 * sale, use or other dealings in this Software without prior written *
27 * authorization. *
28 ****************************************************************************/
29
30 /****************************************************************************
31 * Author: Juergen Pfeifer *
32 * and: Thomas E. Dickey *
33 ****************************************************************************/
34
35 /*
36 * TODO - GetMousePos(POINT * result) from ntconio.c
37 */
38
39 #include <curses.priv.h>
40
41 MODULE_ID("$Id: lib_win32con.c,v 1.7 2021/09/04 10:54:35 tom Exp $")
42
43 #ifdef _NC_WINDOWS
44
45 #ifdef _NC_MINGW
46 #include <wchar.h>
47 #else
48 #include <tchar.h>
49 #endif
50
51 #include <io.h>
52
53 #if USE_WIDEC_SUPPORT
54 #define write_screen WriteConsoleOutputW
55 #define read_screen ReadConsoleOutputW
56 #else
57 #define write_screen WriteConsoleOutput
58 #define read_screen ReadConsoleOutput
59 #endif
60
61 static BOOL IsConsoleHandle(HANDLE hdl);
62 static bool save_original_screen(void);
63 static bool restore_original_screen(void) GCC_UNUSED;
64 static bool read_screen_data(void);
65 static int Adjust(int milliseconds, int diff);
66 static int decode_mouse(SCREEN *sp, int mask);
67 static bool handle_mouse(SCREEN *sp, MOUSE_EVENT_RECORD mer);
68 static int rkeycompare(const void *el1, const void *el2);
69 static int keycompare(const void *el1, const void *el2);
70 static int MapKey(WORD vKey);
71 static int AnsiKey(WORD vKey);
72
73 static ULONGLONG tdiff(FILETIME fstart, FILETIME fend);
74
75 #define GenMap(vKey,key) MAKELONG(key, vKey)
76 static const LONG keylist[] =
77 {
78 GenMap(VK_PRIOR, KEY_PPAGE),
79 GenMap(VK_NEXT, KEY_NPAGE),
80 GenMap(VK_END, KEY_END),
81 GenMap(VK_HOME, KEY_HOME),
82 GenMap(VK_LEFT, KEY_LEFT),
83 GenMap(VK_UP, KEY_UP),
84 GenMap(VK_RIGHT, KEY_RIGHT),
85 GenMap(VK_DOWN, KEY_DOWN),
86 GenMap(VK_DELETE, KEY_DC),
87 GenMap(VK_INSERT, KEY_IC)
88 };
89 static const LONG ansi_keys[] =
90 {
91 GenMap(VK_PRIOR, 'I'),
92 GenMap(VK_NEXT, 'Q'),
93 GenMap(VK_END, 'O'),
94 GenMap(VK_HOME, 'H'),
95 GenMap(VK_LEFT, 'K'),
96 GenMap(VK_UP, 'H'),
97 GenMap(VK_RIGHT, 'M'),
98 GenMap(VK_DOWN, 'P'),
99 GenMap(VK_DELETE, 'S'),
100 GenMap(VK_INSERT, 'R')
101 };
102 #define array_length(a) (sizeof(a)/sizeof(a[0]))
103 #define N_INI ((int)array_length(keylist))
104 #define FKEYS 24
105 #define MAPSIZE (FKEYS + N_INI)
106
107 /* A process can only have a single console, so it is safe
108 to maintain all the information about it in a single
109 static structure.
110 */
111 NCURSES_EXPORT_VAR(ConsoleInfo) _nc_CONSOLE;
112 static bool console_initialized = FALSE;
113
114 #define EnsureInit() (void)(console_initialized ? TRUE : _nc_console_checkinit(TRUE, TRUE))
115
116 #define REQUIRED_MAX_V (DWORD)10
117 #define REQUIRED_MIN_V (DWORD)0
118 #define REQUIRED_BUILD (DWORD)17763
119 /*
120 This function returns 0 if the Windows version has no support for
121 the modern Console interface, otherwise it returns 1
122 */
123 NCURSES_EXPORT(int)
_nc_console_vt_supported(void)124 _nc_console_vt_supported(void)
125 {
126 OSVERSIONINFO osvi;
127 int res = 0;
128
129 T((T_CALLED("lib_win32con::_nc_console_vt_supported")));
130 ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
131 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
132
133 GetVersionEx(&osvi);
134 T(("GetVersionEx returnedMajor=%ld, Minor=%ld, Build=%ld",
135 osvi.dwMajorVersion,
136 osvi.dwMinorVersion,
137 osvi.dwBuildNumber));
138 if (osvi.dwMajorVersion >= REQUIRED_MAX_V) {
139 if (osvi.dwMajorVersion == REQUIRED_MAX_V) {
140 if (((osvi.dwMinorVersion == REQUIRED_MIN_V) &&
141 (osvi.dwBuildNumber >= REQUIRED_BUILD)) ||
142 ((osvi.dwMinorVersion > REQUIRED_MIN_V)))
143 res = 1;
144 } else
145 res = 1;
146 }
147 returnCode(res);
148 }
149
150 NCURSES_EXPORT(void)
_nc_console_size(int * Lines,int * Cols)151 _nc_console_size(int* Lines, int* Cols)
152 {
153 EnsureInit();
154 if (Lines != NULL && Cols != NULL) {
155 if (WINCONSOLE.buffered) {
156 *Lines = (int) (WINCONSOLE.SBI.dwSize.Y);
157 *Cols = (int) (WINCONSOLE.SBI.dwSize.X);
158 } else {
159 *Lines = (int) (WINCONSOLE.SBI.srWindow.Bottom + 1 -
160 WINCONSOLE.SBI.srWindow.Top);
161 *Cols = (int) (WINCONSOLE.SBI.srWindow.Right + 1 -
162 WINCONSOLE.SBI.srWindow.Left);
163 }
164 }
165 }
166
167 /* Convert a file descriptor into a HANDLE
168 That's not necessarily a console HANDLE
169 */
170 NCURSES_EXPORT(HANDLE)
_nc_console_handle(int fd)171 _nc_console_handle(int fd)
172 {
173 intptr_t value = _get_osfhandle(fd);
174 return (HANDLE) value;
175 }
176
177 /* Validate that a HANDLE is actually a
178 console HANDLE
179 */
180 static BOOL
IsConsoleHandle(HANDLE hdl)181 IsConsoleHandle(HANDLE hdl)
182 {
183 DWORD dwFlag = 0;
184 BOOL result = FALSE;
185
186 T((T_CALLED("lib_win32con::IsConsoleHandle(HANDLE=%p"), hdl));
187
188 EnsureInit();
189
190 if (!GetConsoleMode(hdl, &dwFlag)) {
191 T(("GetConsoleMode failed"));
192 } else {
193 result = TRUE;
194 }
195
196 returnBool(result);
197 }
198
199 /* This is used when running in terminfo mode to discover,
200 whether or not the "terminal" is actually a Windows
201 Console. It is the responsibility of the console to deal
202 with the terminal escape sequences that are sent by
203 terminfo.
204 */
205 NCURSES_EXPORT(int)
_nc_console_test(int fd)206 _nc_console_test(int fd)
207 {
208 int code = 0;
209 HANDLE hdl = INVALID_HANDLE_VALUE;
210 T((T_CALLED("lib_win32con::_nc_console_test(%d)"), fd));
211 hdl = _nc_console_handle(fd);
212 code = (int) IsConsoleHandle(hdl);
213 returnCode(code);
214 }
215
216 #define OutHandle() ((WINCONSOLE.isTermInfoConsole || WINCONSOLE.progMode) ? WINCONSOLE.hdl : WINCONSOLE.out)
217
218 NCURSES_EXPORT(void)
_nc_console_selectActiveHandle(void)219 _nc_console_selectActiveHandle(void)
220 {
221 if (WINCONSOLE.lastOut != WINCONSOLE.hdl) {
222 WINCONSOLE.lastOut = WINCONSOLE.hdl;
223 SetConsoleActiveScreenBuffer(WINCONSOLE.lastOut);
224 }
225 }
226
227 NCURSES_EXPORT(HANDLE)
_nc_console_fd2handle(int fd)228 _nc_console_fd2handle(int fd)
229 {
230 HANDLE hdl = _nc_console_handle(fd);
231 if (hdl==WINCONSOLE.inp) {
232 T(("lib_win32con:validateHandle %d -> WINCONSOLE.inp", fd));
233 } else if (hdl==WINCONSOLE.hdl) {
234 T(("lib_win32con:validateHandle %d -> WINCONSOLE.hdl", fd));
235 } else if (hdl==WINCONSOLE.out) {
236 T(("lib_win32con:validateHandle %d -> WINCONSOLE.out", fd));
237 } else {
238 T(("lib_win32con:validateHandle %d maps to unknown HANDLE", fd));
239 hdl = INVALID_HANDLE_VALUE;
240 }
241 #if 1
242 assert(hdl != INVALID_HANDLE_VALUE);
243 #endif
244 if (hdl != INVALID_HANDLE_VALUE) {
245 if (hdl != WINCONSOLE.inp && (!WINCONSOLE.isTermInfoConsole && WINCONSOLE.progMode)) {
246 if (hdl==WINCONSOLE.out && hdl!=WINCONSOLE.hdl) {
247 T(("lib_win32con:validateHandle forcing WINCONSOLE.out -> WINCONSOLE.hdl"));
248 hdl = WINCONSOLE.hdl;
249 }
250 }
251 }
252 return hdl;
253 }
254
255 NCURSES_EXPORT(int)
_nc_console_setmode(HANDLE hdl,const TTY * arg)256 _nc_console_setmode(HANDLE hdl, const TTY *arg)
257 {
258 DWORD dwFlag = 0;
259 int code = ERR;
260 HANDLE alt;
261
262 if (arg) {
263 #ifdef TRACE
264 TTY TRCTTY;
265 #define TRCTTYOUT(flag) TRCTTY.dwFlagOut = flag
266 #define TRCTTYIN(flag) TRCTTY.dwFlagIn = flag
267 #else
268 #define TRCTTYOUT(flag)
269 #define TRCTTYIN(flag)
270 #endif
271 T(("lib_win32con:_nc_console_setmode %s", _nc_trace_ttymode(arg)));
272 if (hdl==WINCONSOLE.inp) {
273 dwFlag = arg->dwFlagIn | ENABLE_MOUSE_INPUT | VT_FLAG_IN;
274 if (WINCONSOLE.isTermInfoConsole)
275 dwFlag |= (VT_FLAG_IN);
276 else
277 dwFlag &= (DWORD) ~(VT_FLAG_IN);
278 TRCTTYIN(dwFlag);
279 SetConsoleMode(hdl, dwFlag);
280
281 alt = OutHandle();
282 dwFlag = arg->dwFlagOut;
283 if (WINCONSOLE.isTermInfoConsole)
284 dwFlag |= (VT_FLAG_OUT);
285 else
286 dwFlag |= (VT_FLAG_OUT);
287 TRCTTYOUT(dwFlag);
288 SetConsoleMode(alt, dwFlag);
289 } else {
290 dwFlag = arg->dwFlagOut;
291 if (WINCONSOLE.isTermInfoConsole)
292 dwFlag |= (VT_FLAG_OUT);
293 else
294 dwFlag |= (VT_FLAG_OUT);
295 TRCTTYOUT(dwFlag);
296 SetConsoleMode(hdl, dwFlag);
297
298 alt = WINCONSOLE.inp;
299 dwFlag = arg->dwFlagIn | ENABLE_MOUSE_INPUT;
300 if (WINCONSOLE.isTermInfoConsole)
301 dwFlag |= (VT_FLAG_IN);
302 else
303 dwFlag &= (DWORD) ~(VT_FLAG_IN);
304 TRCTTYIN(dwFlag);
305 SetConsoleMode(alt, dwFlag);
306 T(("effective mode set %s", _nc_trace_ttymode(&TRCTTY)));
307 }
308 code = OK;
309 }
310 return(code);
311 }
312
313 NCURSES_EXPORT(int)
_nc_console_getmode(HANDLE hdl,TTY * arg)314 _nc_console_getmode(HANDLE hdl, TTY *arg)
315 {
316 int code = ERR;
317
318 if (arg) {
319 DWORD dwFlag = 0;
320 HANDLE alt;
321
322 if (hdl==WINCONSOLE.inp) {
323 if(GetConsoleMode(hdl, &dwFlag)) {
324 arg->dwFlagIn = dwFlag;
325 alt = OutHandle();
326 if (GetConsoleMode(alt, &dwFlag)) {
327 arg->dwFlagOut = dwFlag;
328 code = OK;
329 }
330 }
331 } else {
332 if (GetConsoleMode(hdl, &dwFlag)) {
333 arg->dwFlagOut = dwFlag;
334 alt = WINCONSOLE.inp;
335 if (GetConsoleMode(alt, &dwFlag)) {
336 arg->dwFlagIn = dwFlag;
337 code = OK;
338 }
339 }
340 }
341 }
342 T(("lib_win32con:_nc_console_getmode %s", _nc_trace_ttymode(arg)));
343 return(code);
344 }
345
346 NCURSES_EXPORT(int)
_nc_console_flush(HANDLE hdl)347 _nc_console_flush(HANDLE hdl)
348 {
349 int code = OK;
350
351 T((T_CALLED("lib_win32con::_nc_console_flush(hdl=%p"), hdl));
352
353 if (hdl != INVALID_HANDLE_VALUE) {
354 if (hdl == WINCONSOLE.hdl ||
355 hdl == WINCONSOLE.inp ||
356 hdl == WINCONSOLE.out) {
357 if (!FlushConsoleInputBuffer(WINCONSOLE.inp))
358 code = ERR;
359 } else {
360 code = ERR;
361 T(("_nc_console_flush not requesting a handle owned by console."));
362 }
363 }
364 returnCode(code);
365 }
366
367 NCURSES_EXPORT(WORD)
_nc_console_MapColor(bool fore,int color)368 _nc_console_MapColor(bool fore, int color)
369 {
370 static const int _cmap[] =
371 {0, 4, 2, 6, 1, 5, 3, 7};
372 int a;
373 if (color < 0 || color > 7)
374 a = fore ? 7 : 0;
375 else
376 a = _cmap[color];
377 if (!fore)
378 a = a << 4;
379 return (WORD) a;
380 }
381
382
383 /*
384 * Attempt to save the screen contents. PDCurses does this if
385 * PDC_RESTORE_SCREEN is set, giving the same visual appearance on
386 * restoration as if the library had allocated a console buffer. MSDN
387 * says that the data which can be read is limited to 64Kb (and may be
388 * less).
389 */
390 static bool
save_original_screen(void)391 save_original_screen(void)
392 {
393 bool result = FALSE;
394
395 WINCONSOLE.save_region.Top = 0;
396 WINCONSOLE.save_region.Left = 0;
397 WINCONSOLE.save_region.Bottom = (SHORT) (WINCONSOLE.SBI.dwSize.Y - 1);
398 WINCONSOLE.save_region.Right = (SHORT) (WINCONSOLE.SBI.dwSize.X - 1);
399
400 if (read_screen_data()) {
401 result = TRUE;
402 } else {
403
404 WINCONSOLE.save_region.Top = WINCONSOLE.SBI.srWindow.Top;
405 WINCONSOLE.save_region.Left = WINCONSOLE.SBI.srWindow.Left;
406 WINCONSOLE.save_region.Bottom = WINCONSOLE.SBI.srWindow.Bottom;
407 WINCONSOLE.save_region.Right = WINCONSOLE.SBI.srWindow.Right;
408
409 WINCONSOLE.window_only = TRUE;
410
411 if (read_screen_data()) {
412 result = TRUE;
413 }
414 }
415
416 T(("... save original screen contents %s", result ? "ok" : "err"));
417 return result;
418 }
419
420 static bool
restore_original_screen(void)421 restore_original_screen(void)
422 {
423 COORD bufferCoord;
424 bool result = FALSE;
425 SMALL_RECT save_region = WINCONSOLE.save_region;
426
427 T(("... restoring %s",
428 WINCONSOLE.window_only ? "window" : "entire buffer"));
429
430 bufferCoord.X = (SHORT) (WINCONSOLE.window_only ?
431 WINCONSOLE.SBI.srWindow.Left : 0);
432 bufferCoord.Y = (SHORT) (WINCONSOLE.window_only ?
433 WINCONSOLE.SBI.srWindow.Top : 0);
434
435 if (write_screen(WINCONSOLE.hdl,
436 WINCONSOLE.save_screen,
437 WINCONSOLE.save_size,
438 bufferCoord,
439 &save_region)) {
440 result = TRUE;
441 mvcur(-1, -1, LINES - 2, 0);
442 T(("... restore original screen contents ok %dx%d (%d,%d - %d,%d)",
443 WINCONSOLE.save_size.Y,
444 WINCONSOLE.save_size.X,
445 save_region.Top,
446 save_region.Left,
447 save_region.Bottom,
448 save_region.Right));
449 } else {
450 T(("... restore original screen contents err"));
451 }
452 return result;
453 }
454
455 static bool
read_screen_data(void)456 read_screen_data(void)
457 {
458 bool result = FALSE;
459 COORD bufferCoord;
460 size_t want;
461
462 WINCONSOLE.save_size.X = (SHORT) (WINCONSOLE.save_region.Right
463 - WINCONSOLE.save_region.Left + 1);
464 WINCONSOLE.save_size.Y = (SHORT) (WINCONSOLE.save_region.Bottom
465 - WINCONSOLE.save_region.Top + 1);
466
467 want = (size_t) (WINCONSOLE.save_size.X * WINCONSOLE.save_size.Y);
468
469 if ((WINCONSOLE.save_screen = malloc(want * sizeof(CHAR_INFO))) != 0) {
470 bufferCoord.X = (SHORT) (WINCONSOLE.window_only ?
471 WINCONSOLE.SBI.srWindow.Left : 0);
472 bufferCoord.Y = (SHORT) (WINCONSOLE.window_only ?
473 WINCONSOLE.SBI.srWindow.Top : 0);
474
475 T(("... reading console %s %dx%d into %d,%d - %d,%d at %d,%d",
476 WINCONSOLE.window_only ? "window" : "buffer",
477 WINCONSOLE.save_size.Y, WINCONSOLE.save_size.X,
478 WINCONSOLE.save_region.Top,
479 WINCONSOLE.save_region.Left,
480 WINCONSOLE.save_region.Bottom,
481 WINCONSOLE.save_region.Right,
482 bufferCoord.Y,
483 bufferCoord.X));
484
485 if (read_screen(WINCONSOLE.hdl,
486 WINCONSOLE.save_screen,
487 WINCONSOLE.save_size,
488 bufferCoord,
489 &WINCONSOLE.save_region)) {
490 result = TRUE;
491 } else {
492 T((" error %#lx", (unsigned long) GetLastError()));
493 FreeAndNull(WINCONSOLE.save_screen);
494 }
495 }
496
497 return result;
498 }
499
500 NCURSES_EXPORT(bool)
_nc_console_get_SBI(void)501 _nc_console_get_SBI(void)
502 {
503 bool rc = FALSE;
504 if (GetConsoleScreenBufferInfo(WINCONSOLE.hdl, &(WINCONSOLE.SBI))) {
505 T(("GetConsoleScreenBufferInfo"));
506 T(("... buffer(X:%d Y:%d)",
507 WINCONSOLE.SBI.dwSize.X,
508 WINCONSOLE.SBI.dwSize.Y));
509 T(("... window(X:%d Y:%d)",
510 WINCONSOLE.SBI.dwMaximumWindowSize.X,
511 WINCONSOLE.SBI.dwMaximumWindowSize.Y));
512 T(("... cursor(X:%d Y:%d)",
513 WINCONSOLE.SBI.dwCursorPosition.X,
514 WINCONSOLE.SBI.dwCursorPosition.Y));
515 T(("... display(Top:%d Bottom:%d Left:%d Right:%d)",
516 WINCONSOLE.SBI.srWindow.Top,
517 WINCONSOLE.SBI.srWindow.Bottom,
518 WINCONSOLE.SBI.srWindow.Left,
519 WINCONSOLE.SBI.srWindow.Right));
520 if (WINCONSOLE.buffered) {
521 WINCONSOLE.origin.X = 0;
522 WINCONSOLE.origin.Y = 0;
523 } else {
524 WINCONSOLE.origin.X = WINCONSOLE.SBI.srWindow.Left;
525 WINCONSOLE.origin.Y = WINCONSOLE.SBI.srWindow.Top;
526 }
527 rc = TRUE;
528 } else {
529 T(("GetConsoleScreenBufferInfo ERR"));
530 }
531 return rc;
532 }
533
534 #define MIN_WIDE 80
535 #define MIN_HIGH 24
536
537 /*
538 * In "normal" mode, reset the buffer- and window-sizes back to their original values.
539 */
540 NCURSES_EXPORT(void)
_nc_console_set_scrollback(bool normal,CONSOLE_SCREEN_BUFFER_INFO * info)541 _nc_console_set_scrollback(bool normal, CONSOLE_SCREEN_BUFFER_INFO * info)
542 {
543 SMALL_RECT rect;
544 COORD coord;
545 bool changed = FALSE;
546
547 T((T_CALLED("lib_win32con::_nc_console_set_scrollback(%s)"),
548 (normal
549 ? "normal"
550 : "application")));
551
552 T(("... SBI.srWindow %d,%d .. %d,%d",
553 info->srWindow.Top,
554 info->srWindow.Left,
555 info->srWindow.Bottom,
556 info->srWindow.Right));
557 T(("... SBI.dwSize %dx%d",
558 info->dwSize.Y,
559 info->dwSize.X));
560
561 if (normal) {
562 rect = info->srWindow;
563 coord = info->dwSize;
564 if (memcmp(info, &WINCONSOLE.SBI, sizeof(*info)) != 0) {
565 changed = TRUE;
566 WINCONSOLE.SBI = *info;
567 }
568 } else {
569 int high = info->srWindow.Bottom - info->srWindow.Top + 1;
570 int wide = info->srWindow.Right - info->srWindow.Left + 1;
571
572 if (high < MIN_HIGH) {
573 T(("... height %d < %d", high, MIN_HIGH));
574 high = MIN_HIGH;
575 changed = TRUE;
576 }
577 if (wide < MIN_WIDE) {
578 T(("... width %d < %d", wide, MIN_WIDE));
579 wide = MIN_WIDE;
580 changed = TRUE;
581 }
582
583 rect.Left =
584 rect.Top = 0;
585 rect.Right = (SHORT) (wide - 1);
586 rect.Bottom = (SHORT) (high - 1);
587
588 coord.X = (SHORT) wide;
589 coord.Y = (SHORT) high;
590
591 if (info->dwSize.Y != high ||
592 info->dwSize.X != wide ||
593 info->srWindow.Top != 0 ||
594 info->srWindow.Left != 0) {
595 changed = TRUE;
596 }
597
598 }
599
600 if (changed) {
601 T(("... coord %d,%d", coord.Y, coord.X));
602 T(("... rect %d,%d - %d,%d",
603 rect.Top, rect.Left,
604 rect.Bottom, rect.Right));
605 SetConsoleScreenBufferSize(WINCONSOLE.hdl, coord); /* dwSize */
606 SetConsoleWindowInfo(WINCONSOLE.hdl, TRUE, &rect); /* srWindow */
607 _nc_console_get_SBI();
608 }
609 returnVoid;
610 }
611
612 static ULONGLONG
tdiff(FILETIME fstart,FILETIME fend)613 tdiff(FILETIME fstart, FILETIME fend)
614 {
615 ULARGE_INTEGER ustart;
616 ULARGE_INTEGER uend;
617 ULONGLONG diff;
618
619 ustart.LowPart = fstart.dwLowDateTime;
620 ustart.HighPart = fstart.dwHighDateTime;
621 uend.LowPart = fend.dwLowDateTime;
622 uend.HighPart = fend.dwHighDateTime;
623
624 diff = (uend.QuadPart - ustart.QuadPart) / 10000;
625 return diff;
626 }
627
628 static int
Adjust(int milliseconds,int diff)629 Adjust(int milliseconds, int diff)
630 {
631 if (milliseconds != INFINITY) {
632 milliseconds -= diff;
633 if (milliseconds < 0)
634 milliseconds = 0;
635 }
636 return milliseconds;
637 }
638
639 #define BUTTON_MASK (FROM_LEFT_1ST_BUTTON_PRESSED | \
640 FROM_LEFT_2ND_BUTTON_PRESSED | \
641 FROM_LEFT_3RD_BUTTON_PRESSED | \
642 FROM_LEFT_4TH_BUTTON_PRESSED | \
643 RIGHTMOST_BUTTON_PRESSED)
644
645 static int
decode_mouse(SCREEN * sp,int mask)646 decode_mouse(SCREEN *sp, int mask)
647 {
648 int result = 0;
649
650 (void) sp;
651 assert(sp && console_initialized);
652
653 if (mask & FROM_LEFT_1ST_BUTTON_PRESSED)
654 result |= BUTTON1_PRESSED;
655 if (mask & FROM_LEFT_2ND_BUTTON_PRESSED)
656 result |= BUTTON2_PRESSED;
657 if (mask & FROM_LEFT_3RD_BUTTON_PRESSED)
658 result |= BUTTON3_PRESSED;
659 if (mask & FROM_LEFT_4TH_BUTTON_PRESSED)
660 result |= BUTTON4_PRESSED;
661
662 if (mask & RIGHTMOST_BUTTON_PRESSED) {
663 switch (WINCONSOLE.numButtons) {
664 case 1:
665 result |= BUTTON1_PRESSED;
666 break;
667 case 2:
668 result |= BUTTON2_PRESSED;
669 break;
670 case 3:
671 result |= BUTTON3_PRESSED;
672 break;
673 case 4:
674 result |= BUTTON4_PRESSED;
675 break;
676 }
677 }
678
679 return result;
680 }
681
682 #define AdjustY() (WINCONSOLE.buffered ? 0 : (int) WINCONSOLE.SBI.srWindow.Top)
683
684 static bool
handle_mouse(SCREEN * sp,MOUSE_EVENT_RECORD mer)685 handle_mouse(SCREEN *sp, MOUSE_EVENT_RECORD mer)
686 {
687 MEVENT work;
688 bool result = FALSE;
689
690 assert(sp);
691
692 sp->_drv_mouse_old_buttons = sp->_drv_mouse_new_buttons;
693 sp->_drv_mouse_new_buttons = mer.dwButtonState & BUTTON_MASK;
694
695 /*
696 * We're only interested if the button is pressed or released.
697 * FIXME: implement continuous event-tracking.
698 */
699 if (sp->_drv_mouse_new_buttons != sp->_drv_mouse_old_buttons) {
700 memset(&work, 0, sizeof(work));
701
702 if (sp->_drv_mouse_new_buttons) {
703 work.bstate |=
704 (mmask_t) decode_mouse(sp,
705 sp->_drv_mouse_new_buttons);
706 } else {
707 /* cf: BUTTON_PRESSED, BUTTON_RELEASED */
708 work.bstate |=
709 (mmask_t) (decode_mouse(sp,
710 sp->_drv_mouse_old_buttons)
711 >> 1);
712 result = TRUE;
713 }
714
715 work.x = mer.dwMousePosition.X;
716 work.y = mer.dwMousePosition.Y - AdjustY();
717
718 sp->_drv_mouse_fifo[sp->_drv_mouse_tail] = work;
719 sp->_drv_mouse_tail += 1;
720 }
721 return result;
722 }
723
724 static int
rkeycompare(const void * el1,const void * el2)725 rkeycompare(const void *el1, const void *el2)
726 {
727 WORD key1 = (LOWORD((*((const LONG *) el1)))) & 0x7fff;
728 WORD key2 = (LOWORD((*((const LONG *) el2)))) & 0x7fff;
729
730 return ((key1 < key2) ? -1 : ((key1 == key2) ? 0 : 1));
731 }
732
733
734 static int
keycompare(const void * el1,const void * el2)735 keycompare(const void *el1, const void *el2)
736 {
737 WORD key1 = HIWORD((*((const LONG *) el1)));
738 WORD key2 = HIWORD((*((const LONG *) el2)));
739
740 return ((key1 < key2) ? -1 : ((key1 == key2) ? 0 : 1));
741 }
742
743 static int
MapKey(WORD vKey)744 MapKey(WORD vKey)
745 {
746 int code = -1;
747
748 if (!WINCONSOLE.isTermInfoConsole) {
749 WORD nKey = 0;
750 void *res;
751 LONG key = GenMap(vKey, 0);
752
753 res = bsearch(&key,
754 WINCONSOLE.map,
755 (size_t) (N_INI + FKEYS),
756 sizeof(keylist[0]),
757 keycompare);
758 if (res) {
759 key = *((LONG *) res);
760 nKey = LOWORD(key);
761 code = (int) (nKey & 0x7fff);
762 if (nKey & 0x8000)
763 code = -code;
764 }
765 }
766 return code;
767 }
768
769 static int
AnsiKey(WORD vKey)770 AnsiKey(WORD vKey)
771 {
772 int code = -1;
773
774 if (!WINCONSOLE.isTermInfoConsole) {
775 WORD nKey = 0;
776 void *res;
777 LONG key = GenMap(vKey, 0);
778
779 res = bsearch(&key,
780 WINCONSOLE.ansi_map,
781 (size_t) (N_INI + FKEYS),
782 sizeof(keylist[0]),
783 keycompare);
784 if (res) {
785 key = *((LONG *) res);
786 nKey = LOWORD(key);
787 code = (int) (nKey & 0x7fff);
788 if (nKey & 0x8000)
789 code = -code;
790 }
791 }
792 return code;
793 }
794
795 NCURSES_EXPORT(int)
_nc_console_keyok(int keycode,int flag)796 _nc_console_keyok(int keycode, int flag)
797 {
798 int code = ERR;
799 WORD nKey;
800 WORD vKey;
801 void *res;
802 LONG key = GenMap(0, (WORD) keycode);
803
804 T((T_CALLED("lib_win32con::_nc_console_keyok(%d, %d)"), keycode, flag));
805
806 res = bsearch(&key,
807 WINCONSOLE.rmap,
808 (size_t) (N_INI + FKEYS),
809 sizeof(keylist[0]),
810 rkeycompare);
811 if (res) {
812 key = *((LONG *) res);
813 vKey = HIWORD(key);
814 nKey = (LOWORD(key)) & 0x7fff;
815 if (!flag)
816 nKey |= 0x8000;
817 *(LONG *) res = GenMap(vKey, nKey);
818 }
819 returnCode(code);
820 }
821
822 NCURSES_EXPORT(bool)
_nc_console_keyExist(int keycode)823 _nc_console_keyExist(int keycode)
824 {
825 WORD nKey;
826 void *res;
827 bool found = FALSE;
828 LONG key = GenMap(0, (WORD) keycode);
829
830 T((T_CALLED("lib_win32con::_nc_console_keyExist(%d)"), keycode));
831 res = bsearch(&key,
832 WINCONSOLE.rmap,
833 (size_t) (N_INI + FKEYS),
834 sizeof(keylist[0]),
835 rkeycompare);
836 if (res) {
837 key = *((LONG *) res);
838 nKey = LOWORD(key);
839 if (!(nKey & 0x8000))
840 found = TRUE;
841 }
842 returnCode(found);
843 }
844
845 NCURSES_EXPORT(int)
_nc_console_twait(SCREEN * sp,HANDLE hdl,int mode,int milliseconds,int * timeleft EVENTLIST_2nd (_nc_eventlist * evl))846 _nc_console_twait(
847 SCREEN *sp,
848 HANDLE hdl,
849 int mode,
850 int milliseconds,
851 int *timeleft
852 EVENTLIST_2nd(_nc_eventlist * evl))
853 {
854 INPUT_RECORD inp_rec;
855 BOOL b;
856 DWORD nRead = 0, rc = (DWORD) (-1);
857 int code = 0;
858 FILETIME fstart;
859 FILETIME fend;
860 int diff;
861 bool isNoDelay = (milliseconds == 0);
862
863 #ifdef NCURSES_WGETCH_EVENTS
864 (void) evl; /* TODO: implement wgetch-events */
865 #endif
866
867 #define IGNORE_CTRL_KEYS (SHIFT_PRESSED|LEFT_ALT_PRESSED|RIGHT_ALT_PRESSED| \
868 LEFT_CTRL_PRESSED|RIGHT_CTRL_PRESSED)
869 #define CONSUME() ReadConsoleInput(hdl, &inp_rec, 1, &nRead)
870
871 assert(sp);
872
873 TR(TRACE_IEVENT, ("start twait: hdl=%p, %d milliseconds, mode: %d",
874 hdl, milliseconds, mode));
875
876 if (milliseconds < 0)
877 milliseconds = INFINITY;
878
879 memset(&inp_rec, 0, sizeof(inp_rec));
880
881 while (true) {
882 if (!isNoDelay) {
883 GetSystemTimeAsFileTime(&fstart);
884 rc = WaitForSingleObject(hdl, (DWORD) milliseconds);
885 GetSystemTimeAsFileTime(&fend);
886 diff = (int) tdiff(fstart, fend);
887 milliseconds = Adjust(milliseconds, diff);
888 if (milliseconds< 0)
889 break;
890 }
891
892 if (isNoDelay || (rc == WAIT_OBJECT_0)) {
893 if (mode) {
894 nRead = 0;
895 b = GetNumberOfConsoleInputEvents(hdl, &nRead);
896 if (!b) {
897 T(("twait:err GetNumberOfConsoleInputEvents"));
898 }
899 if (isNoDelay && b) {
900 T(("twait: Events Available: %ld", nRead));
901 if (nRead==0) {
902 code = 0;
903 goto end;
904 } else {
905 DWORD n = 0;
906 INPUT_RECORD* pInpRec =
907 TypeAlloca(INPUT_RECORD, nRead);
908 if (pInpRec != NULL) {
909 DWORD i;
910 BOOL f;
911 memset(pInpRec, 0, sizeof(INPUT_RECORD)*nRead);
912 f = PeekConsoleInput(hdl, pInpRec, nRead, &n);
913 if (f) {
914 for(i = 0; i < n; i++) {
915 if (pInpRec[i].EventType==KEY_EVENT) {
916 if(pInpRec[i].Event.KeyEvent.bKeyDown) {
917 DWORD ctrlMask =
918 (pInpRec[i].Event.KeyEvent.dwControlKeyState &
919 IGNORE_CTRL_KEYS);
920 if (!ctrlMask) {
921 code = TW_INPUT;
922 goto end;
923 }
924 }
925 }
926 }
927 } else {
928 T(("twait:err PeekConsoleInput"));
929 }
930 code = 0;
931 goto end;
932 } else {
933 T(("twait:err could not alloca input records"));
934 }
935 }
936 }
937 if (b && nRead > 0) {
938 b = PeekConsoleInput(hdl, &inp_rec, 1, &nRead);
939 if (!b) {
940 T(("twait:err PeekConsoleInput"));
941 }
942 if (b && nRead > 0) {
943 switch (inp_rec.EventType) {
944 case KEY_EVENT:
945 if (mode & TW_INPUT) {
946 WORD vk =
947 inp_rec.Event.KeyEvent.wVirtualKeyCode;
948 char ch =
949 inp_rec.Event.KeyEvent.uChar.AsciiChar;
950 T(("twait:event KEY_EVENT"));
951 T(("twait vk=%d, ch=%d, keydown=%d",
952 vk, ch, inp_rec.Event.KeyEvent.bKeyDown));
953 if (inp_rec.Event.KeyEvent.bKeyDown) {
954 T(("twait:event KeyDown"));
955 if (!WINCONSOLE.isTermInfoConsole &&
956 (0 == ch)) {
957 int nKey = MapKey(vk);
958 if (nKey < 0) {
959 CONSUME();
960 continue;
961 }
962 }
963 code = TW_INPUT;
964 goto end;
965 } else {
966 CONSUME();
967 }
968 }
969 continue;
970 case MOUSE_EVENT:
971 T(("twait:event MOUSE_EVENT"));
972 if (decode_mouse(sp,
973 (inp_rec.Event.MouseEvent.dwButtonState
974 & BUTTON_MASK)) == 0) {
975 CONSUME();
976 } else if (mode & TW_MOUSE) {
977 code = TW_MOUSE;
978 goto end;
979 }
980 continue;
981 /* e.g., FOCUS_EVENT */
982 default:
983 T(("twait:event Tyoe %d", inp_rec.EventType));
984 CONSUME();
985 _nc_console_selectActiveHandle();
986 continue;
987 }
988 }
989 }
990 }
991 continue;
992 } else {
993 if (rc != WAIT_TIMEOUT) {
994 code = -1;
995 break;
996 } else {
997 code = 0;
998 break;
999 }
1000 }
1001 }
1002 end:
1003
1004 TR(TRACE_IEVENT, ("end twait: returned %d (%lu), remaining time %d msec",
1005 code, GetLastError(), milliseconds));
1006
1007 if (timeleft)
1008 *timeleft = milliseconds;
1009
1010 return code;
1011 }
1012
1013 NCURSES_EXPORT(int)
_nc_console_testmouse(SCREEN * sp,HANDLE hdl,int delay EVENTLIST_2nd (_nc_eventlist * evl))1014 _nc_console_testmouse(
1015 SCREEN *sp,
1016 HANDLE hdl,
1017 int delay
1018 EVENTLIST_2nd(_nc_eventlist * evl))
1019 {
1020 int rc = 0;
1021
1022 assert(sp);
1023
1024 if (sp->_drv_mouse_head < sp->_drv_mouse_tail) {
1025 rc = TW_MOUSE;
1026 } else {
1027 rc = _nc_console_twait(sp,
1028 hdl,
1029 TWAIT_MASK,
1030 delay,
1031 (int *) 0
1032 EVENTLIST_2nd(evl));
1033 }
1034 return rc;
1035 }
1036
1037 NCURSES_EXPORT(int)
_nc_console_read(SCREEN * sp,HANDLE hdl,int * buf)1038 _nc_console_read(
1039 SCREEN *sp,
1040 HANDLE hdl,
1041 int *buf)
1042 {
1043 int rc = -1;
1044 INPUT_RECORD inp_rec;
1045 BOOL b;
1046 DWORD nRead;
1047 WORD vk;
1048
1049 assert(sp);
1050 assert(buf);
1051
1052 memset(&inp_rec, 0, sizeof(inp_rec));
1053
1054 T((T_CALLED("lib_win32con::_nc_console_read(%p)"), sp));
1055
1056 while ((b = ReadConsoleInput(hdl, &inp_rec, 1, &nRead))) {
1057 if (b && nRead > 0) {
1058 if (rc < 0)
1059 rc = 0;
1060 rc = rc + (int) nRead;
1061 if (inp_rec.EventType == KEY_EVENT) {
1062 if (!inp_rec.Event.KeyEvent.bKeyDown)
1063 continue;
1064 *buf = (int) inp_rec.Event.KeyEvent.uChar.AsciiChar;
1065 vk = inp_rec.Event.KeyEvent.wVirtualKeyCode;
1066 /*
1067 * There are 24 virtual function-keys, and typically
1068 * 12 function-keys on a keyboard. Use the shift-modifier
1069 * to provide the remaining 12 keys.
1070 */
1071 if (vk >= VK_F1 && vk <= VK_F12) {
1072 if (inp_rec.Event.KeyEvent.dwControlKeyState &
1073 SHIFT_PRESSED) {
1074 vk = (WORD) (vk + 12);
1075 }
1076 }
1077 if (*buf == 0) {
1078 int key = MapKey(vk);
1079 if (key < 0)
1080 continue;
1081 if (sp->_keypad_on) {
1082 *buf = key;
1083 } else {
1084 ungetch('\0');
1085 *buf = AnsiKey(vk);
1086 }
1087 }
1088 break;
1089 } else if (inp_rec.EventType == MOUSE_EVENT) {
1090 if (handle_mouse(sp,
1091 inp_rec.Event.MouseEvent)) {
1092 *buf = KEY_MOUSE;
1093 break;
1094 }
1095 }
1096 continue;
1097 }
1098 }
1099 returnCode(rc);
1100 }
1101
1102 /* Our replacement for the systems _isatty to include also
1103 a test for mintty. This is called from the NC_ISATTY macro
1104 defined in curses.priv.h
1105
1106 Return codes:
1107 - 0 : Not a TTY
1108 - 1 : A Windows character device detected by _isatty
1109 - 2 : A future implementation may return 2 for mintty
1110 */
1111 NCURSES_EXPORT(int)
_nc_console_isatty(int fd)1112 _nc_console_isatty(int fd)
1113 {
1114 int result = 0;
1115 T((T_CALLED("lib_win32con::_nc_console_isatty(%d"), fd));
1116
1117 if (_isatty(fd))
1118 result = 1;
1119 #ifdef _NC_CHECK_MINTTY
1120 else {
1121 if (_nc_console_checkmintty(fd, NULL)) {
1122 result = 2;
1123 fprintf(stderr, "ncurses on Windows must run in a Windows console.\n");
1124 fprintf(stderr, "On newer versions of Windows, the calling program should create a PTY-like.\n");
1125 fprintf(stderr, "device using the CreatePseudoConsole Windows API call.\n");
1126 exit(EXIT_FAILURE);
1127 }
1128 }
1129 #endif
1130 returnCode(result);
1131 }
1132
1133 NCURSES_EXPORT(bool)
_nc_console_checkinit(bool initFlag,bool assumeTermInfo)1134 _nc_console_checkinit(bool initFlag, bool assumeTermInfo)
1135 {
1136 bool res = FALSE;
1137
1138 T((T_CALLED("lib_win32con::_nc_console_checkinit(initFlag=%d, assumeTermInfo=%d)"),
1139 initFlag, assumeTermInfo));
1140
1141 if (!initFlag) {
1142 res = console_initialized;
1143 } else {
1144 /* initialize once, or not at all */
1145 if (!console_initialized) {
1146 int i;
1147 DWORD num_buttons;
1148 WORD a;
1149 BOOL buffered = FALSE;
1150 BOOL b;
1151
1152 START_TRACE();
1153 WINCONSOLE.isTermInfoConsole = assumeTermInfo;
1154
1155 WINCONSOLE.map = (LPDWORD)malloc(sizeof(DWORD)*MAPSIZE);
1156 WINCONSOLE.rmap = (LPDWORD)malloc(sizeof(DWORD)*MAPSIZE);
1157 WINCONSOLE.ansi_map = (LPDWORD)malloc(sizeof(DWORD)*MAPSIZE);
1158
1159 for (i = 0; i < (N_INI + FKEYS); i++) {
1160 if (i < N_INI) {
1161 WINCONSOLE.rmap[i] = WINCONSOLE.map[i] =
1162 (DWORD) keylist[i];
1163 WINCONSOLE.ansi_map[i] = (DWORD) ansi_keys[i];
1164 } else {
1165 WINCONSOLE.rmap[i] = WINCONSOLE.map[i] =
1166 (DWORD) GenMap((VK_F1 + (i - N_INI)),
1167 (KEY_F(1) + (i - N_INI)));
1168 WINCONSOLE.ansi_map[i] =
1169 (DWORD) GenMap((VK_F1 + (i - N_INI)),
1170 (';' + (i - N_INI)));
1171 }
1172 }
1173 qsort(WINCONSOLE.ansi_map,
1174 (size_t) (MAPSIZE),
1175 sizeof(keylist[0]),
1176 keycompare);
1177 qsort(WINCONSOLE.map,
1178 (size_t) (MAPSIZE),
1179 sizeof(keylist[0]),
1180 keycompare);
1181 qsort(WINCONSOLE.rmap,
1182 (size_t) (MAPSIZE),
1183 sizeof(keylist[0]),
1184 rkeycompare);
1185
1186 if (GetNumberOfConsoleMouseButtons(&num_buttons)) {
1187 WINCONSOLE.numButtons = (int) num_buttons;
1188 } else {
1189 WINCONSOLE.numButtons = 1;
1190 }
1191
1192 a = _nc_console_MapColor(true, COLOR_WHITE) |
1193 _nc_console_MapColor(false, COLOR_BLACK);
1194 for (i = 0; i < CON_NUMPAIRS; i++)
1195 WINCONSOLE.pairs[i] = a;
1196
1197 WINCONSOLE.inp = GetStdHandle(STD_INPUT_HANDLE);
1198 WINCONSOLE.out = GetStdHandle(STD_OUTPUT_HANDLE);
1199 WINCONSOLE.hdl = WINCONSOLE.out;
1200
1201 GetConsoleMode(WINCONSOLE.inp, &WINCONSOLE.originalMode.dwFlagIn);
1202 GetConsoleMode(WINCONSOLE.out, &WINCONSOLE.originalMode.dwFlagOut);
1203
1204 if (!WINCONSOLE.isTermInfoConsole) {
1205 b = AllocConsole();
1206
1207 if (!b)
1208 b = AttachConsole(ATTACH_PARENT_PROCESS);
1209
1210 if (getenv("NCGDB") || getenv("NCURSES_CONSOLE2")) {
1211 T(("... will not buffer console"));
1212 } else {
1213 T(("... creating console buffer"));
1214 WINCONSOLE.hdl =
1215 CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
1216 0,
1217 NULL,
1218 CONSOLE_TEXTMODE_BUFFER,
1219 NULL);
1220 buffered = TRUE;
1221 }
1222 }
1223
1224 /* We set binary I/O even when using the console
1225 driver to cover the situation, that the
1226 TERM variable is set to #win32con, but actually
1227 Windows supports virtual terminal processing.
1228 So if terminfo functions are used in this setup,
1229 they actually may work.
1230 */
1231 _setmode(fileno(stdin), _O_BINARY);
1232 _setmode(fileno(stdout), _O_BINARY);
1233
1234 if (WINCONSOLE.hdl != INVALID_HANDLE_VALUE) {
1235 WINCONSOLE.buffered = buffered;
1236 _nc_console_get_SBI();
1237 WINCONSOLE.save_SBI = WINCONSOLE.SBI;
1238 if (!buffered) {
1239 save_original_screen();
1240 _nc_console_set_scrollback(FALSE, &WINCONSOLE.SBI);
1241 }
1242 GetConsoleCursorInfo(WINCONSOLE.hdl, &WINCONSOLE.save_CI);
1243 T(("... initial cursor is %svisible, %d%%",
1244 (WINCONSOLE.save_CI.bVisible ? "" : "not-"),
1245 (int) WINCONSOLE.save_CI.dwSize));
1246 }
1247
1248 WINCONSOLE.initialized = TRUE;
1249 console_initialized = TRUE;
1250 }
1251 res = (WINCONSOLE.hdl != INVALID_HANDLE_VALUE);
1252 }
1253 returnBool(res);
1254 }
1255
1256 #endif // _NC_WINDOWS
1257