lib/libmenu/menu.c

   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
  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 *
 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
 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 *
 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
 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 *
 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
 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 *
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 *
 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
 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 *
 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
 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
 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
 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 **
 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
 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
 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
 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
 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 }