1 /* $NetBSD: menu.c,v 1.18 2012/12/30 12:27:09 blymn Exp $ */
2
3 /*-
4 * Copyright (c) 1998-1999 Brett Lymn (blymn@baea.com.au, brett_lymn@yahoo.com.au)
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 *
27 */
28
29 #include <sys/cdefs.h>
30 __RCSID("$NetBSD: menu.c,v 1.18 2012/12/30 12:27:09 blymn Exp $");
31
32 #include <ctype.h>
33 #include <menu.h>
34 #include <string.h>
35 #include <stdlib.h>
36 #include "internals.h"
37
38 MENU _menui_default_menu = {
39 16, /* number of item rows that will fit in window */
40 1, /* number of columns of items that will fit in window */
41 0, /* number of rows of items we have */
42 0, /* number of columns of items we have */
43 0, /* current cursor row */
44 0, /* current cursor column */
45 {NULL, 0}, /* mark string */
46 {NULL, 0}, /* unmark string */
47 O_ONEVALUE, /* menu options */
48 NULL, /* the pattern buffer */
49 0, /* length of pattern buffer */
50 0, /* the length of matched buffer */
51 0, /* is the menu posted? */
52 A_REVERSE, /* menu foreground */
53 A_NORMAL, /* menu background */
54 A_UNDERLINE, /* unselectable menu item */
55 ' ', /* filler between name and description */
56 NULL, /* user defined pointer */
57 0, /* top row of menu */
58 0, /* widest item in the menu */
59 0, /* the width of a menu column */
60 0, /* number of items attached to the menu */
61 NULL, /* items in the menu */
62 0, /* current menu item */
63 0, /* currently in a hook function */
64 NULL, /* function called when menu posted */
65 NULL, /* function called when menu is unposted */
66 NULL, /* function called when current item changes */
67 NULL, /* function called when current item changes */
68 NULL, /* the menu window */
69 NULL, /* the menu subwindow */
70 NULL, /* the window to write to */
71 };
72
73
74
75 /*
76 * Set the menu mark character
77 */
78 int
set_menu_mark(MENU * m,char * mark)79 set_menu_mark(MENU *m, char *mark)
80 {
81 MENU *menu = m;
82
83 if (m == NULL) menu = &_menui_default_menu;
84
85 /* if there was an old mark string, free it first */
86 if (menu->mark.string != NULL) free(menu->mark.string);
87
88 if ((menu->mark.string = (char *) malloc(strlen(mark) + 1)) == NULL)
89 return E_SYSTEM_ERROR;
90
91 strcpy(menu->mark.string, mark);
92 menu->mark.length = strlen(mark);
93
94 /* max item size may have changed - recalculate. */
95 _menui_max_item_size(menu);
96 return E_OK;
97 }
98
99 /*
100 * Return the menu mark string for the menu.
101 */
102 char *
menu_mark(MENU * menu)103 menu_mark(MENU *menu)
104 {
105 if (menu == NULL)
106 return _menui_default_menu.mark.string;
107 else
108 return menu->mark.string;
109 }
110
111 /*
112 * Set the menu unmark character
113 */
114 int
set_menu_unmark(MENU * m,char * mark)115 set_menu_unmark(MENU *m, char *mark)
116 {
117 MENU *menu = m;
118
119 if (m == NULL) menu = &_menui_default_menu;
120
121 /* if there was an old mark string, free it first */
122 if (menu->unmark.string != NULL) free(menu->unmark.string);
123
124 if ((menu->unmark.string = (char *) malloc(strlen(mark) + 1)) == NULL)
125 return E_SYSTEM_ERROR;
126
127 strcpy(menu->unmark.string, mark);
128 menu->unmark.length = strlen(mark);
129 /* max item size may have changed - recalculate. */
130 _menui_max_item_size(menu);
131 return E_OK;
132 }
133
134 /*
135 * Return the menu unmark string for the menu.
136 */
137 char *
menu_unmark(MENU * menu)138 menu_unmark(MENU *menu)
139 {
140 if (menu == NULL)
141 return _menui_default_menu.unmark.string;
142 else
143 return menu->unmark.string;
144 }
145
146 /*
147 * Set the menu window to the window passed.
148 */
149 int
set_menu_win(MENU * menu,WINDOW * win)150 set_menu_win(MENU *menu, WINDOW *win)
151 {
152 if (menu == NULL) {
153 _menui_default_menu.menu_win = win;
154 _menui_default_menu.scrwin = win;
155 } else {
156 if (menu->posted == TRUE) {
157 return E_POSTED;
158 } else {
159 menu->menu_win = win;
160 menu->scrwin = win;
161 }
162 }
163
164 return E_OK;
165 }
166
167 /*
168 * Return the pointer to the menu window
169 */
170 WINDOW *
menu_win(MENU * menu)171 menu_win(MENU *menu)
172 {
173 if (menu == NULL)
174 return _menui_default_menu.menu_win;
175 else
176 return menu->menu_win;
177 }
178
179 /*
180 * Set the menu subwindow for the menu.
181 */
182 int
set_menu_sub(MENU * menu,WINDOW * sub)183 set_menu_sub(MENU *menu, WINDOW *sub)
184 {
185 if (menu == NULL) {
186 _menui_default_menu.menu_subwin = sub;
187 _menui_default_menu.scrwin = sub;
188 } else {
189 if (menu->posted == TRUE)
190 return E_POSTED;
191
192 menu->menu_subwin = sub;
193 menu->scrwin = sub;
194 }
195
196 return E_OK;
197 }
198
199 /*
200 * Return the subwindow pointer for the menu
201 */
202 WINDOW *
menu_sub(MENU * menu)203 menu_sub(MENU *menu)
204 {
205 if (menu == NULL)
206 return _menui_default_menu.menu_subwin;
207 else
208 return menu->menu_subwin;
209 }
210
211 /*
212 * Set the maximum number of rows and columns of items that may be displayed.
213 */
214 int
set_menu_format(MENU * param_menu,int rows,int cols)215 set_menu_format(MENU *param_menu, int rows, int cols)
216 {
217 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
218
219 menu->rows = rows;
220 menu->cols = cols;
221
222 if (menu->items != NULL)
223 /* recalculate the item neighbours */
224 return _menui_stitch_items(menu);
225
226 return E_OK;
227 }
228
229 /*
230 * Return the max number of rows and cols that may be displayed.
231 */
232 void
menu_format(MENU * param_menu,int * rows,int * cols)233 menu_format(MENU *param_menu, int *rows, int *cols)
234 {
235 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
236
237 *rows = menu->rows;
238 *cols = menu->cols;
239 }
240
241 /*
242 * Set the user defined function to call when a menu is posted.
243 */
244 int
set_menu_init(MENU * menu,Menu_Hook func)245 set_menu_init(MENU *menu, Menu_Hook func)
246 {
247 if (menu == NULL)
248 _menui_default_menu.menu_init = func;
249 else
250 menu->menu_init = func;
251 return E_OK;
252 }
253
254 /*
255 * Return the pointer to the menu init function.
256 */
257 Menu_Hook
menu_init(MENU * menu)258 menu_init(MENU *menu)
259 {
260 if (menu == NULL)
261 return _menui_default_menu.menu_init;
262 else
263 return menu->menu_init;
264 }
265
266 /*
267 * Set the user defined function called when a menu is unposted.
268 */
269 int
set_menu_term(MENU * menu,Menu_Hook func)270 set_menu_term(MENU *menu, Menu_Hook func)
271 {
272 if (menu == NULL)
273 _menui_default_menu.menu_term = func;
274 else
275 menu->menu_term = func;
276 return E_OK;
277 }
278
279 /*
280 * Return the user defined menu termination function pointer.
281 */
282 Menu_Hook
menu_term(MENU * menu)283 menu_term(MENU *menu)
284 {
285 if (menu == NULL)
286 return _menui_default_menu.menu_term;
287 else
288 return menu->menu_term;
289 }
290
291 /*
292 * Return the current menu options set.
293 */
294 OPTIONS
menu_opts(MENU * menu)295 menu_opts(MENU *menu)
296 {
297 if (menu == NULL)
298 return _menui_default_menu.opts;
299 else
300 return menu->opts;
301 }
302
303 /*
304 * Set the menu options to the given options.
305 */
306 int
set_menu_opts(MENU * param_menu,OPTIONS opts)307 set_menu_opts(MENU *param_menu, OPTIONS opts)
308 {
309 int i, seen;
310 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
311 OPTIONS old_opts = menu->opts;
312
313 menu->opts = opts;
314
315 /*
316 * If the radio option is selected then make sure only one
317 * item is actually selected in the items.
318 */
319 if (((opts & O_RADIO) == O_RADIO) && (menu->items != NULL) &&
320 (menu->items[0] != NULL)) {
321 seen = 0;
322 for (i = 0; i < menu->item_count; i++) {
323 if (menu->items[i]->selected == 1) {
324 if (seen == 0) {
325 seen = 1;
326 } else {
327 menu->items[i]->selected = 0;
328 }
329 }
330 }
331
332 /* if none selected, select the first item */
333 if (seen == 0)
334 menu->items[0]->selected = 1;
335 }
336
337 if ((menu->opts & O_ROWMAJOR) != (old_opts & O_ROWMAJOR))
338 /* changed menu layout - need to recalc neighbours */
339 _menui_stitch_items(menu);
340
341 return E_OK;
342 }
343
344 /*
345 * Turn on the options in menu given by opts.
346 */
347 int
menu_opts_on(MENU * param_menu,OPTIONS opts)348 menu_opts_on(MENU *param_menu, OPTIONS opts)
349 {
350 int i, seen;
351 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
352 OPTIONS old_opts = menu->opts;
353
354 menu->opts |= opts;
355
356 /*
357 * If the radio option is selected then make sure only one
358 * item is actually selected in the items.
359 */
360 if (((opts & O_RADIO) == O_RADIO) && (menu->items != NULL) &&
361 (menu->items[0] != NULL)) {
362 seen = 0;
363 for (i = 0; i < menu->item_count; i++) {
364 if (menu->items[i]->selected == 1) {
365 if (seen == 0) {
366 seen = 1;
367 } else {
368 menu->items[i]->selected = 0;
369 }
370 }
371 }
372 /* if none selected then select the top item */
373 if (seen == 0)
374 menu->items[0]->selected = 1;
375 }
376
377 if ((menu->items != NULL) &&
378 (menu->opts & O_ROWMAJOR) != (old_opts & O_ROWMAJOR))
379 /* changed menu layout - need to recalc neighbours */
380 _menui_stitch_items(menu);
381
382 return E_OK;
383 }
384
385 /*
386 * Turn off the menu options given in opts.
387 */
388 int
menu_opts_off(MENU * param_menu,OPTIONS opts)389 menu_opts_off(MENU *param_menu, OPTIONS opts)
390 {
391 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
392 OPTIONS old_opts = menu->opts;
393
394 menu->opts &= ~(opts);
395
396 if ((menu->items != NULL ) &&
397 (menu->opts & O_ROWMAJOR) != (old_opts & O_ROWMAJOR))
398 /* changed menu layout - need to recalc neighbours */
399 _menui_stitch_items(menu);
400
401 return E_OK;
402 }
403
404 /*
405 * Return the menu pattern buffer.
406 */
407 char *
menu_pattern(MENU * menu)408 menu_pattern(MENU *menu)
409 {
410 if (menu == NULL)
411 return _menui_default_menu.pattern;
412 else
413 return menu->pattern;
414 }
415
416 /*
417 * Set the menu pattern buffer to pat and attempt to match the pattern in
418 * the item list.
419 */
420 int
set_menu_pattern(MENU * param_menu,char * pat)421 set_menu_pattern(MENU *param_menu, char *pat)
422 {
423 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
424 char *p = pat;
425
426 /* check pattern is all printable characters */
427 while (*p)
428 if (!isprint((unsigned char) *p++)) return E_BAD_ARGUMENT;
429
430 if ((menu->pattern = (char *) realloc(menu->pattern,
431 sizeof(char) * strlen(pat) + 1)) == NULL)
432 return E_SYSTEM_ERROR;
433
434 strcpy(menu->pattern, pat);
435 menu->plen = strlen(pat);
436
437 /* search item list for pat here */
438 return _menui_match_items(menu, MATCH_FORWARD, &menu->cur_item);
439 }
440
441 /*
442 * Allocate a new menu structure and fill it in.
443 */
444 MENU *
new_menu(ITEM ** items)445 new_menu(ITEM **items)
446 {
447 MENU *the_menu;
448 char mark[2];
449
450 if ((the_menu = (MENU *)malloc(sizeof(MENU))) == NULL)
451 return NULL;
452
453 /* copy the defaults */
454 (void)memcpy(the_menu, &_menui_default_menu, sizeof(MENU));
455
456 /* set a default window if none already set. */
457 if (the_menu->menu_win == NULL)
458 the_menu->scrwin = stdscr;
459
460 /* make a private copy of the mark string */
461 if (_menui_default_menu.mark.string != NULL) {
462 if ((the_menu->mark.string =
463 (char *) malloc((unsigned) _menui_default_menu.mark.length + 1))
464 == NULL) {
465 free(the_menu);
466 return NULL;
467 }
468
469 strlcpy(the_menu->mark.string, _menui_default_menu.mark.string,
470 (unsigned) _menui_default_menu.mark.length + 1);
471 }
472
473 /* make a private copy of the unmark string too */
474 if (_menui_default_menu.unmark.string != NULL) {
475 if ((the_menu->unmark.string =
476 (char *) malloc((unsigned) _menui_default_menu.unmark.length + 1))
477 == NULL) {
478 free(the_menu);
479 return NULL;
480 }
481
482 strlcpy(the_menu->unmark.string,
483 _menui_default_menu.unmark.string,
484 (unsigned) _menui_default_menu.unmark.length+ 1 );
485 }
486
487 /* default mark needs to be set */
488 mark[0] = '-';
489 mark[1] = '\0';
490
491 set_menu_mark(the_menu, mark);
492
493 /* now attach the items, if any */
494 if (items != NULL) {
495 if(set_menu_items(the_menu, items) < 0) {
496 if (the_menu->mark.string != NULL)
497 free(the_menu->mark.string);
498 if (the_menu->unmark.string != NULL)
499 free(the_menu->unmark.string);
500 free(the_menu);
501 return NULL;
502 }
503 }
504
505 return the_menu;
506 }
507
508 /*
509 * Free up storage allocated to the menu object and destroy it.
510 */
511 int
free_menu(MENU * menu)512 free_menu(MENU *menu)
513 {
514 int i;
515
516 if (menu == NULL)
517 return E_BAD_ARGUMENT;
518
519 if (menu->posted != 0)
520 return E_POSTED;
521
522 if (menu->pattern != NULL)
523 free(menu->pattern);
524
525 if (menu->mark.string != NULL)
526 free(menu->mark.string);
527
528 if (menu->items != NULL) {
529 /* disconnect the items from this menu */
530 for (i = 0; i < menu->item_count; i++) {
531 menu->items[i]->parent = NULL;
532 }
533 }
534
535 free(menu);
536 return E_OK;
537 }
538
539 /*
540 * Calculate the minimum window size for the menu.
541 */
542 int
scale_menu(MENU * param_menu,int * rows,int * cols)543 scale_menu(MENU *param_menu, int *rows, int *cols)
544 {
545 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
546
547 if (menu->items == NULL)
548 return E_BAD_ARGUMENT;
549
550 /* calculate the max item size */
551 _menui_max_item_size(menu);
552
553 *rows = menu->rows;
554 *cols = menu->cols * menu->max_item_width;
555
556 /*
557 * allow for spacing between columns...
558 */
559 *cols += (menu->cols - 1);
560
561 return E_OK;
562 }
563
564 /*
565 * Set the menu item list to the one given.
566 */
567 int
set_menu_items(MENU * param_menu,ITEM ** items)568 set_menu_items(MENU *param_menu, ITEM **items)
569 {
570 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
571 int i, new_count = 0, sel_count = 0;
572
573 /* don't change if menu is posted */
574 if (menu->posted == 1)
575 return E_POSTED;
576
577 /* count the new items and validate none are connected already */
578 while (items[new_count] != NULL) {
579 if ((items[new_count]->parent != NULL) &&
580 (items[new_count]->parent != menu))
581 return E_CONNECTED;
582 if (items[new_count]->selected == 1)
583 sel_count++;
584 new_count++;
585 }
586
587 /*
588 * don't allow multiple selected items if menu is radio
589 * button style.
590 */
591 if (((menu->opts & O_RADIO) == O_RADIO) &&
592 (sel_count > 1))
593 return E_BAD_ARGUMENT;
594
595 /* if there were items connected then disconnect them. */
596 if (menu->items != NULL) {
597 for (i = 0; i < menu->item_count; i++) {
598 menu->items[i]->parent = NULL;
599 menu->items[i]->index = -1;
600 }
601 }
602
603 menu->item_count = new_count;
604
605 /* connect the new items to the menu */
606 for (i = 0; i < new_count; i++) {
607 items[i]->parent = menu;
608 items[i]->index = i;
609 }
610
611 menu->items = items;
612 menu->cur_item = 0; /* reset current item just in case */
613 menu->top_row = 0; /* and the top row too */
614 if (menu->pattern != NULL) { /* and the pattern buffer....sigh */
615 free(menu->pattern);
616 menu->plen = 0;
617 menu->match_len = 0;
618 }
619
620 /*
621 * make sure at least one item is selected on a radio
622 * button style menu.
623 */
624 if (((menu->opts & O_RADIO) == O_RADIO) && (sel_count == 0))
625 menu->items[0]->selected = 1;
626
627
628 _menui_stitch_items(menu); /* recalculate the item neighbours */
629
630 return E_OK;
631 }
632
633 /*
634 * Return the pointer to the menu items array.
635 */
636 ITEM **
menu_items(MENU * menu)637 menu_items(MENU *menu)
638 {
639 if (menu == NULL)
640 return _menui_default_menu.items;
641 else
642 return menu->items;
643 }
644
645 /*
646 * Return the count of items connected to the menu
647 */
648 int
item_count(MENU * menu)649 item_count(MENU *menu)
650 {
651 if (menu == NULL)
652 return _menui_default_menu.item_count;
653 else
654 return menu->item_count;
655 }
656
657 /*
658 * Set the menu top row to be the given row. The current item becomes the
659 * leftmost item on that row in the menu.
660 */
661 int
set_top_row(MENU * param_menu,int row)662 set_top_row(MENU *param_menu, int row)
663 {
664 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
665 int i, cur_item, state = E_SYSTEM_ERROR;
666
667 if (row > menu->item_rows)
668 return E_BAD_ARGUMENT;
669
670 if (menu->items == NULL)
671 return E_NOT_CONNECTED;
672
673 if (menu->in_init == 1)
674 return E_BAD_STATE;
675
676 cur_item = 0;
677
678 for (i = 0; i < menu->item_count; i++) {
679 /* search for first item that matches row - this will be
680 the current item. */
681 if (row == menu->items[i]->row) {
682 cur_item = i;
683 state = E_OK;
684 break; /* found what we want - no need to go further */
685 }
686 }
687
688 menu->in_init = 1; /* just in case we call the init/term routines */
689
690 if (menu->posted == 1) {
691 if (menu->menu_term != NULL)
692 menu->menu_term(menu);
693 if (menu->item_term != NULL)
694 menu->item_term(menu);
695 }
696
697 menu->cur_item = cur_item;
698 menu->top_row = row;
699
700 if (menu->posted == 1) {
701 if (menu->menu_init != NULL)
702 menu->menu_init(menu);
703 if (menu->item_init != NULL)
704 menu->item_init(menu);
705 }
706
707 menu->in_init = 0;
708
709 /* this should always be E_OK unless we are really screwed up */
710 return state;
711 }
712
713 /*
714 * Return the current top row number.
715 */
716 int
top_row(MENU * param_menu)717 top_row(MENU *param_menu)
718 {
719 MENU *menu = (param_menu != NULL) ? param_menu : &_menui_default_menu;
720
721 if (menu->items == NULL)
722 return E_NOT_CONNECTED;
723
724 return menu->top_row;
725 }
726
727 /*
728 * Position the cursor at the correct place in the menu.
729 *
730 */
731 int
pos_menu_cursor(MENU * menu)732 pos_menu_cursor(MENU *menu)
733 {
734 int movx, maxmark;
735
736 if (menu == NULL)
737 return E_BAD_ARGUMENT;
738
739 maxmark = max(menu->mark.length, menu->unmark.length);
740 movx = maxmark + (menu->items[menu->cur_item]->col
741 * (menu->col_width + 1));
742
743 if (menu->match_len > 0)
744 movx += menu->match_len - 1;
745
746 wmove(menu->scrwin,
747 menu->items[menu->cur_item]->row - menu->top_row, movx);
748
749 return E_OK;
750 }
751