C-Menu 0.2.9
A User Interface Toolkit
Loading...
Searching...
No Matches
curskeys.c
Go to the documentation of this file.
1/** @file curskeys.c
2 @brief Test Curses Keys
3 @author Bill Waller
4 Copyright (c) 2025
5 MIT License
6 billxwaller@gmail.com
7 @date 2026-02-09
8 */
9
10#include "common.h"
11#include "ui_backend.h"
12#include <unistd.h>
13
14#define KSTRLEN 100
15#define MAXLEN 256
16int popup_ckeys();
17
18/** @brief Display Curses Keys
19 Responds to curses keys and mouse events, displaying the key code and
20 description.
21 @return 0 on success, non-zero on failure
22 */
23#ifdef UAL_UI
24#include "ui_ncurses_internal.h"
25int ncurses_input(UiSurface *s, uint w);
26#else
27#include "ui_notcurses_internal.h"
28int notcurses_input(UiSurface *s, uint w);
29#endif
30
31int popup_ckeys() {
32 char Title[] = "TEST CURSES KEYS";
33 unsigned lines = 10;
34 unsigned cols = 55;
35 char tmp[MAXLEN];
36 uint maxy, maxx;
37 ui_get_screen_size(&maxy, &maxx);
38 uint begy = (maxy - lines) / 3;
39 uint begx = (maxx - cols) / 2;
40 if (surface_box_win_new(lines, cols, begy, begx, Title)) {
41 strnz__cpy(tmp, "surface_box_win_new failed: ", MAXLEN - 1);
42 strnz__cat(tmp, Title, MAXLEN - 1);
43 Perror(tmp);
44 exit(EXIT_FAILURE);
45 }
46 UiSurface *sfc = ui_surface[sfc_ptr];
47 ui_keypad(sfc, WIN, true);
48 ui_bkgdset(sfc, WIN, &cell_nt_rev);
49 ui_mvwaddstr(sfc, WIN, lines - 1, 0, " <ALT>END to exit ");
50 ui_bkgdset(sfc, WIN, &cell_nt);
51 ui_mvwaddstr(sfc, WIN, 1, 4, "Press a key or activate the mouse:");
52#ifdef UAL_UI
53 ncurses_input(sfc, WIN);
54#else
55 notcurses_input(sfc, WIN);
56#endif
57 ui_surface_destroy(sfc);
58 return 0;
59}
60
61#ifdef UAL_UI
62int ncurses_input(UiSurface *sfc, uint w) {
63 char kstr[KSTRLEN];
64 int c;
65 char action[MAXLEN];
66 c = '\0';
67 char tmp[MAXLEN];
68 UiEvent ev;
69 while (!c) {
70 kstr[0] = '\0';
71 ui_cursor_move(sfc, WIN, 1, 39);
72 do {
73 ui_render();
74 c = ui_get_event(sfc, WIN, &ev, -1);
75 if (sig_received != 0) {
76 if (handle_signal(sig_received))
77 c = display_error(em0, em1, em2, NULL);
78 if (c == 'q' || c == KEY_F(9))
79 exit(EXIT_FAILURE);
80 continue;
81 }
82 } while (c == ERR);
83 switch (c) {
84 case '\0':
85 break;
86 case KEY_CODE_YES:
87 strnz__cpy(kstr, "KEY_CODE_YES A wchar_t contains a key code",
88 KSTRLEN - 1);
89 break;
90 case KEY_BREAK:
91 strnz__cpy(kstr, "KEY_BREAK Break key(unreliable)", KSTRLEN - 1);
92 break;
93 case KEY_DOWN:
94 strnz__cpy(kstr, "KEY_DOWN down - arrow key", KSTRLEN - 1);
95 break;
96 case KEY_UP:
97 strnz__cpy(kstr, "KEY_UP up - arrow key", KSTRLEN - 1);
98 break;
99 case KEY_LEFT:
100 strnz__cpy(kstr, "KEY_LEFT left - arrow key", KSTRLEN - 1);
101 break;
102 case KEY_RIGHT:
103 strnz__cpy(kstr, "KEY_RIGHT right - arrow key", KSTRLEN - 1);
104 break;
105 case KEY_HOME:
106 strnz__cpy(kstr, "KEY_HOME home key", KSTRLEN - 1);
107 break;
108 case KEY_BACKSPACE:
109 strnz__cpy(kstr, "KEY_BACKSPACE backspace key", KSTRLEN - 1);
110 break;
111 case KEY_F(1):
112 strnz__cpy(kstr, "KEY_F(1) KEY_F(1)", KSTRLEN - 1);
113 break;
114 case KEY_F(2):
115 strnz__cpy(kstr, "KEY_F2 KEY_F2", KSTRLEN - 1);
116 break;
117 case KEY_F(3):
118 strnz__cpy(kstr, "KEY_F3 KEY_F3", KSTRLEN - 1);
119 break;
120 case KEY_F(4):
121 strnz__cpy(kstr, "KEY_F4 KEY_F4", KSTRLEN - 1);
122 break;
123 case KEY_F(5):
124 strnz__cpy(kstr, "KEY_F5 KEY_F5", KSTRLEN - 1);
125 break;
126 case KEY_F(6):
127 strnz__cpy(kstr, "KEY_F6 KEY_F6", KSTRLEN - 1);
128 break;
129 case KEY_F(7):
130 strnz__cpy(kstr, "KEY_F7 KEY_F7", KSTRLEN - 1);
131 break;
132 case KEY_F(8):
133 strnz__cpy(kstr, "KEY_F8 KEY_F8", KSTRLEN - 1);
134 break;
135 case KEY_F(9):
136 strnz__cpy(kstr, "KEY_F9 KEY_F9", KSTRLEN - 1);
137 break;
138 case KEY_F(10):
139 strnz__cpy(kstr, "KEY_F10 KEY_F10", KSTRLEN - 1);
140 break;
141 case KEY_F(11):
142 strnz__cpy(kstr, "KEY_F11 KEY_F11", KSTRLEN - 1);
143 break;
144 case KEY_F(12):
145 strnz__cpy(kstr, "KEY_F12 KEY_F12", KSTRLEN - 1);
146 break;
147 case KEY_DL:
148 strnz__cpy(kstr, "KEY_DL delete - line key", KSTRLEN - 1);
149 break;
150 case KEY_IL:
151 strnz__cpy(kstr, "KEY_IL insert - line key", KSTRLEN - 1);
152 break;
153 case KEY_DC:
154 strnz__cpy(kstr, "KEY_DC delete - character key", KSTRLEN - 1);
155 break;
156 case KEY_IC:
157 strnz__cpy(kstr, "KEY_IC insert - character key", KSTRLEN - 1);
158 break;
159 case KEY_EIC:
160 strnz__cpy(kstr, "KEY_EIC sent by rmir or smir in insert mode",
161 KSTRLEN - 1);
162 break;
163 case KEY_CLEAR:
164 strnz__cpy(kstr, "KEY_CLEAR clear - screen or erase key",
165 KSTRLEN - 1);
166 break;
167 case KEY_EOS:
168 strnz__cpy(kstr, "KEY_EOS clear - to - end - of - screen key",
169 KSTRLEN - 1);
170 break;
171 case KEY_EOL:
172 strnz__cpy(kstr, "KEY_EOL clear - to - end - of - line key",
173 KSTRLEN - 1);
174 break;
175 case KEY_SF:
176 strnz__cpy(kstr, "KEY_SF scroll - forward key", KSTRLEN - 1);
177 break;
178 case KEY_SR:
179 strnz__cpy(kstr, "KEY_SR scroll - backward key", KSTRLEN - 1);
180 break;
181 case KEY_NPAGE:
182 strnz__cpy(kstr, "KEY_NPAGE next - page key", KSTRLEN - 1);
183 break;
184 case KEY_PPAGE:
185 strnz__cpy(kstr, "KEY_PPAGE previous - page key", KSTRLEN - 1);
186 break;
187 case KEY_STAB:
188 strnz__cpy(kstr, "KEY_STAB set - tab key", KSTRLEN - 1);
189 break;
190 case KEY_CTAB:
191 strnz__cpy(kstr, "KEY_CTAB clear - tab key", KSTRLEN - 1);
192 break;
193 case KEY_CATAB:
194 strnz__cpy(kstr, "KEY_CATAB clear - all - tabs key", KSTRLEN - 1);
195 break;
196 case '\n':
197 strnz__cpy(kstr, "KEY_ENTER newline key", KSTRLEN - 1);
198 break;
199 case KEY_ENTER:
200 strnz__cpy(kstr, "KEY_ENTER enter / send key", KSTRLEN - 1);
201 break;
202 case KEY_SRESET:
203 strnz__cpy(kstr, "KEY_SRESET Soft(partial) reset(unreliable)",
204 KSTRLEN - 1);
205 break;
206 case KEY_RESET:
207 strnz__cpy(kstr, "KEY_RESET Reset or hard reset(unreliable)",
208 KSTRLEN - 1);
209 break;
210 case KEY_PRINT:
211 strnz__cpy(kstr, "KEY_PRINT print key", KSTRLEN - 1);
212 break;
213 case KEY_LL:
214 strnz__cpy(kstr, "KEY_LL lower - left key(home down)", KSTRLEN - 1);
215 break;
216 case KEY_A1:
217 strnz__cpy(kstr, "KEY_A1 upper left of keypad", KSTRLEN - 1);
218 break;
219 case KEY_A3:
220 strnz__cpy(kstr, "KEY_A3 upper right of keypad", KSTRLEN - 1);
221 break;
222 case KEY_B2:
223 strnz__cpy(kstr, "KEY_B2 center of keypad", KSTRLEN - 1);
224 break;
225 case KEY_C1:
226 strnz__cpy(kstr, "KEY_C1 lower left of keypad", KSTRLEN - 1);
227 break;
228 case KEY_C3:
229 strnz__cpy(kstr, "KEY_C3 lower right of keypad", KSTRLEN - 1);
230 break;
231 case KEY_BTAB:
232 strnz__cpy(kstr, "KEY_BTAB back - tab key", KSTRLEN - 1);
233 break;
234 case KEY_BEG:
235 strnz__cpy(kstr, "KEY_BEG begin key", KSTRLEN - 1);
236 break;
237 case KEY_CANCEL:
238 strnz__cpy(kstr, "KEY_CANCEL cancel key", KSTRLEN - 1);
239 break;
240 case KEY_CLOSE:
241 strnz__cpy(kstr, "KEY_CLOSE close key", KSTRLEN - 1);
242 break;
243 case KEY_COMMAND:
244 strnz__cpy(kstr, "KEY_COMMAND command key", KSTRLEN - 1);
245 break;
246 case KEY_COPY:
247 strnz__cpy(kstr, "KEY_COPY copy key", KSTRLEN - 1);
248 break;
249 case KEY_CREATE:
250 strnz__cpy(kstr, "KEY_CREATE create key", KSTRLEN - 1);
251 break;
252 case KEY_END:
253 strnz__cpy(kstr, "KEY_END end key", KSTRLEN - 1);
254 break;
255 case KEY_EXIT:
256 strnz__cpy(kstr, "KEY_EXIT exit key", KSTRLEN - 1);
257 break;
258 case KEY_FIND:
259 strnz__cpy(kstr, "KEY_FIND find key", KSTRLEN - 1);
260 break;
261 case KEY_HELP:
262 strnz__cpy(kstr, "KEY_HELP help key", KSTRLEN - 1);
263 break;
264 case KEY_MARK:
265 strnz__cpy(kstr, "KEY_MARK mark key", KSTRLEN - 1);
266 break;
267 case KEY_MESSAGE:
268 strnz__cpy(kstr, "KEY_MESSAGE message key", KSTRLEN - 1);
269 break;
270 case KEY_MOVE:
271 strnz__cpy(kstr, "KEY_MOVE move key", KSTRLEN - 1);
272 break;
273 case KEY_NEXT:
274 strnz__cpy(kstr, "KEY_NEXT next key", KSTRLEN - 1);
275 break;
276 case KEY_OPEN:
277 strnz__cpy(kstr, "KEY_OPEN open key", KSTRLEN - 1);
278 break;
279 case KEY_OPTIONS:
280 strnz__cpy(kstr, "KEY_OPTIONS options key", KSTRLEN - 1);
281 break;
282 case KEY_PREVIOUS:
283 strnz__cpy(kstr, "KEY_PREVIOUS previous key", KSTRLEN - 1);
284 break;
285 case KEY_REDO:
286 strnz__cpy(kstr, "KEY_REDO redo key", KSTRLEN - 1);
287 break;
288 case KEY_REFERENCE:
289 strnz__cpy(kstr, "KEY_REFERENCE reference key", KSTRLEN - 1);
290 break;
291 case KEY_REFRESH:
292 strnz__cpy(kstr, "KEY_REFRESH refresh key", KSTRLEN - 1);
293 break;
294 case KEY_REPLACE:
295 strnz__cpy(kstr, "KEY_REPLACE replace key", KSTRLEN - 1);
296 break;
297 case KEY_RESTART:
298 strnz__cpy(kstr, "KEY_RESTART restart key", KSTRLEN - 1);
299 break;
300 case KEY_RESUME:
301 strnz__cpy(kstr, "KEY_RESUME resume key", KSTRLEN - 1);
302 break;
303 case KEY_SAVE:
304 strnz__cpy(kstr, "KEY_SAVE save key", KSTRLEN - 1);
305 break;
306 case KEY_SBEG:
307 strnz__cpy(kstr, "KEY_SBEG shifted begin key", KSTRLEN - 1);
308 break;
309 case KEY_SCANCEL:
310 strnz__cpy(kstr, "KEY_SCANCEL shifted cancel key", KSTRLEN - 1);
311 break;
312 case KEY_SCOMMAND:
313 strnz__cpy(kstr, "KEY_SCOMMAND shifted command key", KSTRLEN - 1);
314 break;
315 case KEY_SCOPY:
316 strnz__cpy(kstr, "KEY_SCOPY shifted copy key", KSTRLEN - 1);
317 break;
318 case KEY_SCREATE:
319 strnz__cpy(kstr, "KEY_SCREATE shifted create key", KSTRLEN - 1);
320 break;
321 case KEY_SDC:
322 strnz__cpy(kstr, "KEY_SDC shifted delete - character key",
323 KSTRLEN - 1);
324 break;
325 case KEY_SDL:
326 strnz__cpy(kstr, "KEY_SDL shifted delete - line key", KSTRLEN - 1);
327 break;
328 case KEY_SELECT:
329 strnz__cpy(kstr, "KEY_SELECT select key", KSTRLEN - 1);
330 break;
331 case KEY_SEND:
332 strnz__cpy(kstr, "KEY_SEND shifted end key", KSTRLEN - 1);
333 break;
334 case KEY_SEOL:
335 strnz__cpy(kstr,
336 "KEY_SEOL shifted clear - to - end - of - line key",
337 KSTRLEN - 1);
338 break;
339 case KEY_SEXIT:
340 strnz__cpy(kstr, "KEY_SEXIT shifted exit key", KSTRLEN - 1);
341 break;
342 case KEY_SFIND:
343 strnz__cpy(kstr, "KEY_SFIND shifted find key", KSTRLEN - 1);
344 break;
345 case KEY_SHELP:
346 strnz__cpy(kstr, "KEY_SHELP shifted help key", KSTRLEN - 1);
347 break;
348 case KEY_SHOME:
349 strnz__cpy(kstr, "KEY_SHOME shifted home key", KSTRLEN - 1);
350 break;
351 case KEY_SIC:
352 strnz__cpy(kstr, "KEY_SIC shifted insert - character key",
353 KSTRLEN - 1);
354 break;
355 case KEY_SLEFT:
356 strnz__cpy(kstr, "KEY_SLEFT shifted left - arrow key", KSTRLEN - 1);
357 break;
358 case KEY_SMESSAGE:
359 strnz__cpy(kstr, "KEY_SMESSAGE shifted message key", KSTRLEN - 1);
360 break;
361 case KEY_SMOVE:
362 strnz__cpy(kstr, "KEY_SMOVE shifted move key", KSTRLEN - 1);
363 break;
364 case KEY_SNEXT:
365 strnz__cpy(kstr, "KEY_SNEXT shifted next key", KSTRLEN - 1);
366 break;
367 case KEY_SOPTIONS:
368 strnz__cpy(kstr, "KEY_SOPTIONS shifted options key", KSTRLEN - 1);
369 break;
370 case KEY_SPREVIOUS:
371 strnz__cpy(kstr, "KEY_SPREVIOUS shifted previous key", KSTRLEN - 1);
372 break;
373 case KEY_SPRINT:
374 strnz__cpy(kstr, "KEY_SPRINT shifted print key", KSTRLEN - 1);
375 break;
376 case KEY_SREDO:
377 strnz__cpy(kstr, "KEY_SREDO shifted redo key", KSTRLEN - 1);
378 break;
379 case KEY_SREPLACE:
380 strnz__cpy(kstr, "KEY_SREPLACE shifted replace key", KSTRLEN - 1);
381 break;
382 case KEY_SRIGHT:
383 strnz__cpy(kstr, "KEY_SRIGHT shifted right - arrow key",
384 KSTRLEN - 1);
385 break;
386 case KEY_SRSUME:
387 strnz__cpy(kstr, "KEY_SRSUME shifted resume key", KSTRLEN - 1);
388 break;
389 case KEY_SSAVE:
390 strnz__cpy(kstr, "KEY_SSAVE shifted save key", KSTRLEN - 1);
391 break;
392 case KEY_SSUSPEND:
393 strnz__cpy(kstr, "KEY_SSUSPEND shifted suspend key", KSTRLEN - 1);
394 break;
395 case KEY_SUNDO:
396 strnz__cpy(kstr, "KEY_SUNDO shifted undo key", KSTRLEN - 1);
397 break;
398 case KEY_SUSPEND:
399 strnz__cpy(kstr, "KEY_SUSPEND suspend key", KSTRLEN - 1);
400 break;
401 case KEY_UNDO:
402 strnz__cpy(kstr, "KEY_UNDO undo key", KSTRLEN - 1);
403 break;
404 case KEY_ALTDEL:
405 strnz__cpy(kstr, "KEY_ALTDEL alt+delete", KSTRLEN - 1);
406 break;
407 case KEY_ALTDOWN:
408 strnz__cpy(kstr, "KEY_ALTDOWN alt+down", KSTRLEN - 1);
409 break;
410 case KEY_ALTEND:
411 strnz__cpy(kstr, "KEY_ALTEND alt+end", KSTRLEN - 1);
412 break;
413 case KEY_ALTHOME:
414 strnz__cpy(kstr, "KEY_ALTHOME alt+home", KSTRLEN - 1);
415 break;
416 case KEY_ALTINS:
417 strnz__cpy(kstr, "KEY_ALTINS alt+ins", KSTRLEN - 1);
418 break;
419 case KEY_ALTLEFT:
420 strnz__cpy(kstr, "KEY_ALTLEFT alt+left", KSTRLEN - 1);
421 break;
422 case KEY_ALTPGDN:
423 strnz__cpy(kstr, "KEY_ALTPGDN alt+pgdn", KSTRLEN - 1);
424 break;
425 case KEY_ALTPGUP:
426 strnz__cpy(kstr, "KEY_ALTPGUP alt+pgup", KSTRLEN - 1);
427 break;
428 case KEY_ALTRIGHT:
429 strnz__cpy(kstr, "KEY_ALTRIGHT alt+right", KSTRLEN - 1);
430 break;
431 case KEY_ALTUP:
432 strnz__cpy(kstr, "KEY_ALTUP alt+up", KSTRLEN - 1);
433 break;
434 case KEY_ALTF(1):
435 strnz__cpy(kstr, "KEY_ALTF1 alt+F1", KSTRLEN - 1);
436 break;
437 case KEY_ALTF(2):
438 strnz__cpy(kstr, "KEY_ALTF1 alt+F2", KSTRLEN - 1);
439 break;
440 case KEY_ALTF(3):
441 strnz__cpy(kstr, "KEY_ALTF3 alt+F3", KSTRLEN - 1);
442 break;
443 case KEY_ALTF(4):
444 strnz__cpy(kstr, "KEY_ALTF4 alt+F4", KSTRLEN - 1);
445 break;
446 case KEY_ALTF(5):
447 strnz__cpy(kstr, "KEY_ALTF5 alt+F5", KSTRLEN - 1);
448 break;
449 case KEY_ALTF(6):
450 strnz__cpy(kstr, "KEY_ALTF6 alt+F6", KSTRLEN - 1);
451 break;
452 case KEY_ALTF(7):
453 strnz__cpy(kstr, "KEY_ALTF7 alt+F7", KSTRLEN - 1);
454 break;
455 case KEY_ALTF(8):
456 strnz__cpy(kstr, "KEY_ALTF8 alt+F8", KSTRLEN - 1);
457 break;
458 case KEY_ALTF(9):
459 strnz__cpy(kstr, "KEY_ALTF9 alt+F9", KSTRLEN - 1);
460 break;
461 case KEY_ALTF(10):
462 strnz__cpy(kstr, "KEY_ALTF10 alt+F10", KSTRLEN - 1);
463 break;
464 case KEY_ALTF(11):
465 strnz__cpy(kstr, "KEY_ALTF11 alt+F11", KSTRLEN - 1);
466 break;
467 case KEY_ALTF(12):
468 strnz__cpy(kstr, "KEY_ALTF12 alt+F12", KSTRLEN - 1);
469 break;
470 case KEY_MOUSE:
471 switch (ev.bstate) {
472 case BUTTON1_PRESSED:
473 strnz__cpy(action, "Button 1 pressed", KSTRLEN - 1);
474 break;
475 case BUTTON1_RELEASED:
476 strnz__cpy(action, "Button 1 released", KSTRLEN - 1);
477 break;
478 case BUTTON1_CLICKED:
479 strnz__cpy(action, "Button 1 clicked", KSTRLEN - 1);
480 break;
481 case BUTTON1_DOUBLE_CLICKED:
482 strnz__cpy(action, "Button 1 double-clicked", KSTRLEN - 1);
483 break;
484 case BUTTON2_PRESSED:
485 strnz__cpy(action, "Button 2 pressed", KSTRLEN - 1);
486 break;
487 case BUTTON2_RELEASED:
488 strnz__cpy(action, "Button 2 released", KSTRLEN - 1);
489 break;
490 case BUTTON2_CLICKED:
491 strnz__cpy(action, "Button 2 clicked", KSTRLEN - 1);
492 break;
493 case BUTTON2_DOUBLE_CLICKED:
494 strnz__cpy(action, "Button 2 double-clicked", KSTRLEN - 1);
495 break;
496 case BUTTON3_PRESSED:
497 strnz__cpy(action, "Button 3 pressed", KSTRLEN - 1);
498 break;
499 case BUTTON3_RELEASED:
500 strnz__cpy(action, "Button 3 released", KSTRLEN - 1);
501 break;
502 case BUTTON3_CLICKED:
503 strnz__cpy(action, "Button 3 clicked", KSTRLEN - 1);
504 break;
505 case BUTTON3_DOUBLE_CLICKED:
506 strnz__cpy(action, "Button 3 double-clicked", KSTRLEN - 1);
507 break;
508 case BUTTON4_PRESSED:
509 strnz__cpy(action, "Button 4 pressed", KSTRLEN - 1);
510 break;
511 case BUTTON4_RELEASED:
512 strnz__cpy(action, "Button 4 released", KSTRLEN - 1);
513 break;
514 case BUTTON4_CLICKED:
515 strnz__cpy(action, "Button 4 clicked", KSTRLEN - 1);
516 break;
517 case BUTTON4_DOUBLE_CLICKED:
518 strnz__cpy(action, "Button 4 double-clicked", KSTRLEN - 1);
519 break;
520 case BUTTON5_PRESSED:
521 strnz__cpy(action, "Scroll Up", KSTRLEN - 1);
522 break;
523 default:
524 break;
525 }
526 ui_mvwaddstr(sfc, WIN, 6, 3, " Action:");
527 ui_mvwaddstr(sfc, WIN, 6, 16, action);
528 ui_wclrtoeol(sfc, WIN);
529 strnz__cpy(tmp, " With Key:", MAXLEN - 1);
530 if (ev.bstate & BUTTON_SHIFT)
531 strnz__cat(tmp, " Shift", MAXLEN - 1);
532 if (ev.bstate & BUTTON_CTRL)
533 strnz__cat(tmp, " Ctrl", MAXLEN - 1);
534 if (ev.bstate & BUTTON_ALT)
535 strnz__cat(tmp, " Alt", MAXLEN - 1);
536 ui_mvwaddstr(sfc, WIN, 3, 4, tmp);
537 ui_wclrtoeol(sfc, WIN);
538 if (ev.mouse_inside) {
539 sprintf(tmp, " Inside Win: y: %3d, x: %3d",
540 ev.y, ev.x);
541 } else {
542 sprintf(tmp, " stdwin: y: %3d, x: %3d",
543 ev.y, ev.x);
544 }
545 ui_mvwaddstr(sfc, WIN, 4, 4, tmp);
546 ui_wclrtoeol(sfc, WIN);
547 ui_cursor_move(sfc, WIN, 5, 0);
548 ui_wclrtoeol(sfc, WIN);
549 ui_cursor_move(sfc, WIN, 7, 0);
550 ui_wclrtoeol(sfc, WIN);
551 default:
552 break;
553 }
554 if (c != KEY_MOUSE) {
555 sprintf(tmp, " Octal: %3o", c);
556 ui_mvwaddstr(sfc, WIN, 3, 4, tmp);
557 ui_wclrtoeol(sfc, WIN);
558
559 sprintf(tmp, " Decimal: %3d", c);
560 ui_mvwaddstr(sfc, WIN, 4, 4, tmp);
561 ui_wclrtoeol(sfc, WIN);
562
563 sprintf(tmp, " Hex: %3x", c);
564 ui_mvwaddstr(sfc, WIN, 5, 4, tmp);
565 ui_wclrtoeol(sfc, WIN);
566
567 if (kstr[0]) {
568 sprintf(tmp, "Description: %s", kstr);
569 } else {
570 sprintf(tmp, " ASCII: %c", c);
571 }
572 ui_mvwaddstr(sfc, WIN, 6, 3, tmp);
573 ui_wclrtoeol(sfc, WIN);
574 ui_render();
575 }
576 if (c == KEY_ALTEND) {
577 usleep(100000);
578 break;
579 }
580 c = '\0';
581 }
582 return 0;
583#else
584int notcurses_input(UiSurface *sfc, uint w) {
585 char kstr[KSTRLEN];
586 int c = -1;
587 char action[MAXLEN];
588 uint key_id = 0;
589 UiEvent ev;
590 while (!c) {
591 kstr[0] = '\0';
592 ui_cursor_move(sfc, WIN, 1, 39);
593 do {
594 ui_render();
595 c = ui_get_event(sfc, WIN, &ev, -1);
596 if (sig_received != 0) {
597 if (handle_signal(sig_received))
598 c = display_error(em0, em1, em2, NULL);
599 if (c == 'q' || c == KEY_F09)
600 exit(EXIT_FAILURE);
601 continue;
602 }
603 } while (c == -1);
604 switch (c) {
605 case NCKEY_INVALID:
606 strcpy(kstr, "NCKEY_INVALID");
607 break;
608 case NCKEY_RESIZE:
609 strcpy(kstr, "NCKEY_RESIZE");
610 break;
611 case NCKEY_UP:
612 strcpy(kstr, "NCKEY_UP");
613 break;
614 case NCKEY_RIGHT:
615 strcpy(kstr, "NCKEY_RIGHT");
616 break;
617 case NCKEY_DOWN:
618 strcpy(kstr, "NCKEY_DOWN");
619 break;
620 case NCKEY_LEFT:
621 strcpy(kstr, "NCKEY_LEFT");
622 break;
623 case NCKEY_INS:
624 strcpy(kstr, "NCKEY_INS");
625 break;
626 case NCKEY_DEL:
627 strcpy(kstr, "NCKEY_DEL");
628 break;
629 case NCKEY_BACKSPACE:
630 strcpy(kstr, "NCKEY_BACKSPACE");
631 break;
632 case NCKEY_PGDOWN:
633 strcpy(kstr, "NCKEY_PGDOWN");
634 break;
635 case NCKEY_PGUP:
636 strcpy(kstr, "NCKEY_PGUP");
637 break;
638 case NCKEY_HOME:
639 strcpy(kstr, "NCKEY_HOME");
640 break;
641 case NCKEY_END:
642 strcpy(kstr, "NCKEY_END");
643 break;
644 case NCKEY_F00:
645 strcpy(kstr, "NCKEY_F00");
646 break;
647 case NCKEY_F01:
648 strcpy(kstr, "NCKEY_F01");
649 break;
650 case NCKEY_F02:
651 strcpy(kstr, "NCKEY_F02");
652 break;
653 case NCKEY_F03:
654 strcpy(kstr, "NCKEY_F03");
655 break;
656 case NCKEY_F04:
657 strcpy(kstr, "NCKEY_F04");
658 break;
659 case NCKEY_F05:
660 strcpy(kstr, "NCKEY_F05");
661 break;
662 case NCKEY_F06:
663 strcpy(kstr, "NCKEY_F06");
664 break;
665 case NCKEY_F07:
666 strcpy(kstr, "NCKEY_F07");
667 break;
668 case NCKEY_F08:
669 strcpy(kstr, "NCKEY_F08");
670 break;
671 case NCKEY_F09:
672 strcpy(kstr, "NCKEY_F09");
673 break;
674 case NCKEY_F10:
675 strcpy(kstr, "NCKEY_F10");
676 break;
677 case NCKEY_F11:
678 strcpy(kstr, "NCKEY_F11");
679 break;
680 case NCKEY_F12:
681 strcpy(kstr, "NCKEY_F12");
682 break;
683 case NCKEY_F13:
684 strcpy(kstr, "NCKEY_F13");
685 break;
686 case NCKEY_F14:
687 strcpy(kstr, "NCKEY_F14");
688 break;
689 case NCKEY_F15:
690 strcpy(kstr, "NCKEY_F15");
691 break;
692 case NCKEY_F16:
693 strcpy(kstr, "NCKEY_F16");
694 break;
695 case NCKEY_F17:
696 strcpy(kstr, "NCKEY_F17");
697 break;
698 case NCKEY_F18:
699 strcpy(kstr, "NCKEY_F18");
700 break;
701 case NCKEY_F19:
702 strcpy(kstr, "NCKEY_F19");
703 break;
704 case NCKEY_F20:
705 strcpy(kstr, "NCKEY_F20");
706 break;
707 case NCKEY_F21:
708 strcpy(kstr, "NCKEY_F21");
709 break;
710 case NCKEY_F22:
711 strcpy(kstr, "NCKEY_F22");
712 break;
713 case NCKEY_F23:
714 strcpy(kstr, "NCKEY_F23");
715 break;
716 case NCKEY_F24:
717 strcpy(kstr, "NCKEY_F24");
718 break;
719 case NCKEY_F25:
720 strcpy(kstr, "NCKEY_F25");
721 break;
722 case NCKEY_F26:
723 strcpy(kstr, "NCKEY_F26");
724 break;
725 case NCKEY_F27:
726 strcpy(kstr, "NCKEY_F27");
727 break;
728 case NCKEY_F28:
729 strcpy(kstr, "NCKEY_F28");
730 break;
731 case NCKEY_F29:
732 strcpy(kstr, "NCKEY_F29");
733 break;
734 case NCKEY_F30:
735 strcpy(kstr, "NCKEY_F30");
736 break;
737 case NCKEY_F31:
738 strcpy(kstr, "NCKEY_F31");
739 break;
740 case NCKEY_F32:
741 strcpy(kstr, "NCKEY_F32");
742 break;
743 case NCKEY_F33:
744 strcpy(kstr, "NCKEY_F33");
745 break;
746 case NCKEY_F34:
747 strcpy(kstr, "NCKEY_F34");
748 break;
749 case NCKEY_F35:
750 strcpy(kstr, "NCKEY_F35");
751 break;
752 case NCKEY_F36:
753 strcpy(kstr, "NCKEY_F36");
754 break;
755 case NCKEY_F37:
756 strcpy(kstr, "NCKEY_F37");
757 break;
758 case NCKEY_F38:
759 strcpy(kstr, "NCKEY_F38");
760 break;
761 case NCKEY_F39:
762 strcpy(kstr, "NCKEY_F39");
763 break;
764 case NCKEY_F40:
765 strcpy(kstr, "NCKEY_F40");
766 break;
767 case NCKEY_F41:
768 strcpy(kstr, "NCKEY_F41");
769 break;
770 case NCKEY_F42:
771 strcpy(kstr, "NCKEY_F42");
772 break;
773 case NCKEY_F43:
774 strcpy(kstr, "NCKEY_F43");
775 break;
776 case NCKEY_F44:
777 strcpy(kstr, "NCKEY_F44");
778 break;
779 case NCKEY_F45:
780 strcpy(kstr, "NCKEY_F45");
781 break;
782 case NCKEY_F46:
783 strcpy(kstr, "NCKEY_F46");
784 break;
785 case NCKEY_F47:
786 strcpy(kstr, "NCKEY_F47");
787 break;
788 case NCKEY_F48:
789 strcpy(kstr, "NCKEY_F48");
790 break;
791 case NCKEY_F49:
792 strcpy(kstr, "NCKEY_F49");
793 break;
794 case NCKEY_F50:
795 strcpy(kstr, "NCKEY_F50");
796 break;
797 case NCKEY_F51:
798 strcpy(kstr, "NCKEY_F51");
799 break;
800 case NCKEY_F52:
801 strcpy(kstr, "NCKEY_F52");
802 break;
803 case NCKEY_F53:
804 strcpy(kstr, "NCKEY_F53");
805 break;
806 case NCKEY_F54:
807 strcpy(kstr, "NCKEY_F54");
808 break;
809 case NCKEY_F55:
810 strcpy(kstr, "NCKEY_F55");
811 break;
812 case NCKEY_F56:
813 strcpy(kstr, "NCKEY_F56");
814 break;
815 case NCKEY_F57:
816 strcpy(kstr, "NCKEY_F57");
817 break;
818 case NCKEY_F58:
819 strcpy(kstr, "NCKEY_F58");
820 break;
821 case NCKEY_F59:
822 strcpy(kstr, "NCKEY_F59");
823 break;
824 case NCKEY_F60:
825 strcpy(kstr, "NCKEY_F60");
826 break;
827 case NCKEY_ENTER:
828 strcpy(kstr, "NCKEY_ENTER");
829 break;
830 case NCKEY_CLS:
831 strcpy(kstr, "NCKEY_CLS");
832 break;
833 case NCKEY_DLEFT:
834 strcpy(kstr, "NCKEY_DLEFT");
835 break;
836 case NCKEY_DRIGHT:
837 strcpy(kstr, "NCKEY_DRIGHT");
838 break;
839 case NCKEY_ULEFT:
840 strcpy(kstr, "NCKEY_ULEFT");
841 break;
842 case NCKEY_URIGHT:
843 strcpy(kstr, "NCKEY_URIGHT");
844 break;
845 case NCKEY_CENTER:
846 strcpy(kstr, "NCKEY_CENTER");
847 break;
848 case NCKEY_BEGIN:
849 strcpy(kstr, "NCKEY_BEGIN");
850 break;
851 case NCKEY_CANCEL:
852 strcpy(kstr, "NCKEY_CANCEL");
853 break;
854 case NCKEY_CLOSE:
855 strcpy(kstr, "NCKEY_CLOSE");
856 break;
857 case NCKEY_COMMAND:
858 strcpy(kstr, "NCKEY_COMMAND");
859 break;
860 case NCKEY_COPY:
861 strcpy(kstr, "NCKEY_COPY");
862 break;
863 case NCKEY_EXIT:
864 strcpy(kstr, "NCKEY_EXIT");
865 break;
866 case NCKEY_PRINT:
867 strcpy(kstr, "NCKEY_PRINT");
868 break;
869 case NCKEY_REFRESH:
870 strcpy(kstr, "NCKEY_REFRESH");
871 break;
872 case NCKEY_SEPARATOR:
873 strcpy(kstr, "NCKEY_SEPARATOR");
874 break;
875 case NCKEY_CAPS_LOCK:
876 strcpy(kstr, "NCKEY_CAPS_LOCK");
877 break;
878 case NCKEY_SCROLL_LOCK:
879 strcpy(kstr, "NCKEY_SCROLL_LOCK");
880 break;
881 case NCKEY_NUM_LOCK:
882 strcpy(kstr, "NCKEY_NUM_LOCK");
883 break;
884 case NCKEY_PRINT_SCREEN:
885 strcpy(kstr, "NCKEY_PRINT_SCREEN");
886 break;
887 case NCKEY_PAUSE:
888 strcpy(kstr, "NCKEY_PAUSE");
889 break;
890 case NCKEY_MENU:
891 strcpy(kstr, "NCKEY_MENU");
892 break;
893 case NCKEY_MEDIA_PLAY:
894 strcpy(kstr, "NCKEY_MEDIA_PLAY");
895 break;
896 case NCKEY_MEDIA_PAUSE:
897 strcpy(kstr, "NCKEY_MEDIA_PAUSE");
898 break;
899 case NCKEY_MEDIA_PPAUSE:
900 strcpy(kstr, "NCKEY_MEDIA_PPAUSE");
901 break;
902 case NCKEY_MEDIA_REV:
903 strcpy(kstr, "NCKEY_MEDIA_REV");
904 break;
905 case NCKEY_MEDIA_STOP:
906 strcpy(kstr, "NCKEY_MEDIA_STOP");
907 break;
908 case NCKEY_MEDIA_FF:
909 strcpy(kstr, "NCKEY_MEDIA_FF");
910 break;
911 case NCKEY_MEDIA_REWIND:
912 strcpy(kstr, "NCKEY_MEDIA_REWIND");
913 break;
914 case NCKEY_MEDIA_NEXT:
915 strcpy(kstr, "NCKEY_MEDIA_NEXT");
916 break;
917 case NCKEY_MEDIA_PREV:
918 strcpy(kstr, "NCKEY_MEDIA_PREV");
919 break;
920 case NCKEY_MEDIA_RECORD:
921 strcpy(kstr, "NCKEY_MEDIA_RECORD");
922 break;
923 case NCKEY_MEDIA_LVOL:
924 strcpy(kstr, "NCKEY_MEDIA_LVOL");
925 break;
926 case NCKEY_MEDIA_RVOL:
927 strcpy(kstr, "NCKEY_MEDIA_RVOL");
928 break;
929 case NCKEY_MEDIA_MUTE:
930 strcpy(kstr, "NCKEY_MEDIA_MUTE");
931 break;
932 case NCKEY_LSHIFT:
933 strcpy(kstr, "NCKEY_LSHIFT");
934 break;
935 case NCKEY_LCTRL:
936 strcpy(kstr, "NCKEY_LCTRL");
937 break;
938 case NCKEY_LALT:
939 strcpy(kstr, "NCKEY_LALT");
940 break;
941 case NCKEY_LSUPER:
942 strcpy(kstr, "NCKEY_LSUPER");
943 break;
944 case NCKEY_LHYPER:
945 strcpy(kstr, "NCKEY_LHYPER");
946 break;
947 case NCKEY_LMETA:
948 strcpy(kstr, "NCKEY_LMETA");
949 break;
950 case NCKEY_RSHIFT:
951 strcpy(kstr, "NCKEY_RSHIFT");
952 break;
953 case NCKEY_RCTRL:
954 strcpy(kstr, "NCKEY_RCTRL");
955 break;
956 case NCKEY_RALT:
957 strcpy(kstr, "NCKEY_RALT");
958 break;
959 case NCKEY_RSUPER:
960 strcpy(kstr, "NCKEY_RSUPER");
961 break;
962 case NCKEY_RHYPER:
963 strcpy(kstr, "NCKEY_RHYPER");
964 break;
965 case NCKEY_RMETA:
966 strcpy(kstr, "NCKEY_RMETA");
967 break;
968 case NCKEY_L3SHIFT:
969 strcpy(kstr, "NCKEY_L3SHIFT");
970 break;
971 case NCKEY_L5SHIFT:
972 strcpy(kstr, "NCKEY_L5SHIFT");
973 break;
974 case NCKEY_MOTION:
975 strcpy(kstr, "NCKEY_MOTION");
976 break;
977 case NCKEY_BUTTON1:
978 strcpy(kstr, "NCKEY_BUTTON1");
979 break;
980 case NCKEY_BUTTON2:
981 strcpy(kstr, "NCKEY_BUTTON2");
982 break;
983 case NCKEY_BUTTON3:
984 strcpy(kstr, "NCKEY_BUTTON3");
985 break;
986 case NCKEY_BUTTON4:
987 strcpy(kstr, "NCKEY_BUTTON4");
988 break;
989 case NCKEY_BUTTON5:
990 strcpy(kstr, "NCKEY_BUTTON5");
991 break;
992 case NCKEY_BUTTON6:
993 strcpy(kstr, "NCKEY_BUTTON6");
994 break;
995 case NCKEY_BUTTON7:
996 strcpy(kstr, "NCKEY_BUTTON7");
997 break;
998 case NCKEY_BUTTON8:
999 strcpy(kstr, "NCKEY_BUTTON8");
1000 break;
1001 case NCKEY_BUTTON9:
1002 strcpy(kstr, "NCKEY_BUTTON9");
1003 break;
1004 case NCKEY_BUTTON10:
1005 strcpy(kstr, "NCKEY_BUTTON10");
1006 break;
1007 case NCKEY_BUTTON11:
1008 strcpy(kstr, "NCKEY_BUTTON11");
1009 break;
1010 case NCKEY_SIGNAL:
1011 strcpy(kstr, "NCKEY_SIGNAL");
1012 break;
1013 case NCKEY_EOF:
1014 strcpy(kstr, "NCKEY_EOF");
1015 break;
1016 default:
1017 snprintf(kstr, 32, "NCKEY_%d", key_id);
1018 break;
1019 }
1020 ui_mvwaddstr(sfc, w, 6, 3, " Action:");
1021 ui_mvwaddstr(sfc, w, 6, 16, action);
1022 ui_wclrtoeol(sfc, w);
1023 char tmp[MAXLEN];
1024 if (ev.mouse_inside) {
1025 sprintf(tmp, " Inside Win: y: %3d, x: %3d",
1026 ev.y, ev.x);
1027 } else {
1028 sprintf(tmp, " stdwin: y: %3d, x: %3d",
1029 ev.y, ev.x);
1030 }
1031 ui_mvwaddstr(sfc, w, 4, 4, tmp);
1032 ui_wclrtoeol(sfc, w);
1033 ui_cursor_move(sfc, w, 5, 0);
1034 ui_wclrtoeol(sfc, w);
1035 ui_cursor_move(sfc, w, 7, 0);
1036 ui_wclrtoeol(sfc, w);
1037 if (c != KEY_MOUSE) {
1038 sprintf(tmp, " Octal: %3o", c);
1039 ui_mvwaddstr(sfc, w, 3, 4, tmp);
1040 ui_wclrtoeol(sfc, w);
1041
1042 sprintf(tmp, " Decimal: %3d", c);
1043 ui_mvwaddstr(sfc, w, 4, 4, tmp);
1044 ui_wclrtoeol(sfc, w);
1045
1046 sprintf(tmp, " Hex: %3x", c);
1047 ui_mvwaddstr(sfc, w, 5, 4, tmp);
1048 ui_wclrtoeol(sfc, w);
1049
1050 if (kstr[0]) {
1051 sprintf(tmp, "Description: %s", kstr);
1052 } else {
1053 sprintf(tmp, " ASCII: %c", c);
1054 }
1055 ui_mvwaddstr(sfc, w, 6, 3, tmp);
1056 ui_wclrtoeol(sfc, w);
1057 ui_render();
1058 }
1059 if (c == KEY_ALTEND) {
1060 usleep(100000);
1061 break;
1062 }
1063 c = '\0';
1064 }
1065#endif
1066 return 0;
1067}
sig_received
volatile sig_atomic_t sig_received
Definition sig.c:31
handle_signal
bool handle_signal(sig_atomic_t)
KEY_ALTEND
#define KEY_ALTEND
Definition cm.h:560
ui_render
void ui_render()
Definition ui_ncurses.c:800
ui_cursor_move
int ui_cursor_move(UiSurface *s, uint w, uint y, uint x)
Definition ui_ncurses.c:727
ui_bkgdset
int ui_bkgdset(UiSurface *s, uint w, const UiCell *cell)
Definition ui_ncurses.c:760
ui_mvwaddstr
int ui_mvwaddstr(UiSurface *s, uint w, uint y, uint x, const char *text)
Definition ui_ncurses_draw.c:132
ui_get_event
int ui_get_event(UiSurface *s, uint w, UiEvent *ev, int timeout_ms)
Wait for an input event on target (or stdscr if NULL).
Definition ui_ncurses_input.c:103
ui_surface_destroy
void ui_surface_destroy(UiSurface *s)
Definition ui_ncurses.c:377
ui_surface
UiSurface * ui_surface[UI_SFC_MAX]
Definition ui_ncurses.c:28
ui_get_screen_size
void ui_get_screen_size(uint *lines, uint *cols)
Definition ui_ncurses.c:692
ui_wclrtoeol
int ui_wclrtoeol(UiSurface *s, uint w)
Definition ui_ncurses_draw.c:31
sfc_ptr
int sfc_ptr
Definition nckeys.c:47
ui_keypad
int ui_keypad(UiSurface *s, uint w, bool enable)
Definition ui_ncurses.c:635
KEY_F09
#define KEY_F09
Definition ui_ncurses_internal.h:33
KEY_MOUSE
#define KEY_MOUSE
Definition ui_notcurses_internal.h:52
notcurses_input
int notcurses_input(UiSurface *s, uint w)
Display Curses Keys Responds to curses keys and mouse events, displaying the key code and description...
Definition curskeys.c:584
popup_ckeys
int popup_ckeys()
Definition curskeys.c:31
KSTRLEN
#define KSTRLEN
Definition curskeys.c:14
MAXLEN
#define MAXLEN
Definition curskeys.c:15
surface_box_win_new
int surface_box_win_new(uint wlines, uint wcols, uint wbegy, uint wbegx, char *wtitle)
Definition dwin.c:521
cell_nt
UiCell cell_nt
Definition dwin.c:94
em1
char em1[MAXLEN]
Definition dwin.c:143
em2
char em2[MAXLEN]
Definition dwin.c:144
em0
char em0[MAXLEN]
Definition dwin.c:142
cell_nt_rev
UiCell cell_nt_rev
Definition dwin.c:95
Perror
int Perror(char *emsg_str)
Display a simple error message window or print to stderr.
Definition dwin.c:841
display_error
int display_error(char *msg0, char *msg1, char *msg2, char *msg3)
Display an error message window or print to stderr.
Definition dwin.c:778
strnz__cpy
size_t strnz__cpy(char *, const char *, size_t)
safer alternative to strncpy
Definition futil.c:537
strnz__cat
size_t strnz__cat(char *, const char *, size_t)
safer alternative to strncat
Definition futil.c:566
UiEvent::mouse_inside
bool mouse_inside
Definition ui_backend.h:113