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