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