C-Menu 0.2.9
A User Interface Toolkit
Loading...
Searching...
No Matches
curskeys.c File Reference

Test Curses Keys. More...

#include <common.h>
#include <ncursesw/ncurses.h>
#include <unistd.h>
Include dependency graph for curskeys.c:

Go to the source code of this file.

Macros

#define KSTRLEN   100
#define MAXLEN   256

Functions

int popup_ckeys ()
 Display Curses Keys Responds to curses keys and mouse events, displaying the key code and description.

Detailed Description

Test Curses Keys.

Author
Bill Waller Copyright (c) 2025 MIT License billx.nosp@m.wall.nosp@m.er@gm.nosp@m.ail..nosp@m.com
Date
2026-02-09

Definition in file curskeys.c.

Macro Definition Documentation

◆ KSTRLEN

#define KSTRLEN   100

Definition at line 14 of file curskeys.c.

◆ MAXLEN

#define MAXLEN   256

Definition at line 15 of file curskeys.c.

Function Documentation

◆ popup_ckeys()

int popup_ckeys ( )

Display Curses Keys Responds to curses keys and mouse events, displaying the key code and description.

Returns
0 on success, non-zero on failure

Definition at line 23 of file curskeys.c.

23 {
24 WINDOW *win;
25 // WINDOW *box;
26 char Title[] = "TEST CURSES KEYS";
27 int lines = 10;
28 int cols = 55;
29 char kstr[KSTRLEN];
30 int c;
31 char action[MAXLEN];
32 char tmp[MAXLEN];
33 MEVENT event;
34 char *s;
35 int maxy, maxx;
36
37 getmaxyx(stdscr, maxy, maxx);
38 int begy = (maxy - lines) / 3;
39 int begx = (maxx - cols) / 2;
40 mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION | BUTTON_SHIFT |
41 BUTTON_CTRL | BUTTON_ALT,
42 NULL);
43 if (box_new(lines, cols, begy, begx, Title)) {
44 strnz__cpy(tmp, "box_new failed: ", MAXLEN - 1);
45 strnz__cat(tmp, Title, MAXLEN - 1);
46 Perror(tmp);
47 exit(EXIT_FAILURE);
48 }
49 // box = win_box[win_ptr];
50 win = win_win[win_ptr];
51 keypad(win, TRUE);
52 wbkgrndset(win, &CC_NT_REV);
53 mvwaddstr(win, lines - 1, 0, " <ALT>END to exit ");
54 wbkgrndset(win, &CC_NT);
55 // wnoutrefresh(box);
56 mvwaddstr(win, 1, 4, "Press a key or activate the mouse:");
57 c = '\0';
58 halfdelay(1);
59 while (!c) {
60 kstr[0] = '\0';
61 wmove(win, 1, 39);
62 do {
63 update_panels();
64 doupdate();
65 c = wgetch(win);
66 if (sig_received != 0) {
67 if (handle_signal(sig_received))
68 c = display_error(em0, em1, em2, NULL);
69 if (c == 'q' || c == KEY_F(9))
70 exit(EXIT_FAILURE);
71 continue;
72 }
73 } while (c == ERR);
74 s = keybound(c, 0);
75 switch (c) {
76 case '\0':
77 break;
78 case KEY_CODE_YES:
79 strnz__cpy(kstr, "KEY_CODE_YES A wchar_t contains a key code",
80 KSTRLEN - 1);
81 break;
82 case KEY_BREAK:
83 strnz__cpy(kstr, "KEY_BREAK Break key(unreliable)", KSTRLEN - 1);
84 break;
85 case KEY_DOWN:
86 strnz__cpy(kstr, "KEY_DOWN down - arrow key", KSTRLEN - 1);
87 break;
88 case KEY_UP:
89 strnz__cpy(kstr, "KEY_UP up - arrow key", KSTRLEN - 1);
90 break;
91 case KEY_LEFT:
92 strnz__cpy(kstr, "KEY_LEFT left - arrow key", KSTRLEN - 1);
93 break;
94 case KEY_RIGHT:
95 strnz__cpy(kstr, "KEY_RIGHT right - arrow key", KSTRLEN - 1);
96 break;
97 case KEY_HOME:
98 strnz__cpy(kstr, "KEY_HOME home key", KSTRLEN - 1);
99 break;
100 case KEY_BACKSPACE:
101 strnz__cpy(kstr, "KEY_BACKSPACE backspace key", KSTRLEN - 1);
102 break;
103 case KEY_F(1):
104 strnz__cpy(kstr, "KEY_F(1) KEY_F(1)", KSTRLEN - 1);
105 break;
106 case KEY_F(2):
107 strnz__cpy(kstr, "KEY_F2 KEY_F2", KSTRLEN - 1);
108 break;
109 case KEY_F(3):
110 strnz__cpy(kstr, "KEY_F3 KEY_F3", KSTRLEN - 1);
111 break;
112 case KEY_F(4):
113 strnz__cpy(kstr, "KEY_F4 KEY_F4", KSTRLEN - 1);
114 break;
115 case KEY_F(5):
116 strnz__cpy(kstr, "KEY_F5 KEY_F5", KSTRLEN - 1);
117 break;
118 case KEY_F(6):
119 strnz__cpy(kstr, "KEY_F6 KEY_F6", KSTRLEN - 1);
120 break;
121 case KEY_F(7):
122 strnz__cpy(kstr, "KEY_F7 KEY_F7", KSTRLEN - 1);
123 break;
124 case KEY_F(8):
125 strnz__cpy(kstr, "KEY_F8 KEY_F8", KSTRLEN - 1);
126 break;
127 case KEY_F(9):
128 strnz__cpy(kstr, "KEY_F9 KEY_F9", KSTRLEN - 1);
129 break;
130 case KEY_F(10):
131 strnz__cpy(kstr, "KEY_F10 KEY_F10", KSTRLEN - 1);
132 break;
133 case KEY_F(11):
134 strnz__cpy(kstr, "KEY_F11 KEY_F11", KSTRLEN - 1);
135 break;
136 case KEY_F(12):
137 strnz__cpy(kstr, "KEY_F12 KEY_F12", KSTRLEN - 1);
138 break;
139 case KEY_DL:
140 strnz__cpy(kstr, "KEY_DL delete - line key", KSTRLEN - 1);
141 break;
142 case KEY_IL:
143 strnz__cpy(kstr, "KEY_IL insert - line key", KSTRLEN - 1);
144 break;
145 case KEY_DC:
146 strnz__cpy(kstr, "KEY_DC delete - character key", KSTRLEN - 1);
147 break;
148 case KEY_IC:
149 strnz__cpy(kstr, "KEY_IC insert - character key", KSTRLEN - 1);
150 break;
151 case KEY_EIC:
152 strnz__cpy(kstr, "KEY_EIC sent by rmir or smir in insert mode",
153 KSTRLEN - 1);
154 break;
155 case KEY_CLEAR:
156 strnz__cpy(kstr, "KEY_CLEAR clear - screen or erase key",
157 KSTRLEN - 1);
158 break;
159 case KEY_EOS:
160 strnz__cpy(kstr, "KEY_EOS clear - to - end - of - screen key",
161 KSTRLEN - 1);
162 break;
163 case KEY_EOL:
164 strnz__cpy(kstr, "KEY_EOL clear - to - end - of - line key",
165 KSTRLEN - 1);
166 break;
167 case KEY_SF:
168 strnz__cpy(kstr, "KEY_SF scroll - forward key", KSTRLEN - 1);
169 break;
170 case KEY_SR:
171 strnz__cpy(kstr, "KEY_SR scroll - backward key", KSTRLEN - 1);
172 break;
173 case KEY_NPAGE:
174 strnz__cpy(kstr, "KEY_NPAGE next - page key", KSTRLEN - 1);
175 break;
176 case KEY_PPAGE:
177 strnz__cpy(kstr, "KEY_PPAGE previous - page key", KSTRLEN - 1);
178 break;
179 case KEY_STAB:
180 strnz__cpy(kstr, "KEY_STAB set - tab key", KSTRLEN - 1);
181 break;
182 case KEY_CTAB:
183 strnz__cpy(kstr, "KEY_CTAB clear - tab key", KSTRLEN - 1);
184 break;
185 case KEY_CATAB:
186 strnz__cpy(kstr, "KEY_CATAB clear - all - tabs key", KSTRLEN - 1);
187 break;
188 case '\n':
189 strnz__cpy(kstr, "KEY_ENTER newline key", KSTRLEN - 1);
190 break;
191 case KEY_ENTER:
192 strnz__cpy(kstr, "KEY_ENTER enter / send key", KSTRLEN - 1);
193 break;
194 case KEY_SRESET:
195 strnz__cpy(kstr, "KEY_SRESET Soft(partial) reset(unreliable)",
196 KSTRLEN - 1);
197 break;
198 case KEY_RESET:
199 strnz__cpy(kstr, "KEY_RESET Reset or hard reset(unreliable)",
200 KSTRLEN - 1);
201 break;
202 case KEY_PRINT:
203 strnz__cpy(kstr, "KEY_PRINT print key", KSTRLEN - 1);
204 break;
205 case KEY_LL:
206 strnz__cpy(kstr, "KEY_LL lower - left key(home down)", KSTRLEN - 1);
207 break;
208 case KEY_A1:
209 strnz__cpy(kstr, "KEY_A1 upper left of keypad", KSTRLEN - 1);
210 break;
211 case KEY_A3:
212 strnz__cpy(kstr, "KEY_A3 upper right of keypad", KSTRLEN - 1);
213 break;
214 case KEY_B2:
215 strnz__cpy(kstr, "KEY_B2 center of keypad", KSTRLEN - 1);
216 break;
217 case KEY_C1:
218 strnz__cpy(kstr, "KEY_C1 lower left of keypad", KSTRLEN - 1);
219 break;
220 case KEY_C3:
221 strnz__cpy(kstr, "KEY_C3 lower right of keypad", KSTRLEN - 1);
222 break;
223 case KEY_BTAB:
224 strnz__cpy(kstr, "KEY_BTAB back - tab key", KSTRLEN - 1);
225 break;
226 case KEY_BEG:
227 strnz__cpy(kstr, "KEY_BEG begin key", KSTRLEN - 1);
228 break;
229 case KEY_CANCEL:
230 strnz__cpy(kstr, "KEY_CANCEL cancel key", KSTRLEN - 1);
231 break;
232 case KEY_CLOSE:
233 strnz__cpy(kstr, "KEY_CLOSE close key", KSTRLEN - 1);
234 break;
235 case KEY_COMMAND:
236 strnz__cpy(kstr, "KEY_COMMAND command key", KSTRLEN - 1);
237 break;
238 case KEY_COPY:
239 strnz__cpy(kstr, "KEY_COPY copy key", KSTRLEN - 1);
240 break;
241 case KEY_CREATE:
242 strnz__cpy(kstr, "KEY_CREATE create key", KSTRLEN - 1);
243 break;
244 case KEY_END:
245 strnz__cpy(kstr, "KEY_END end key", KSTRLEN - 1);
246 break;
247 case KEY_EXIT:
248 strnz__cpy(kstr, "KEY_EXIT exit key", KSTRLEN - 1);
249 break;
250 case KEY_FIND:
251 strnz__cpy(kstr, "KEY_FIND find key", KSTRLEN - 1);
252 break;
253 case KEY_HELP:
254 strnz__cpy(kstr, "KEY_HELP help key", KSTRLEN - 1);
255 break;
256 case KEY_MARK:
257 strnz__cpy(kstr, "KEY_MARK mark key", KSTRLEN - 1);
258 break;
259 case KEY_MESSAGE:
260 strnz__cpy(kstr, "KEY_MESSAGE message key", KSTRLEN - 1);
261 break;
262 case KEY_MOVE:
263 strnz__cpy(kstr, "KEY_MOVE move key", KSTRLEN - 1);
264 break;
265 case KEY_NEXT:
266 strnz__cpy(kstr, "KEY_NEXT next key", KSTRLEN - 1);
267 break;
268 case KEY_OPEN:
269 strnz__cpy(kstr, "KEY_OPEN open key", KSTRLEN - 1);
270 break;
271 case KEY_OPTIONS:
272 strnz__cpy(kstr, "KEY_OPTIONS options key", KSTRLEN - 1);
273 break;
274 case KEY_PREVIOUS:
275 strnz__cpy(kstr, "KEY_PREVIOUS previous key", KSTRLEN - 1);
276 break;
277 case KEY_REDO:
278 strnz__cpy(kstr, "KEY_REDO redo key", KSTRLEN - 1);
279 break;
280 case KEY_REFERENCE:
281 strnz__cpy(kstr, "KEY_REFERENCE reference key", KSTRLEN - 1);
282 break;
283 case KEY_REFRESH:
284 strnz__cpy(kstr, "KEY_REFRESH refresh key", KSTRLEN - 1);
285 break;
286 case KEY_REPLACE:
287 strnz__cpy(kstr, "KEY_REPLACE replace key", KSTRLEN - 1);
288 break;
289 case KEY_RESTART:
290 strnz__cpy(kstr, "KEY_RESTART restart key", KSTRLEN - 1);
291 break;
292 case KEY_RESUME:
293 strnz__cpy(kstr, "KEY_RESUME resume key", KSTRLEN - 1);
294 break;
295 case KEY_SAVE:
296 strnz__cpy(kstr, "KEY_SAVE save key", KSTRLEN - 1);
297 break;
298 case KEY_SBEG:
299 strnz__cpy(kstr, "KEY_SBEG shifted begin key", KSTRLEN - 1);
300 break;
301 case KEY_SCANCEL:
302 strnz__cpy(kstr, "KEY_SCANCEL shifted cancel key", KSTRLEN - 1);
303 break;
304 case KEY_SCOMMAND:
305 strnz__cpy(kstr, "KEY_SCOMMAND shifted command key", KSTRLEN - 1);
306 break;
307 case KEY_SCOPY:
308 strnz__cpy(kstr, "KEY_SCOPY shifted copy key", KSTRLEN - 1);
309 break;
310 case KEY_SCREATE:
311 strnz__cpy(kstr, "KEY_SCREATE shifted create key", KSTRLEN - 1);
312 break;
313 case KEY_SDC:
314 strnz__cpy(kstr, "KEY_SDC shifted delete - character key",
315 KSTRLEN - 1);
316 break;
317 case KEY_SDL:
318 strnz__cpy(kstr, "KEY_SDL shifted delete - line key", KSTRLEN - 1);
319 break;
320 case KEY_SELECT:
321 strnz__cpy(kstr, "KEY_SELECT select key", KSTRLEN - 1);
322 break;
323 case KEY_SEND:
324 strnz__cpy(kstr, "KEY_SEND shifted end key", KSTRLEN - 1);
325 break;
326 case KEY_SEOL:
327 strnz__cpy(kstr,
328 "KEY_SEOL shifted clear - to - end - of - line key",
329 KSTRLEN - 1);
330 break;
331 case KEY_SEXIT:
332 strnz__cpy(kstr, "KEY_SEXIT shifted exit key", KSTRLEN - 1);
333 break;
334 case KEY_SFIND:
335 strnz__cpy(kstr, "KEY_SFIND shifted find key", KSTRLEN - 1);
336 break;
337 case KEY_SHELP:
338 strnz__cpy(kstr, "KEY_SHELP shifted help key", KSTRLEN - 1);
339 break;
340 case KEY_SHOME:
341 strnz__cpy(kstr, "KEY_SHOME shifted home key", KSTRLEN - 1);
342 break;
343 case KEY_SIC:
344 strnz__cpy(kstr, "KEY_SIC shifted insert - character key",
345 KSTRLEN - 1);
346 break;
347 case KEY_SLEFT:
348 strnz__cpy(kstr, "KEY_SLEFT shifted left - arrow key", KSTRLEN - 1);
349 break;
350 case KEY_SMESSAGE:
351 strnz__cpy(kstr, "KEY_SMESSAGE shifted message key", KSTRLEN - 1);
352 break;
353 case KEY_SMOVE:
354 strnz__cpy(kstr, "KEY_SMOVE shifted move key", KSTRLEN - 1);
355 break;
356 case KEY_SNEXT:
357 strnz__cpy(kstr, "KEY_SNEXT shifted next key", KSTRLEN - 1);
358 break;
359 case KEY_SOPTIONS:
360 strnz__cpy(kstr, "KEY_SOPTIONS shifted options key", KSTRLEN - 1);
361 break;
362 case KEY_SPREVIOUS:
363 strnz__cpy(kstr, "KEY_SPREVIOUS shifted previous key", KSTRLEN - 1);
364 break;
365 case KEY_SPRINT:
366 strnz__cpy(kstr, "KEY_SPRINT shifted print key", KSTRLEN - 1);
367 break;
368 case KEY_SREDO:
369 strnz__cpy(kstr, "KEY_SREDO shifted redo key", KSTRLEN - 1);
370 break;
371 case KEY_SREPLACE:
372 strnz__cpy(kstr, "KEY_SREPLACE shifted replace key", KSTRLEN - 1);
373 break;
374 case KEY_SRIGHT:
375 strnz__cpy(kstr, "KEY_SRIGHT shifted right - arrow key",
376 KSTRLEN - 1);
377 break;
378 case KEY_SRSUME:
379 strnz__cpy(kstr, "KEY_SRSUME shifted resume key", KSTRLEN - 1);
380 break;
381 case KEY_SSAVE:
382 strnz__cpy(kstr, "KEY_SSAVE shifted save key", KSTRLEN - 1);
383 break;
384 case KEY_SSUSPEND:
385 strnz__cpy(kstr, "KEY_SSUSPEND shifted suspend key", KSTRLEN - 1);
386 break;
387 case KEY_SUNDO:
388 strnz__cpy(kstr, "KEY_SUNDO shifted undo key", KSTRLEN - 1);
389 break;
390 case KEY_SUSPEND:
391 strnz__cpy(kstr, "KEY_SUSPEND suspend key", KSTRLEN - 1);
392 break;
393 case KEY_UNDO:
394 strnz__cpy(kstr, "KEY_UNDO undo key", KSTRLEN - 1);
395 break;
396 case KEY_ALTDEL:
397 strnz__cpy(kstr, "KEY_ALTDEL alt+delete", KSTRLEN - 1);
398 break;
399 case KEY_ALTDOWN:
400 strnz__cpy(kstr, "KEY_ALTDOWN alt+down", KSTRLEN - 1);
401 break;
402 case KEY_ALTEND:
403 strnz__cpy(kstr, "KEY_ALTEND alt+end", KSTRLEN - 1);
404 break;
405 case KEY_ALTHOME:
406 strnz__cpy(kstr, "KEY_ALTHOME alt+home", KSTRLEN - 1);
407 break;
408 case KEY_ALTINS:
409 strnz__cpy(kstr, "KEY_ALTINS alt+ins", KSTRLEN - 1);
410 break;
411 case KEY_ALTLEFT:
412 strnz__cpy(kstr, "KEY_ALTLEFT alt+left", KSTRLEN - 1);
413 break;
414 case KEY_ALTPGDN:
415 strnz__cpy(kstr, "KEY_ALTPGDN alt+pgdn", KSTRLEN - 1);
416 break;
417 case KEY_ALTPGUP:
418 strnz__cpy(kstr, "KEY_ALTPGUP alt+pgup", KSTRLEN - 1);
419 break;
420 case KEY_ALTRIGHT:
421 strnz__cpy(kstr, "KEY_ALTRIGHT alt+right", KSTRLEN - 1);
422 break;
423 case KEY_ALTUP:
424 strnz__cpy(kstr, "KEY_ALTUP alt+up", KSTRLEN - 1);
425 break;
426 case KEY_ALTF(1):
427 strnz__cpy(kstr, "KEY_ALTF1 alt+F1", KSTRLEN - 1);
428 break;
429 case KEY_ALTF(2):
430 strnz__cpy(kstr, "KEY_ALTF1 alt+F2", KSTRLEN - 1);
431 break;
432 case KEY_ALTF(3):
433 strnz__cpy(kstr, "KEY_ALTF3 alt+F3", KSTRLEN - 1);
434 break;
435 case KEY_ALTF(4):
436 strnz__cpy(kstr, "KEY_ALTF4 alt+F4", KSTRLEN - 1);
437 break;
438 case KEY_ALTF(5):
439 strnz__cpy(kstr, "KEY_ALTF5 alt+F5", KSTRLEN - 1);
440 break;
441 case KEY_ALTF(6):
442 strnz__cpy(kstr, "KEY_ALTF6 alt+F6", KSTRLEN - 1);
443 break;
444 case KEY_ALTF(7):
445 strnz__cpy(kstr, "KEY_ALTF7 alt+F7", KSTRLEN - 1);
446 break;
447 case KEY_ALTF(8):
448 strnz__cpy(kstr, "KEY_ALTF8 alt+F8", KSTRLEN - 1);
449 break;
450 case KEY_ALTF(9):
451 strnz__cpy(kstr, "KEY_ALTF9 alt+F9", KSTRLEN - 1);
452 break;
453 case KEY_ALTF(10):
454 strnz__cpy(kstr, "KEY_ALTF10 alt+F10", KSTRLEN - 1);
455 break;
456 case KEY_ALTF(11):
457 strnz__cpy(kstr, "KEY_ALTF11 alt+F11", KSTRLEN - 1);
458 break;
459 case KEY_ALTF(12):
460 strnz__cpy(kstr, "KEY_ALTF12 alt+F12", KSTRLEN - 1);
461 break;
462 case KEY_MOUSE:
463 action[0] = '\0';
464 if (getmouse(&event) == OK) {
465 switch (event.bstate) {
466 case BUTTON1_PRESSED:
467 strnz__cpy(action, "Button 1 pressed", KSTRLEN - 1);
468 break;
469 case BUTTON1_RELEASED:
470 strnz__cpy(action, "Button 1 released", KSTRLEN - 1);
471 break;
472 case BUTTON1_CLICKED:
473 strnz__cpy(action, "Button 1 clicked", KSTRLEN - 1);
474 break;
475 case BUTTON1_DOUBLE_CLICKED:
476 strnz__cpy(action, "Button 1 double-clicked", KSTRLEN - 1);
477 break;
478 case BUTTON2_PRESSED:
479 strnz__cpy(action, "Button 2 pressed", KSTRLEN - 1);
480 break;
481 case BUTTON2_RELEASED:
482 strnz__cpy(action, "Button 2 released", KSTRLEN - 1);
483 break;
484 case BUTTON2_CLICKED:
485 strnz__cpy(action, "Button 2 clicked", KSTRLEN - 1);
486 break;
487 case BUTTON2_DOUBLE_CLICKED:
488 strnz__cpy(action, "Button 2 double-clicked", KSTRLEN - 1);
489 break;
490 case BUTTON3_PRESSED:
491 strnz__cpy(action, "Button 3 pressed", KSTRLEN - 1);
492 break;
493 case BUTTON3_RELEASED:
494 strnz__cpy(action, "Button 3 released", KSTRLEN - 1);
495 break;
496 case BUTTON3_CLICKED:
497 strnz__cpy(action, "Button 3 clicked", KSTRLEN - 1);
498 break;
499 case BUTTON3_DOUBLE_CLICKED:
500 strnz__cpy(action, "Button 3 double-clicked", KSTRLEN - 1);
501 break;
502 case BUTTON4_PRESSED:
503 strnz__cpy(action, "Button 4 pressed", KSTRLEN - 1);
504 break;
505 case BUTTON4_RELEASED:
506 strnz__cpy(action, "Button 4 released", KSTRLEN - 1);
507 break;
508 case BUTTON4_CLICKED:
509 strnz__cpy(action, "Button 4 clicked", KSTRLEN - 1);
510 break;
511 case BUTTON4_DOUBLE_CLICKED:
512 strnz__cpy(action, "Button 4 double-clicked", KSTRLEN - 1);
513 break;
514 case BUTTON5_PRESSED:
515 strnz__cpy(action, "Scroll Up", KSTRLEN - 1);
516 break;
517 default:
518 break;
519 }
520 mvwaddstr(win, 6, 3, " Action:");
521 mvwaddstr(win, 6, 16, action);
522 wclrtoeol(win);
523
524 strnz__cpy(tmp, " With Key:", MAXLEN - 1);
525 if (event.bstate & BUTTON_SHIFT)
526 strnz__cat(tmp, " Shift", MAXLEN - 1);
527 if (event.bstate & BUTTON_CTRL)
528 strnz__cat(tmp, " Ctrl", MAXLEN - 1);
529 if (event.bstate & BUTTON_ALT)
530 strnz__cat(tmp, " Alt", MAXLEN - 1);
531 mvwaddstr(win, 3, 4, tmp);
532 wclrtoeol(win);
533 if (wenclose(win, event.y, event.x)) {
534 sprintf(tmp, " Inside Win: y: %3d, x: %3d",
535 event.y - begy, event.x - begx);
536 } else {
537 sprintf(tmp, " Outside Win: y: %3d, x: %3d",
538 event.y - begy, event.x - begx);
539 }
540 mvwaddstr(win, 4, 4, tmp);
541 wclrtoeol(win);
542 wmove(win, 5, 0);
543 wclrtoeol(win);
544 wmove(win, 7, 0);
545 wclrtoeol(win);
546 }
547 break;
548 default:
549 break;
550 }
551 if (c != KEY_MOUSE) {
552
553 sprintf(tmp, " Octal: %3o", c);
554 mvwaddstr(win, 3, 4, tmp);
555 wclrtoeol(win);
556
557 sprintf(tmp, " Decimal: %3d", c);
558 mvwaddstr(win, 4, 4, tmp);
559 wclrtoeol(win);
560
561 sprintf(tmp, " Hex: %3x", c);
562 mvwaddstr(win, 5, 4, tmp);
563 wclrtoeol(win);
564
565 if (kstr[0]) {
566 sprintf(tmp, "Description: %s", kstr);
567 } else {
568 sprintf(tmp, " ASCII: %c", c);
569 }
570 mvwaddstr(win, 6, 3, tmp);
571 wclrtoeol(win);
572 mvwaddstr(win, 7, 2, "Key bound To: ");
573 wclrtoeol(win);
574 mvwaddstr(win, 7, 16, s ? s : "Not Bound");
575 // wrefresh(win);
576 update_panels();
577 doupdate();
578 }
579 if (c == KEY_ALTEND) {
580 usleep(100000);
581 break;
582 }
583 c = '\0';
584 }
585 win_del();
586 return 0;
587}
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
KEY_ALTLEFT
#define KEY_ALTLEFT
Definition cm.h:563
KEY_ALTDOWN
#define KEY_ALTDOWN
Definition cm.h:564
win_win
WINDOW * win_win[MAXWIN]
Definition dwin.c:52
KEY_ALTHOME
#define KEY_ALTHOME
Definition cm.h:557
em1
char em1[MAXLEN]
Definition dwin.c:176
CC_NT
cchar_t CC_NT
Definition dwin.c:204
KEY_ALTPGDN
#define KEY_ALTPGDN
Definition cm.h:561
KEY_ALTRIGHT
#define KEY_ALTRIGHT
Definition cm.h:565
KEY_ALTDEL
#define KEY_ALTDEL
Definition cm.h:559
KEY_ALTUP
#define KEY_ALTUP
Definition cm.h:562
win_ptr
int win_ptr
Definition dwin.c:164
KEY_ALTPGUP
#define KEY_ALTPGUP
Definition cm.h:558
em0
char em0[MAXLEN]
Definition dwin.c:175
KEY_ALTF
#define KEY_ALTF(n)
Definition cm.h:503
CC_NT_REV
cchar_t CC_NT_REV
Definition dwin.c:205
KEY_ALTINS
#define KEY_ALTINS
Definition cm.h:556
em2
char em2[MAXLEN]
Definition dwin.c:177
TRUE
#define TRUE
Definition iloan.c:19
KSTRLEN
#define KSTRLEN
Definition curskeys.c:14
MAXLEN
#define MAXLEN
Definition curskeys.c:15
win_del
void win_del()
Delete the current window and its associated box window.
Definition dwin.c:1179
box_new
int box_new(int, int, int, int, char *)
Create a new window with optional box and title.
Definition dwin.c:967
Perror
int Perror(char *)
Display a simple error message window or print to stderr.
Definition dwin.c:1526
display_error
int display_error(char *, char *, char *, char *)
Display an error message window or print to stderr.
Definition dwin.c:1467
strnz__cpy
size_t strnz__cpy(char *, const char *, size_t)
safer alternative to strncpy
Definition futil.c:544
strnz__cat
size_t strnz__cat(char *, const char *, size_t)
safer alternative to strncat
Definition futil.c:573

References box_new(), CC_NT, CC_NT_REV, display_error(), em0, em1, em2, handle_signal(), Perror(), sig_received, strnz__cat(), strnz__cpy(), win_del(), win_ptr, and win_win.

Referenced by main(), and menu_cmd_processor().

Here is the call graph for this function:
Here is the caller graph for this function: