| /* -*- c -*- ------------------------------------------------------------- * |
| * |
| * Copyright 2004-2005 Murali Krishnan Ganapathy - All Rights Reserved |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation, Inc., 53 Temple Place Ste 330, |
| * Boston MA 02111-1307, USA; either version 2 of the License, or |
| * (at your option) any later version; incorporated herein by reference. |
| * |
| * ----------------------------------------------------------------------- */ |
| |
| #include "cmenu.h" |
| #include "com32io.h" |
| #include <stdlib.h> |
| #include <console.h> |
| |
| // Local Variables |
| static pt_menusystem ms; // Pointer to the menusystem |
| char TITLESTR[] = |
| "COMBOOT Menu System for SYSLINUX developed by Murali Krishnan Ganapathy"; |
| char TITLELONG[] = " TITLE too long "; |
| char ITEMLONG[] = " ITEM too long "; |
| char ACTIONLONG[] = " ACTION too long "; |
| char STATUSLONG[] = " STATUS too long "; |
| char EMPTYSTR[] = ""; |
| |
| /* Forward declarations */ |
| int calc_visible(pt_menu menu, int first); |
| int next_visible(pt_menu menu, int index); |
| int prev_visible(pt_menu menu, int index); |
| int next_visible_sep(pt_menu menu, int index); |
| int prev_visible_sep(pt_menu menu, int index); |
| int calc_first_early(pt_menu menu, int curr); |
| int calc_first_late(pt_menu menu, int curr); |
| int isvisible(pt_menu menu, int first, int curr); |
| |
| /* Basic Menu routines */ |
| |
| // This is same as inputc except it honors the ontimeout handler |
| // and calls it when needed. For the callee, there is no difference |
| // as this will not return unless a key has been pressed. |
| static int getch(void) |
| { |
| t_timeout_handler th; |
| int key; |
| unsigned long i; |
| |
| // Wait until keypress if no handler specified |
| if ((ms->ontimeout == NULL) && (ms->ontotaltimeout == NULL)) |
| return get_key(stdin, 0); |
| |
| th = ms->ontimeout; |
| for (;;) { |
| for (i = 0; i < ms->tm_numsteps; i++) { |
| key = get_key(stdin, ms->tm_stepsize); |
| if (key != KEY_NONE) |
| return key; |
| |
| if ((ms->tm_total_timeout == 0) || (ms->ontotaltimeout == NULL)) |
| continue; // Dont bother with calculations if no handler |
| ms->tm_sofar_timeout += ms->tm_stepsize; |
| if (ms->tm_sofar_timeout >= ms->tm_total_timeout) { |
| th = ms->ontotaltimeout; |
| ms->tm_sofar_timeout = 0; |
| break; // Get out of the for loop |
| } |
| } |
| if (!th) |
| continue; // no handler |
| key = th(); |
| switch (key) { |
| case CODE_ENTER: // Pretend user hit enter |
| return KEY_ENTER; |
| case CODE_ESCAPE: // Pretend user hit escape |
| return KEY_ESC; |
| default: |
| break; |
| } |
| } |
| return KEY_NONE; |
| } |
| |
| int find_shortcut(pt_menu menu, uchar shortcut, int index) |
| // Find the next index with specified shortcut key |
| { |
| int ans; |
| pt_menuitem mi; |
| |
| // Garbage in garbage out |
| if ((index < 0) || (index >= menu->numitems)) |
| return index; |
| ans = index + 1; |
| // Go till end of menu |
| while (ans < menu->numitems) { |
| mi = menu->items[ans]; |
| if ((mi->action == OPT_INVISIBLE) || (mi->action == OPT_SEP) |
| || (mi->shortcut != shortcut)) |
| ans++; |
| else |
| return ans; |
| } |
| // Start at the beginning and try again |
| ans = 0; |
| while (ans < index) { |
| mi = menu->items[ans]; |
| if ((mi->action == OPT_INVISIBLE) || (mi->action == OPT_SEP) |
| || (mi->shortcut != shortcut)) |
| ans++; |
| else |
| return ans; |
| } |
| return index; // Sorry not found |
| } |
| |
| /* Redraw background and title */ |
| static void reset_ui(void) |
| { |
| uchar tpos; |
| |
| cls(); |
| clearwindow(ms->minrow, ms->mincol, ms->maxrow, ms->maxcol, |
| ms->fillchar, ms->fillattr); |
| |
| tpos = (ms->numcols - strlen(ms->title) - 1) >> 1; // center it on line |
| gotoxy(ms->minrow, ms->mincol); |
| cprint(ms->tfillchar, ms->titleattr, ms->numcols); |
| gotoxy(ms->minrow, ms->mincol + tpos); |
| csprint(ms->title, ms->titleattr); |
| |
| cursoroff(); |
| } |
| |
| /* |
| * Print a menu item |
| * |
| * attr[0] is non-hilite attr, attr[1] is highlight attr |
| */ |
| void printmenuitem(const char *str, uchar * attr) |
| { |
| int hlite = NOHLITE; // Initially no highlighting |
| |
| while (*str) { |
| switch (*str) { |
| case BELL: // No Bell Char |
| break; |
| case ENABLEHLITE: // Switch on highlighting |
| hlite = HLITE; |
| break; |
| case DISABLEHLITE: // Turn off highlighting |
| hlite = NOHLITE; |
| break; |
| default: |
| putch(*str, attr[hlite]); |
| } |
| str++; |
| } |
| } |
| |
| |
| /** |
| * print_line - Print a whole line in a menu |
| * @menu: current menu to handle |
| * @curr: index of the current entry highlighted |
| * @top: top coordinate of the @menu |
| * @left: left coordinate of the @menu |
| * @x: index in the menu of curr |
| * @row: row currently displayed |
| * @radio: radio item? |
| **/ |
| static void print_line(pt_menu menu, int curr, uchar top, uchar left, |
| int x, int row, bool radio) |
| { |
| pt_menuitem ci; |
| char fchar[6], lchar[6]; // The first and last char in for each entry |
| const char *str; // Item string (cf printmenuitem) |
| char sep[MENULEN]; // Separator (OPT_SEP) |
| uchar *attr; // Attribute |
| int menuwidth = menu->menuwidth + 3; |
| |
| if (row >= menu->menuheight) |
| return; |
| |
| ci = menu->items[x]; |
| |
| memset(sep, ms->box_horiz, menuwidth); |
| sep[menuwidth - 1] = 0; |
| |
| // Setup the defaults now |
| if (radio) { |
| fchar[0] = '\b'; |
| fchar[1] = SO; |
| fchar[2] = (x == curr ? RADIOSEL : RADIOUNSEL); |
| fchar[3] = SI; |
| fchar[4] = '\0'; // Unselected ( ) |
| lchar[0] = '\0'; // Nothing special after |
| attr = ms->normalattr; // Always same attribute |
| } else { |
| lchar[0] = fchar[0] = ' '; |
| lchar[1] = fchar[1] = '\0'; // fchar and lchar are just spaces |
| attr = (x == curr ? ms->reverseattr : ms->normalattr); // Normal attributes |
| } |
| str = ci->item; // Pointer to item string |
| switch (ci->action) // set up attr,str,fchar,lchar for everything |
| { |
| case OPT_INACTIVE: |
| if (radio) |
| attr = ms->inactattr; |
| else |
| attr = (x == curr ? ms->revinactattr : ms->inactattr); |
| break; |
| case OPT_SUBMENU: |
| if (radio) |
| break; // Not supported for radio menu |
| lchar[0] = '>'; |
| lchar[1] = 0; |
| break; |
| case OPT_RADIOMENU: |
| if (radio) |
| break; // Not supported for radio menu |
| lchar[0] = RADIOMENUCHAR; |
| lchar[1] = 0; |
| break; |
| case OPT_CHECKBOX: |
| if (radio) |
| break; // Not supported for radio menu |
| lchar[0] = '\b'; |
| lchar[1] = SO; |
| lchar[2] = (ci->itemdata.checked ? CHECKED : UNCHECKED); |
| lchar[3] = SI; |
| lchar[4] = 0; |
| break; |
| case OPT_SEP: |
| fchar[0] = '\b'; |
| fchar[1] = SO; |
| fchar[2] = LEFT_MIDDLE_BORDER; |
| fchar[3] = MIDDLE_BORDER; |
| fchar[4] = MIDDLE_BORDER; |
| fchar[5] = 0; |
| memset(sep, MIDDLE_BORDER, menuwidth); |
| sep[menuwidth - 1] = 0; |
| str = sep; |
| lchar[0] = MIDDLE_BORDER; |
| lchar[1] = RIGHT_MIDDLE_BORDER; |
| lchar[2] = SI; |
| lchar[3] = 0; |
| break; |
| case OPT_EXITMENU: |
| if (radio) |
| break; // Not supported for radio menu |
| fchar[0] = '<'; |
| fchar[1] = 0; |
| break; |
| default: // Just to keep the compiler happy |
| break; |
| } |
| |
| // Wipe area with spaces |
| gotoxy(top + row, left - 2); |
| cprint(ms->spacechar, attr[NOHLITE], menuwidth + 2); |
| |
| // Print first part |
| gotoxy(top + row, left - 2); |
| csprint(fchar, attr[NOHLITE]); |
| |
| // Print main part |
| gotoxy(top + row, left); |
| printmenuitem(str, attr); |
| |
| // Print last part |
| gotoxy(top + row, left + menuwidth - 1); |
| csprint(lchar, attr[NOHLITE]); |
| } |
| |
| // print the menu starting from FIRST |
| // will print a maximum of menu->menuheight items |
| static void printmenu(pt_menu menu, int curr, uchar top, uchar left, uchar first, bool radio) |
| { |
| int x, row; // x = index, row = position from top |
| int numitems, menuwidth; |
| pt_menuitem ci; |
| |
| numitems = calc_visible(menu, first); |
| if (numitems > menu->menuheight) |
| numitems = menu->menuheight; |
| |
| menuwidth = menu->menuwidth + 3; |
| clearwindow(top, left - 2, top + numitems + 1, left + menuwidth + 1, |
| ms->fillchar, ms->shadowattr); |
| drawbox(top - 1, left - 3, top + numitems, left + menuwidth, |
| ms->normalattr[NOHLITE]); |
| |
| // Menu title |
| x = (menuwidth - strlen(menu->title) - 1) >> 1; |
| gotoxy(top - 1, left + x); |
| printmenuitem(menu->title, ms->normalattr); |
| |
| // All lines in the menu |
| row = -1; // 1 less than inital value of x |
| for (x = first; x < menu->numitems; x++) { |
| ci = menu->items[x]; |
| if (ci->action == OPT_INVISIBLE) |
| continue; |
| row++; |
| if (row >= numitems) |
| break; // Already have enough number of items |
| print_line(menu, curr, top, left, x, row, radio); |
| } |
| // Check if we need to MOREABOVE and MOREBELOW to be added |
| // reuse x |
| row = 0; |
| x = next_visible_sep(menu, 0); // First item |
| if (!isvisible(menu, first, x)) // There is more above |
| { |
| row = 1; |
| gotoxy(top, left + menuwidth); |
| cprint(MOREABOVE, ms->normalattr[NOHLITE], 1); |
| } |
| x = prev_visible_sep(menu, menu->numitems); // last item |
| if (!isvisible(menu, first, x)) // There is more above |
| { |
| row = 1; |
| gotoxy(top + numitems - 1, left + menuwidth); |
| cprint(MOREBELOW, ms->normalattr[NOHLITE], 1); |
| } |
| // Add a scroll box |
| x = ((numitems - 1) * curr) / (menu->numitems); |
| if ((x > 0) && (row == 1)) { |
| gotoxy(top + x, left + menuwidth); |
| csprint("\016\141\017", ms->normalattr[NOHLITE]); |
| } |
| if (ms->handler) |
| ms->handler(ms, menu->items[curr]); |
| } |
| |
| void cleanupmenu(pt_menu menu, uchar top, uchar left, int numitems) |
| { |
| if (numitems > menu->menuheight) |
| numitems = menu->menuheight; |
| clearwindow(top, left - 2, top + numitems + 1, left + menu->menuwidth + 4, ms->fillchar, ms->fillattr); // Clear the shadow |
| clearwindow(top - 1, left - 3, top + numitems, left + menu->menuwidth + 3, ms->fillchar, ms->fillattr); // main window |
| } |
| |
| |
| /* Handle one menu */ |
| static pt_menuitem getmenuoption(pt_menu menu, uchar top, uchar left, uchar startopt, bool radio) |
| // Return item chosen or NULL if ESC was hit. |
| { |
| int prev, prev_first, curr, i, first, tmp; |
| int asc = 0; |
| bool redraw = true; // Need to draw the menu the first time |
| uchar numitems; |
| pt_menuitem ci; // Current item |
| t_handler_return hr; // Return value of handler |
| |
| numitems = calc_visible(menu, 0); |
| // Setup status line |
| gotoxy(ms->minrow + ms->statline, ms->mincol); |
| cprint(ms->spacechar, ms->statusattr[NOHLITE], ms->numcols); |
| |
| // Initialise current menu item |
| curr = next_visible(menu, startopt); |
| prev = curr; |
| |
| gotoxy(ms->minrow + ms->statline, ms->mincol); |
| cprint(ms->spacechar, ms->statusattr[NOHLITE], ms->numcols); |
| gotoxy(ms->minrow + ms->statline, ms->mincol); |
| printmenuitem(menu->items[curr]->status, ms->statusattr); |
| first = calc_first_early(menu, curr); |
| prev_first = first; |
| while (1) // Forever |
| { |
| /* Redraw everything if: |
| * + we need to scroll (take care of scroll bars, ...) |
| * + menuoption |
| */ |
| if (prev_first != first || redraw) { |
| printmenu(menu, curr, top, left, first, radio); |
| } else { |
| /* Redraw only the highlighted entry */ |
| print_line(menu, curr, top, left, prev, prev - first, radio); |
| print_line(menu, curr, top, left, curr, curr - first, radio); |
| } |
| redraw = false; |
| prev = curr; |
| prev_first = first; |
| ci = menu->items[curr]; |
| asc = getch(); |
| switch (asc) { |
| case KEY_CTRL('L'): |
| redraw = true; |
| break; |
| case KEY_HOME: |
| curr = next_visible(menu, 0); |
| first = calc_first_early(menu, curr); |
| break; |
| case KEY_END: |
| curr = prev_visible(menu, numitems - 1); |
| first = calc_first_late(menu, curr); |
| break; |
| case KEY_PGDN: |
| for (i = 0; i < 5; i++) |
| curr = next_visible(menu, curr + 1); |
| first = calc_first_late(menu, curr); |
| break; |
| case KEY_PGUP: |
| for (i = 0; i < 5; i++) |
| curr = prev_visible(menu, curr - 1); |
| first = calc_first_early(menu, curr); |
| break; |
| case KEY_UP: |
| curr = prev_visible(menu, curr - 1); |
| if (curr < first) |
| first = calc_first_early(menu, curr); |
| break; |
| case KEY_DOWN: |
| curr = next_visible(menu, curr + 1); |
| if (!isvisible(menu, first, curr)) |
| first = calc_first_late(menu, curr); |
| break; |
| case KEY_LEFT: |
| case KEY_ESC: |
| return NULL; |
| break; |
| case KEY_RIGHT: |
| case KEY_ENTER: |
| if (ci->action == OPT_INACTIVE) |
| break; |
| if (ci->action == OPT_CHECKBOX) |
| break; |
| if (ci->action == OPT_SEP) |
| break; |
| if (ci->action == OPT_EXITMENU) |
| return NULL; // As if we hit Esc |
| // If we are going into a radio menu, dont call handler, return ci |
| if (ci->action == OPT_RADIOMENU) |
| return ci; |
| if (ci->handler != NULL) // Do we have a handler |
| { |
| hr = ci->handler(ms, ci); |
| if (hr.refresh) // Do we need to refresh |
| { |
| // Cleanup menu using old number of items |
| cleanupmenu(menu, top, left, numitems); |
| // Recalculate the number of items |
| numitems = calc_visible(menu, 0); |
| // Reprint the menu |
| printmenu(menu, curr, top, left, first, radio); |
| } |
| if (hr.valid) |
| return ci; |
| } else |
| return ci; |
| break; |
| case SPACECHAR: |
| if (ci->action != OPT_CHECKBOX) |
| break; |
| ci->itemdata.checked = !ci->itemdata.checked; |
| if (ci->handler != NULL) // Do we have a handler |
| { |
| hr = ci->handler(ms, ci); |
| if (hr.refresh) // Do we need to refresh |
| { |
| // Cleanup menu using old number of items |
| cleanupmenu(menu, top, left, numitems); |
| // Recalculate the number of items |
| numitems = calc_visible(menu, 0); |
| // Reprint the menu |
| printmenu(menu, curr, top, left, first, radio); |
| } |
| } |
| break; |
| default: |
| // Check if this is a shortcut key |
| if (((asc >= 'A') && (asc <= 'Z')) || |
| ((asc >= 'a') && (asc <= 'z')) || |
| ((asc >= '0') && (asc <= '9'))) { |
| tmp = find_shortcut(menu, asc, curr); |
| if ((tmp > curr) && (!isvisible(menu, first, tmp))) |
| first = calc_first_late(menu, tmp); |
| if (tmp < curr) |
| first = calc_first_early(menu, tmp); |
| curr = tmp; |
| } else { |
| if (ms->keys_handler) // Call extra keys handler |
| ms->keys_handler(ms, menu->items[curr], asc); |
| |
| /* The handler may have changed the UI, reset it on exit */ |
| reset_ui(); |
| // Cleanup menu using old number of items |
| cleanupmenu(menu, top, left, numitems); |
| // Recalculate the number of items |
| numitems = calc_visible(menu, 0); |
| // Reprint the menu |
| printmenu(menu, curr, top, left, first, radio); |
| } |
| break; |
| } |
| // Update status line |
| /* Erase the previous status */ |
| gotoxy(ms->minrow + ms->statline, ms->mincol); |
| cprint(ms->spacechar, ms->statusattr[NOHLITE], ms->numcols); |
| /* Print the new status */ |
| gotoxy(ms->minrow + ms->statline, ms->mincol); |
| printmenuitem(menu->items[curr]->status, ms->statusattr); |
| } |
| return NULL; // Should never come here |
| } |
| |
| /* Handle the entire system of menu's. */ |
| pt_menuitem runmenusystem(uchar top, uchar left, pt_menu cmenu, uchar startopt, |
| uchar menutype) |
| /* |
| * cmenu |
| * Which menu should be currently displayed |
| * top,left |
| * What is the position of the top,left corner of the menu |
| * startopt |
| * which menu item do I start with |
| * menutype |
| * NORMALMENU or RADIOMENU |
| * |
| * Return Value: |
| * Returns a pointer to the final item chosen, or NULL if nothing chosen. |
| */ |
| { |
| pt_menuitem opt, choice; |
| uchar startat, mt; |
| uchar row, col; |
| |
| if (cmenu == NULL) |
| return NULL; |
| |
| startover: |
| // Set the menu height |
| cmenu->menuheight = ms->maxrow - top - 3; |
| if (cmenu->menuheight > ms->maxmenuheight) |
| cmenu->menuheight = ms->maxmenuheight; |
| if (menutype == NORMALMENU) |
| opt = getmenuoption(cmenu, top, left, startopt, false); |
| else // menutype == RADIOMENU |
| opt = getmenuoption(cmenu, top, left, startopt, true); |
| |
| if (opt == NULL) { |
| // User hit Esc |
| cleanupmenu(cmenu, top, left, calc_visible(cmenu, 0)); |
| return NULL; |
| } |
| // Are we done with the menu system? |
| if ((opt->action != OPT_SUBMENU) && (opt->action != OPT_RADIOMENU)) { |
| cleanupmenu(cmenu, top, left, calc_visible(cmenu, 0)); |
| return opt; // parent cleanup other menus |
| } |
| // Either radiomenu or submenu |
| // Do we have a valid menu number? The next hack uses the fact that |
| // itemdata.submenunum = itemdata.radiomenunum (since enum data type) |
| if (opt->itemdata.submenunum >= ms->nummenus) // This is Bad.... |
| { |
| gotoxy(12, 12); // Middle of screen |
| csprint("ERROR: Invalid submenu requested.", 0x07); |
| cleanupmenu(cmenu, top, left, calc_visible(cmenu, 0)); |
| return NULL; // Pretend user hit esc |
| } |
| // Call recursively for submenu |
| // Position the submenu below the current item, |
| // covering half the current window (horizontally) |
| row = ms->menus[(unsigned int)opt->itemdata.submenunum]->row; |
| col = ms->menus[(unsigned int)opt->itemdata.submenunum]->col; |
| if (row == 0xFF) |
| row = top + opt->index + 2; |
| if (col == 0xFF) |
| col = left + 3 + (cmenu->menuwidth >> 1); |
| mt = (opt->action == OPT_SUBMENU ? NORMALMENU : RADIOMENU); |
| startat = 0; |
| if ((opt->action == OPT_RADIOMENU) && (opt->data != NULL)) |
| startat = ((t_menuitem *) opt->data)->index; |
| |
| choice = runmenusystem(row, col, |
| ms->menus[(unsigned int)opt->itemdata.submenunum], |
| startat, mt); |
| if (opt->action == OPT_RADIOMENU) { |
| if (choice != NULL) |
| opt->data = (void *)choice; // store choice in data field |
| if (opt->handler != NULL) |
| opt->handler(ms, opt); |
| choice = NULL; // Pretend user hit esc |
| } |
| if (choice == NULL) // User hit Esc in submenu |
| { |
| // Startover |
| startopt = opt->index; |
| goto startover; |
| } else { |
| cleanupmenu(cmenu, top, left, calc_visible(cmenu, 0)); |
| return choice; |
| } |
| } |
| |
| // Finds the indexof the menu with given name |
| uchar find_menu_num(const char *name) |
| { |
| int i; |
| pt_menu m; |
| |
| if (name == NULL) |
| return (uchar) (-1); |
| for (i = 0; i < ms->nummenus; i++) { |
| m = ms->menus[i]; |
| if ((m->name) && (strcmp(m->name, name) == 0)) |
| return i; |
| } |
| return (uchar) (-1); |
| } |
| |
| // Run through all items and if they are submenus |
| // with a non-trivial "action" and trivial submenunum |
| // replace submenunum with the menu with name "action" |
| void fix_submenus(void) |
| { |
| int i, j; |
| pt_menu m; |
| pt_menuitem mi; |
| |
| i = 0; |
| for (i = 0; i < ms->nummenus; i++) { |
| m = ms->menus[i]; |
| for (j = 0; j < m->numitems; j++) { |
| mi = m->items[j]; |
| // if item is a submenu and has non-empty non-trivial data string |
| if (mi->data && strlen(mi->data) > 0 && |
| ((mi->action == OPT_SUBMENU) |
| || (mi->action == OPT_RADIOMENU))) { |
| mi->itemdata.submenunum = find_menu_num(mi->data); |
| } |
| } |
| } |
| } |
| |
| /* User Callable functions */ |
| |
| pt_menuitem showmenus(uchar startmenu) |
| { |
| pt_menuitem rv; |
| |
| fix_submenus(); // Fix submenu numbers incase nick names were used |
| |
| /* Turn autowrap off, to avoid scrolling the menu */ |
| printf(CSI "?7l"); |
| |
| // Setup screen for menusystem |
| reset_ui(); |
| |
| // Go, main menu cannot be a radio menu |
| rv = runmenusystem(ms->minrow + MENUROW, ms->mincol + MENUCOL, |
| ms->menus[(unsigned int)startmenu], 0, NORMALMENU); |
| |
| // Hide the garbage we left on the screen |
| cls(); |
| gotoxy(ms->minrow, ms->mincol); |
| cursoron(); |
| |
| // Return user choice |
| return rv; |
| } |
| |
| pt_menusystem init_menusystem(const char *title) |
| { |
| int i; |
| |
| ms = NULL; |
| ms = (pt_menusystem) malloc(sizeof(t_menusystem)); |
| if (ms == NULL) |
| return NULL; |
| ms->nummenus = 0; |
| // Initialise all menu pointers |
| for (i = 0; i < MAXMENUS; i++) |
| ms->menus[i] = NULL; |
| |
| ms->title = (char *)malloc(TITLELEN + 1); |
| if (title == NULL) |
| strcpy(ms->title, TITLESTR); // Copy string |
| else |
| strcpy(ms->title, title); |
| |
| // Timeout settings |
| ms->tm_stepsize = TIMEOUTSTEPSIZE; |
| ms->tm_numsteps = TIMEOUTNUMSTEPS; |
| |
| ms->normalattr[NOHLITE] = NORMALATTR; |
| ms->normalattr[HLITE] = NORMALHLITE; |
| |
| ms->reverseattr[NOHLITE] = REVERSEATTR; |
| ms->reverseattr[HLITE] = REVERSEHLITE; |
| |
| ms->inactattr[NOHLITE] = INACTATTR; |
| ms->inactattr[HLITE] = INACTHLITE; |
| |
| ms->revinactattr[NOHLITE] = REVINACTATTR; |
| ms->revinactattr[HLITE] = REVINACTHLITE; |
| |
| ms->statusattr[NOHLITE] = STATUSATTR; |
| ms->statusattr[HLITE] = STATUSHLITE; |
| |
| ms->statline = STATLINE; |
| ms->tfillchar = TFILLCHAR; |
| ms->titleattr = TITLEATTR; |
| |
| ms->fillchar = FILLCHAR; |
| ms->fillattr = FILLATTR; |
| ms->spacechar = SPACECHAR; |
| ms->shadowattr = SHADOWATTR; |
| |
| ms->menupage = MENUPAGE; // Usually no need to change this at all |
| |
| // Initialise all handlers |
| ms->handler = NULL; |
| ms->keys_handler = NULL; |
| ms->ontimeout = NULL; // No timeout handler |
| ms->tm_total_timeout = 0; |
| ms->tm_sofar_timeout = 0; |
| ms->ontotaltimeout = NULL; |
| |
| // Setup ACTION_{,IN}VALID |
| ACTION_VALID.valid = 1; |
| ACTION_VALID.refresh = 0; |
| ACTION_INVALID.valid = 0; |
| ACTION_INVALID.refresh = 0; |
| |
| // Figure out the size of the screen we are in now. |
| // By default we use the whole screen for our menu |
| if (getscreensize(1, &ms->numrows, &ms->numcols)) { |
| /* Unknown screen size? */ |
| ms->numcols = 80; |
| ms->numrows = 24; |
| } |
| ms->minrow = ms->mincol = 0; |
| ms->maxcol = ms->numcols - 1; |
| ms->maxrow = ms->numrows - 1; |
| |
| // How many entries per menu can we display at a time |
| ms->maxmenuheight = ms->maxrow - ms->minrow - 3; |
| if (ms->maxmenuheight > MAXMENUHEIGHT) |
| ms->maxmenuheight = MAXMENUHEIGHT; |
| |
| console_ansi_raw(); |
| |
| return ms; |
| } |
| |
| void set_normal_attr(uchar normal, uchar selected, uchar inactivenormal, |
| uchar inactiveselected) |
| { |
| if (normal != 0xFF) |
| ms->normalattr[0] = normal; |
| if (selected != 0xFF) |
| ms->reverseattr[0] = selected; |
| if (inactivenormal != 0xFF) |
| ms->inactattr[0] = inactivenormal; |
| if (inactiveselected != 0xFF) |
| ms->revinactattr[0] = inactiveselected; |
| } |
| |
| void set_normal_hlite(uchar normal, uchar selected, uchar inactivenormal, |
| uchar inactiveselected) |
| { |
| if (normal != 0xFF) |
| ms->normalattr[1] = normal; |
| if (selected != 0xFF) |
| ms->reverseattr[1] = selected; |
| if (inactivenormal != 0xFF) |
| ms->inactattr[1] = inactivenormal; |
| if (inactiveselected != 0xFF) |
| ms->revinactattr[1] = inactiveselected; |
| } |
| |
| void set_status_info(uchar statusattr, uchar statushlite, uchar statline) |
| { |
| if (statusattr != 0xFF) |
| ms->statusattr[NOHLITE] = statusattr; |
| if (statushlite != 0xFF) |
| ms->statusattr[HLITE] = statushlite; |
| // statline is relative to minrow |
| if (statline >= ms->numrows) |
| statline = ms->numrows - 1; |
| ms->statline = statline; // relative to ms->minrow, 0 based |
| } |
| |
| void set_title_info(uchar tfillchar, uchar titleattr) |
| { |
| if (tfillchar != 0xFF) |
| ms->tfillchar = tfillchar; |
| if (titleattr != 0xFF) |
| ms->titleattr = titleattr; |
| } |
| |
| void set_misc_info(uchar fillchar, uchar fillattr, uchar spacechar, |
| uchar shadowattr) |
| { |
| if (fillchar != 0xFF) |
| ms->fillchar = fillchar; |
| if (fillattr != 0xFF) |
| ms->fillattr = fillattr; |
| if (spacechar != 0xFF) |
| ms->spacechar = spacechar; |
| if (shadowattr != 0xFF) |
| ms->shadowattr = shadowattr; |
| } |
| |
| void set_menu_options(uchar maxmenuheight) |
| { |
| if (maxmenuheight != 0xFF) |
| ms->maxmenuheight = maxmenuheight; |
| } |
| |
| // Set the window which menusystem should use |
| void set_window_size(uchar top, uchar left, uchar bot, uchar right) |
| { |
| int nr, nc; |
| |
| if ((top > bot) || (left > right)) |
| return; // Sorry no change will happen here |
| |
| if (getscreensize(1, &nr, &nc)) { |
| /* Unknown screen size? */ |
| nr = 80; |
| nc = 24; |
| } |
| if (bot >= nr) |
| bot = nr - 1; |
| if (right >= nc) |
| right = nc - 1; |
| ms->minrow = top; |
| ms->mincol = left; |
| ms->maxrow = bot; |
| ms->maxcol = right; |
| ms->numcols = right - left + 1; |
| ms->numrows = bot - top + 1; |
| if (ms->statline >= ms->numrows) |
| ms->statline = ms->numrows - 1; // Clip statline if need be |
| } |
| |
| void reg_handler(t_handler htype, void *handler) |
| { |
| // If bad value set to default screen handler |
| switch (htype) { |
| case HDLR_KEYS: |
| ms->keys_handler = (t_keys_handler) handler; |
| break; |
| default: |
| ms->handler = (t_menusystem_handler) handler; |
| break; |
| } |
| } |
| |
| void unreg_handler(t_handler htype) |
| { |
| switch (htype) { |
| case HDLR_KEYS: |
| ms->keys_handler = NULL; |
| break; |
| default: |
| ms->handler = NULL; |
| break; |
| } |
| } |
| |
| void reg_ontimeout(t_timeout_handler handler, unsigned int numsteps, |
| unsigned int stepsize) |
| { |
| ms->ontimeout = handler; |
| if (numsteps != 0) |
| ms->tm_numsteps = numsteps; |
| if (stepsize != 0) |
| ms->tm_stepsize = stepsize; |
| } |
| |
| void unreg_ontimeout(void) |
| { |
| ms->ontimeout = NULL; |
| } |
| |
| void reg_ontotaltimeout(t_timeout_handler handler, |
| unsigned long numcentiseconds) |
| { |
| if (numcentiseconds != 0) { |
| ms->ontotaltimeout = handler; |
| ms->tm_total_timeout = numcentiseconds * 10; // to convert to milliseconds |
| ms->tm_sofar_timeout = 0; |
| } |
| } |
| |
| void unreg_ontotaltimeout(void) |
| { |
| ms->ontotaltimeout = NULL; |
| } |
| |
| int next_visible(pt_menu menu, int index) |
| { |
| int ans; |
| if (index < 0) |
| ans = 0; |
| else if (index >= menu->numitems) |
| ans = menu->numitems - 1; |
| else |
| ans = index; |
| while ((ans < menu->numitems - 1) && |
| ((menu->items[ans]->action == OPT_INVISIBLE) || |
| (menu->items[ans]->action == OPT_SEP))) |
| ans++; |
| return ans; |
| } |
| |
| int prev_visible(pt_menu menu, int index) // Return index of prev visible |
| { |
| int ans; |
| if (index < 0) |
| ans = 0; |
| else if (index >= menu->numitems) |
| ans = menu->numitems - 1; |
| else |
| ans = index; |
| while ((ans > 0) && |
| ((menu->items[ans]->action == OPT_INVISIBLE) || |
| (menu->items[ans]->action == OPT_SEP))) |
| ans--; |
| return ans; |
| } |
| |
| int next_visible_sep(pt_menu menu, int index) |
| { |
| int ans; |
| if (index < 0) |
| ans = 0; |
| else if (index >= menu->numitems) |
| ans = menu->numitems - 1; |
| else |
| ans = index; |
| while ((ans < menu->numitems - 1) && |
| (menu->items[ans]->action == OPT_INVISIBLE)) |
| ans++; |
| return ans; |
| } |
| |
| int prev_visible_sep(pt_menu menu, int index) // Return index of prev visible |
| { |
| int ans; |
| if (index < 0) |
| ans = 0; |
| else if (index >= menu->numitems) |
| ans = menu->numitems - 1; |
| else |
| ans = index; |
| while ((ans > 0) && (menu->items[ans]->action == OPT_INVISIBLE)) |
| ans--; |
| return ans; |
| } |
| |
| int calc_visible(pt_menu menu, int first) |
| { |
| int ans, i; |
| |
| if (menu == NULL) |
| return 0; |
| ans = 0; |
| for (i = first; i < menu->numitems; i++) |
| if (menu->items[i]->action != OPT_INVISIBLE) |
| ans++; |
| return ans; |
| } |
| |
| // is curr visible if first entry is first? |
| int isvisible(pt_menu menu, int first, int curr) |
| { |
| if (curr < first) |
| return 0; |
| return (calc_visible(menu, first) - calc_visible(menu, curr) < |
| menu->menuheight); |
| } |
| |
| // Calculate the first entry to be displayed |
| // so that curr is visible and make curr as late as possible |
| int calc_first_late(pt_menu menu, int curr) |
| { |
| int ans, i, nv; |
| |
| nv = calc_visible(menu, 0); |
| if (nv <= menu->menuheight) |
| return 0; |
| // Start with curr and go back menu->menuheight times |
| ans = curr + 1; |
| for (i = 0; i < menu->menuheight; i++) |
| ans = prev_visible_sep(menu, ans - 1); |
| return ans; |
| } |
| |
| // Calculate the first entry to be displayed |
| // so that curr is visible and make curr as early as possible |
| int calc_first_early(pt_menu menu, int curr) |
| { |
| int ans, i, nv; |
| |
| nv = calc_visible(menu, 0); |
| if (nv <= menu->menuheight) |
| return 0; |
| // Start with curr and go back till >= menu->menuheight |
| // items are visible |
| nv = calc_visible(menu, curr); // Already nv of them are visible |
| ans = curr; |
| for (i = 0; i < menu->menuheight - nv; i++) |
| ans = prev_visible_sep(menu, ans - 1); |
| return ans; |
| } |
| |
| // Create a new menu and return its position |
| uchar add_menu(const char *title, int maxmenusize) |
| { |
| int num, i; |
| pt_menu m; |
| |
| num = ms->nummenus; |
| if (num >= MAXMENUS) |
| return -1; |
| m = NULL; |
| m = (pt_menu) malloc(sizeof(t_menu)); |
| if (m == NULL) |
| return -1; |
| ms->menus[num] = m; |
| m->numitems = 0; |
| m->name = NULL; |
| m->row = 0xFF; |
| m->col = 0xFF; |
| if (maxmenusize < 1) |
| m->maxmenusize = MAXMENUSIZE; |
| else |
| m->maxmenusize = maxmenusize; |
| m->items = (pt_menuitem *) malloc(sizeof(pt_menuitem) * (m->maxmenusize)); |
| for (i = 0; i < m->maxmenusize; i++) |
| m->items[i] = NULL; |
| |
| m->title = (char *)malloc(MENULEN + 1); |
| if (title) { |
| if (strlen(title) > MENULEN - 2) |
| strcpy(m->title, TITLELONG); |
| else |
| strcpy(m->title, title); |
| } else |
| strcpy(m->title, EMPTYSTR); |
| m->menuwidth = strlen(m->title); |
| ms->nummenus++; |
| return ms->nummenus - 1; |
| } |
| |
| void set_menu_name(const char *name) // Set the "name" of this menu |
| { |
| pt_menu m; |
| |
| m = ms->menus[ms->nummenus - 1]; |
| if (m->name) // Free up previous name |
| { |
| free(m->name); |
| m->name = NULL; |
| } |
| |
| if (name) { |
| m->name = (char *)malloc(strlen(name) + 1); |
| strcpy(m->name, name); |
| } |
| } |
| |
| // Create a new named menu and return its position |
| uchar add_named_menu(const char *name, const char *title, int maxmenusize) |
| { |
| add_menu(title, maxmenusize); |
| set_menu_name(name); |
| return ms->nummenus - 1; |
| } |
| |
| void set_menu_pos(uchar row, uchar col) // Set the position of this menu. |
| { |
| pt_menu m; |
| |
| m = ms->menus[ms->nummenus - 1]; |
| m->row = row; |
| m->col = col; |
| } |
| |
| pt_menuitem add_sep(void) // Add a separator to current menu |
| { |
| pt_menuitem mi; |
| pt_menu m; |
| |
| m = (ms->menus[ms->nummenus - 1]); |
| mi = NULL; |
| mi = (pt_menuitem) malloc(sizeof(t_menuitem)); |
| if (mi == NULL) |
| return NULL; |
| m->items[(unsigned int)m->numitems] = mi; |
| mi->handler = NULL; // No handler |
| mi->item = mi->status = mi->data = NULL; |
| mi->action = OPT_SEP; |
| mi->index = m->numitems++; |
| mi->parindex = ms->nummenus - 1; |
| mi->shortcut = 0; |
| mi->helpid = 0; |
| return mi; |
| } |
| |
| // Add item to the "current" menu |
| pt_menuitem add_item(const char *item, const char *status, t_action action, |
| const char *data, uchar itemdata) |
| { |
| pt_menuitem mi; |
| pt_menu m; |
| const char *str; |
| uchar inhlite = 0; // Are we inside hlite area |
| |
| m = (ms->menus[ms->nummenus - 1]); |
| mi = NULL; |
| mi = (pt_menuitem) malloc(sizeof(t_menuitem)); |
| if (mi == NULL) |
| return NULL; |
| m->items[(unsigned int)m->numitems] = mi; |
| mi->handler = NULL; // No handler |
| |
| // Allocate space to store stuff |
| mi->item = (char *)malloc(MENULEN + 1); |
| mi->status = (char *)malloc(STATLEN + 1); |
| mi->data = (char *)malloc(ACTIONLEN + 1); |
| |
| if (item) { |
| if (strlen(item) > MENULEN) { |
| strcpy(mi->item, ITEMLONG); |
| } else { |
| strcpy(mi->item, item); |
| } |
| if (strlen(mi->item) > m->menuwidth) |
| m->menuwidth = strlen(mi->item); |
| } else |
| strcpy(mi->item, EMPTYSTR); |
| |
| if (status) { |
| if (strlen(status) > STATLEN) { |
| strcpy(mi->status, STATUSLONG); |
| } else { |
| strcpy(mi->status, status); |
| } |
| } else |
| strcpy(mi->status, EMPTYSTR); |
| |
| mi->action = action; |
| str = mi->item; |
| mi->shortcut = 0; |
| mi->helpid = 0xFFFF; |
| inhlite = 0; // We have not yet seen an ENABLEHLITE char |
| // Find the first char in [A-Za-z0-9] after ENABLEHLITE and not arg to control char |
| while (*str) { |
| if (*str == ENABLEHLITE) { |
| inhlite = 1; |
| } |
| if (*str == DISABLEHLITE) { |
| inhlite = 0; |
| } |
| if ((inhlite == 1) && |
| (((*str >= 'A') && (*str <= 'Z')) || |
| ((*str >= 'a') && (*str <= 'z')) || |
| ((*str >= '0') && (*str <= '9')))) { |
| mi->shortcut = *str; |
| break; |
| } |
| ++str; |
| } |
| if ((mi->shortcut >= 'A') && (mi->shortcut <= 'Z')) // Make lower case |
| mi->shortcut = mi->shortcut - 'A' + 'a'; |
| |
| if (data) { |
| if (strlen(data) > ACTIONLEN) { |
| strcpy(mi->data, ACTIONLONG); |
| } else { |
| strcpy(mi->data, data); |
| } |
| } else |
| strcpy(mi->data, EMPTYSTR); |
| |
| switch (action) { |
| case OPT_SUBMENU: |
| mi->itemdata.submenunum = itemdata; |
| break; |
| case OPT_CHECKBOX: |
| mi->itemdata.checked = itemdata; |
| break; |
| case OPT_RADIOMENU: |
| mi->itemdata.radiomenunum = itemdata; |
| if (mi->data) |
| free(mi->data); |
| mi->data = NULL; // No selection made |
| break; |
| default: // to keep the compiler happy |
| break; |
| } |
| mi->index = m->numitems++; |
| mi->parindex = ms->nummenus - 1; |
| return mi; |
| } |
| |
| // Set the shortcut key for the current item |
| void set_item_options(uchar shortcut, int helpid) |
| { |
| pt_menuitem mi; |
| pt_menu m; |
| |
| m = (ms->menus[ms->nummenus - 1]); |
| if (m->numitems <= 0) |
| return; |
| mi = m->items[(unsigned int)m->numitems - 1]; |
| |
| if (shortcut != 0xFF) |
| mi->shortcut = shortcut; |
| if (helpid != 0xFFFF) |
| mi->helpid = helpid; |
| } |
| |
| // Free internal datasutructures |
| void close_menusystem(void) |
| { |
| } |
| |
| // append_line_helper(pt_menu menu,char *line) |
| void append_line_helper(int menunum, char *line) |
| { |
| pt_menu menu; |
| pt_menuitem mi, ri; |
| char *app; |
| int ctr; |
| |
| menu = ms->menus[menunum]; |
| for (ctr = 0; ctr < (int)menu->numitems; ctr++) { |
| mi = menu->items[ctr]; |
| app = NULL; //What to append |
| switch (mi->action) { |
| case OPT_CHECKBOX: |
| if (mi->itemdata.checked) |
| app = mi->data; |
| break; |
| case OPT_RADIOMENU: |
| if (mi->data) { // Some selection has been made |
| ri = (pt_menuitem) (mi->data); |
| app = ri->data; |
| } |
| break; |
| case OPT_SUBMENU: |
| append_line_helper(mi->itemdata.submenunum, line); |
| break; |
| default: |
| break; |
| } |
| if (app) { |
| strcat(line, " "); |
| strcat(line, app); |
| } |
| } |
| } |
| |
| // Generate string based on state of checkboxes and radioitem in given menu |
| // Assume line points to large enough buffer |
| void gen_append_line(const char *menu_name, char *line) |
| { |
| int menunum; |
| |
| menunum = find_menu_num(menu_name); |
| if (menunum < 0) |
| return; // No such menu |
| append_line_helper(menunum, line); |
| } |
