NetBSD/dist/cdk/menu.c

628 lines
15 KiB
C
Raw Normal View History

#include <cdk.h>
/*
* $Author: garbled $
* $Date: 2001/01/09 18:41:53 $
* $Revision: 1.3 $
*/
/*
* Declare file local prototypes.
*/
static void cleanUpMenu (CDKMENU *menu);
DeclareCDKObjects(my_funcs,Menu);
/*
* This creates a new menu widget.
*/
CDKMENU *newCDKMenu (CDKSCREEN *cdkscreen, char *menulist[MAX_MENU_ITEMS][MAX_SUB_ITEMS], int menuItems, int *subsize, int *menuloc, int menuPos, chtype titleAttr, chtype subtitleAttr)
{
CDKMENU *menu = newCDKObject(CDKMENU, &my_funcs);
int rightcount = menuItems-1;
int rightloc = getmaxx((cdkscreen->window)) - 1;
int leftloc = 0;
int x, y, max, junk;
/* Start making a copy of the information. */
ScreenOf(menu) = cdkscreen;
ObjOf(menu)->box = FALSE;
rightcount = menuItems-1;
menu->parent = cdkscreen->window;
menu->menuItems = menuItems;
menu->titleAttr = titleAttr;
menu->subtitleAttr = subtitleAttr;
menu->currentTitle = 0;
menu->currentSubtitle = 0;
menu->lastSelection = -1;
menu->preProcessFunction = 0;
menu->preProcessData = 0;
menu->postProcessFunction = 0;
menu->postProcessData = 0;
menu->menuPos = menuPos;
menu->exitType = vNEVER_ACTIVATED;
/* Create the pull down menus. */
for (x=0; x < menuItems; x++)
{
max = -1;
for (y=1; y < subsize[x] ; y++)
{
if (menuloc[x] == LEFT)
{
menu->sublist[x][y-1] = char2Chtype (menulist[x][y], &menu->sublistLen[x][y-1], &junk);
max = MAXIMUM (max, menu->sublistLen[x][y-1]);
}
else
{
menu->sublist[rightcount][y-1] = char2Chtype (menulist[x][y], &menu->sublistLen[rightcount][y-1], &junk);
max = MAXIMUM (max, menu->sublistLen[rightcount][y-1]);
}
}
if (menuloc[x] == LEFT)
{
/*
* Its a menu item on the left, add it to the left side
* of the menu.
*/
menu->title[x] = char2Chtype (menulist[x][0], &menu->titleLen[x], &junk);
menu->subsize[x] = subsize[x] - 1;
if (menu->menuPos == BOTTOM)
{
menu->titleWin[x] = subwin (cdkscreen->window, 1, menu->titleLen[x]+2, LINES-1, leftloc);
menu->pullWin[x] = subwin (cdkscreen->window, subsize[x]+1, max+2, LINES-subsize[x]-2, leftloc);
}
else
{
menu->titleWin[x] = subwin (cdkscreen->window, 1, menu->titleLen[x]+2, 0, leftloc);
menu->pullWin[x] = subwin (cdkscreen->window, subsize[x]+1, max+2, 1, leftloc);
}
leftloc += menu->titleLen[x] + 1;
/* Allow the windows to use the keypad. */
keypad (menu->titleWin[x], TRUE);
keypad (menu->pullWin[x], TRUE);
}
else
{
/*
* Its a menu item on the right, add it to the right side
* of the menu.
*/
rightloc -= max + 3;
menu->title[rightcount] = char2Chtype (menulist[x][0], &menu->titleLen[rightcount], &junk);
menu->subsize[rightcount] = subsize[x] - 1;
if (menu->menuPos == BOTTOM)
{
menu->titleWin[rightcount] = subwin (cdkscreen->window, 1, menu->titleLen[x]+2, LINES-1, rightloc);
menu->pullWin[rightcount] = subwin (cdkscreen->window, subsize[x]+1, max+2, LINES-subsize[x]-2, rightloc);
}
else
{
menu->titleWin[rightcount] = subwin (cdkscreen->window, 1, menu->titleLen[x]+2, 0, rightloc);
menu->pullWin[rightcount] = subwin (cdkscreen->window, subsize[x]+1, max+2, 1, rightloc);
}
/* Allow the windows to use the keypad. */
keypad (menu->titleWin[rightcount], TRUE);
keypad (menu->pullWin[rightcount], TRUE);
rightcount--;
}
}
/* Clean the key bindings. */
cleanCDKObjectBindings (vMENU, menu);
/* Register this baby. */
registerCDKObject (cdkscreen, vMENU, menu);
/* Return the menu object. */
return (menu);
}
/*
* This activates the CDK Menu.
*/
int activateCDKMenu (CDKMENU *menu, chtype *actions)
{
chtype input;
int ret;
/* Draw in the screen. */
refreshCDKScreen (ScreenOf(menu));
/* Display the menu titles. */
drawCDKMenu(menu, ObjOf(menu)->box);
/* Highlight the current title and window. */
drawCDKMenuSubwin (menu);
/* If the input string is null, this is an interactive activate. */
if (actions == 0)
{
/* Start taking input from the keyboard. */
for (;;)
{
wrefresh (menu->titleWin[menu->currentTitle]);
input = wgetch (menu->titleWin[menu->currentTitle]);
/* Inject the character into the widget. */
ret = injectCDKMenu (menu, input);
if (menu->exitType != vEARLY_EXIT)
{
return ret;
}
}
}
else
{
int count = chlen (actions);
int x = 0;
for (x=0; x < count; x++)
{
ret = injectCDKMenu (menu, actions[x]);
if (menu->exitType != vEARLY_EXIT)
{
return ret;
}
}
}
/* Set the exit type and return. */
menu->exitType = vEARLY_EXIT;
return -1;
}
/*
* This injects a character into the menu widget.
*/
int injectCDKMenu (CDKMENU *menu, chtype input)
{
int ppReturn = 1;
/* Set the exit type. */
menu->exitType = vEARLY_EXIT;
/* Check if there is a pre-process function to be called. */
if (menu->preProcessFunction != 0)
{
/* Call the pre-process function. */
ppReturn = ((PROCESSFN)(menu->preProcessFunction)) (vMENU, menu, menu->preProcessData, input);
}
/* Should we continue? */
if (ppReturn != 0)
{
/* Check for key bindings. */
if (checkCDKObjectBind (vMENU, menu, input) != 0)
{
return -1;
}
else
{
switch (input)
{
case KEY_LEFT :
/* Erase the menu sub-window */
eraseCDKMenuSubwin (menu);
refreshCDKScreen (ScreenOf(menu));
/* Set the values. */
menu->currentSubtitle = 0;
if (menu->currentTitle == 0)
{
menu->currentTitle = menu->menuItems - 1;
}
else
{
menu->currentTitle--;
}
/* Draw the new menu sub-window. */
drawCDKMenuSubwin (menu);
break;
case KEY_RIGHT : case KEY_TAB :
/* Erase the menu sub-window. */
eraseCDKMenuSubwin (menu);
refreshCDKScreen (ScreenOf(menu));
/* Set the values. */
menu->currentSubtitle = 0;
if (menu->currentTitle == menu->menuItems-1)
{
menu->currentTitle = 0;
}
else
{
menu->currentTitle++;
}
/* Draw the new menu sub-window. */
drawCDKMenuSubwin (menu);
break;
case KEY_UP :
/* Erase the old subtitle. */
writeChtype (menu->pullWin[menu->currentTitle],
1, menu->currentSubtitle+1,
menu->sublist[menu->currentTitle][menu->currentSubtitle],
HORIZONTAL,
0, menu->sublistLen[menu->currentTitle][menu->currentSubtitle]);
/* Set the values. */
if (menu->currentSubtitle == 0)
{
menu->currentSubtitle = menu->subsize[menu->currentTitle] - 1;
}
else
{
menu->currentSubtitle--;
}
/* Draw the new sub-title. */
writeChtypeAttrib (menu->pullWin[menu->currentTitle],
1, menu->currentSubtitle+1,
menu->sublist[menu->currentTitle][menu->currentSubtitle],
menu->subtitleAttr,
HORIZONTAL,
0, menu->sublistLen[menu->currentTitle][menu->currentSubtitle]);
wnoutrefresh (menu->pullWin[menu->currentTitle]);
break;
case KEY_DOWN : case SPACE :
/* Erase the old subtitle. */
writeChtype (menu->pullWin[menu->currentTitle],
1, menu->currentSubtitle+1,
menu->sublist[menu->currentTitle][menu->currentSubtitle],
HORIZONTAL,
0, menu->sublistLen[menu->currentTitle][menu->currentSubtitle]);
/* Set the values. */
if (menu->currentSubtitle == menu->subsize[menu->currentTitle]-1)
{
menu->currentSubtitle = 0;
}
else
{
menu->currentSubtitle++;
}
/* Draw the new sub-title. */
writeChtypeAttrib (menu->pullWin[menu->currentTitle],
1, menu->currentSubtitle+1,
menu->sublist[menu->currentTitle][menu->currentSubtitle],
menu->subtitleAttr,
HORIZONTAL,
0, menu->sublistLen[menu->currentTitle][menu->currentSubtitle]);
wnoutrefresh (menu->pullWin[menu->currentTitle]);
break;
case KEY_ESC :
cleanUpMenu (menu);
menu->exitType = vESCAPE_HIT;
menu->lastSelection = -1;
return menu->lastSelection;
case KEY_RETURN : case KEY_ENTER : case KEY_CR :
cleanUpMenu (menu);
menu->exitType = vNORMAL;
menu->lastSelection = ((menu->currentTitle * 100) + menu->currentSubtitle);
return menu->lastSelection;
case CDK_REFRESH :
eraseCDKScreen (ScreenOf(menu));
refreshCDKScreen (ScreenOf(menu));
break;
default :
Beep();
break;
}
}
/* Should we call a post-process? */
if (menu->postProcessFunction != 0)
{
((PROCESSFN)(menu->postProcessFunction)) (vMENU, menu, menu->postProcessData, input);
}
}
/* Set the exit type and exit */
menu->exitType = vEARLY_EXIT;
return -1;
}
/*
* This draws a menu item subwindow.
*/
void drawCDKMenuSubwin (CDKMENU *menu)
{
int x;
/* Box the window. */
box (menu->pullWin[menu->currentTitle], ACS_VLINE, ACS_HLINE);
if (menu->menuPos == BOTTOM)
{
mvwaddch (menu->pullWin[menu->currentTitle],
menu->subsize[menu->currentTitle]+1, 0, ACS_LTEE);
}
else
{
mvwaddch (menu->pullWin[menu->currentTitle], 0, 0, ACS_LTEE);
}
/* Draw in the items. */
for (x=0; x < menu->subsize[menu->currentTitle] ; x++)
{
if (x == menu->currentSubtitle)
{
writeChtypeAttrib (menu->pullWin[menu->currentTitle],
1, x+1,
menu->sublist[menu->currentTitle][x],
menu->subtitleAttr,
HORIZONTAL,
0, menu->sublistLen[menu->currentTitle][x]);
}
else
{
writeChtype (menu->pullWin[menu->currentTitle],
1, x+1,
menu->sublist[menu->currentTitle][x],
HORIZONTAL,
0, menu->sublistLen[menu->currentTitle][x]);
}
}
wnoutrefresh (menu->pullWin[menu->currentTitle]);
/* Highlight the title. */
writeChtypeAttrib (menu->titleWin[menu->currentTitle],
0, 0, menu->title[menu->currentTitle],
menu->titleAttr, HORIZONTAL, 0,
menu->titleLen[menu->currentTitle]);
wnoutrefresh (menu->titleWin[menu->currentTitle]);
}
/*
* This erases a menu item subwindow.
*/
void eraseCDKMenuSubwin (CDKMENU *menu)
{
eraseCursesWindow (menu->pullWin[menu->currentTitle]);
/* Redraw the sub-menu title. */
writeChtype (menu->titleWin[menu->currentTitle],
0, 0, menu->title[menu->currentTitle],
HORIZONTAL,
0, menu->titleLen[menu->currentTitle]);
wnoutrefresh (menu->titleWin[menu->currentTitle]);
}
/*
* This function draws the menu.
*/
static void _drawCDKMenu (CDKOBJS *object, boolean Box GCC_UNUSED)
{
CDKMENU *menu = (CDKMENU *)object;
int x;
/* Draw in the menu titles. */
for (x=0; x < menu->menuItems; x++)
{
writeChtype (menu->titleWin[x], 0, 0, menu->title[x], HORIZONTAL, 0, menu->titleLen[x]);
wnoutrefresh (menu->titleWin[x]);
}
}
/*
* This moves the menu to the given location.
*/
static void _moveCDKMenu (CDKOBJS *object, int xplace, int yplace, boolean relative, boolean refresh_flag)
{
CDKMENU *menu = (CDKMENU *)object;
/*
* If this is a relative move, then we will adjust where we want
* to move to.
*/
if (relative)
{
xplace += getbegx(WindowOf(menu));
yplace += getbegy(WindowOf(menu));
}
/* Adjust the window if we need to. */
alignxy (WindowOf(menu), &xplace, &yplace, getmaxx(WindowOf(menu)), getmaxy(WindowOf(menu)));
/* Move the windows to the new location. */
moveCursesWindow(WindowOf(menu), xplace, yplace);
/* Redraw the window, if they asked for it. */
if (refresh_flag)
{
drawCDKMenu (menu, ObjOf(menu)->box);
}
}
/*
* This sets the background color of the widget.
*/
void setCDKMenuBackgroundColor (CDKMENU *menu, char *color)
{
chtype *holder = 0;
int x, junk1, junk2;
/* Make sure the color isn't null. */
if (color == 0)
{
return;
}
/* Convert the value of the environment variable to a chtype. */
holder = char2Chtype (color, &junk1, &junk2);
/* Set the widgets background color. */
for (x=0; x < menu->menuItems; x++)
{
wbkgd (menu->titleWin[x], holder[0]);
wbkgd (menu->pullWin[x], holder[0]);
}
/* Clean up. */
freeChtype (holder);
}
/*
* This function destroys a menu widget.
*/
void destroyCDKMenu (CDKMENU *menu)
{
int x, y;
/* Erase the object. */
eraseCDKMenu (menu);
/* Clean up both the winodws and the char pointers. */
for (x=0; x < menu->menuItems; x++)
{
/* Clean the windows. */
deleteCursesWindow (menu->titleWin[x]);
deleteCursesWindow (menu->pullWin[x]);
/* Delete the character pointers. */
freeChtype (menu->title[x]);
for (y=0; y < menu->subsize[x] ; y++)
{
freeChtype (menu->sublist[x][y]);
}
}
/* Unregister this object. */
unregisterCDKObject (vMENU, menu);
/* Finish cleaning up. */
free (menu);
}
/*
* This function erases the menu widget from the screen.
*/
static void _eraseCDKMenu (CDKOBJS *object)
{
CDKMENU *menu = (CDKMENU *)object;
int x = 0;
/* Erase the menu items. */
for (x=0 ; x < menu->menuItems; x++)
{
werase (menu->titleWin[x]);
wnoutrefresh (menu->titleWin[x]);
werase (menu->pullWin[x]);
wnoutrefresh (menu->pullWin[x]);
}
}
/*
* This sets multiple features of the menu.
*/
void setCDKMenu (CDKMENU *menu, int menuItem, int subMenuItem, chtype titleHighlight, chtype subTitleHighlight)
{
setCDKMenuCurrentItem (menu, menuItem, subMenuItem);
setCDKMenuTitleHighlight (menu, titleHighlight);
setCDKMenuSubTitleHighlight (menu, subTitleHighlight);
}
/*
* This sets the current menu itme to highlight.
*/
void setCDKMenuCurrentItem (CDKMENU *menu, int menuitem, int submenuitem)
{
/* Set the menu item position values. */
if (menuitem < 0)
{
menu->currentTitle = 0;
}
else if (menuitem >= menu->menuItems)
{
menu->currentTitle = menu->menuItems - 1;
}
else
{
menu->currentTitle = menuitem;
}
if (submenuitem < 0)
{
menu->currentSubtitle = 0;
}
else if (submenuitem >= menu->subsize[menu->currentTitle])
{
menu->currentSubtitle = menu->subsize[menu->currentTitle]-1;
}
else
{
menu->currentSubtitle = submenuitem;
}
}
void getCDKMenuCurrentItem (CDKMENU *menu, int *menuItem, int *subMenuItem)
{
(*menuItem) = menu->currentTitle;
(*subMenuItem) = menu->currentSubtitle;
}
/*
* This sets the attribute of the menu titles.
*/
void setCDKMenuTitleHighlight (CDKMENU *menu, chtype highlight)
{
menu->titleAttr = highlight;
}
chtype getCDKMenuTitleHighlight (CDKMENU *menu)
{
return menu->titleAttr;
}
/*
* This sets the attribute of the sub-title.
*/
void setCDKMenuSubTitleHighlight (CDKMENU *menu, chtype highlight)
{
menu->subtitleAttr = highlight;
}
chtype getCDKMenuSubTitleHighlight (CDKMENU *menu)
{
return menu->subtitleAttr;
}
/*
* This exits the menu.
*/
static void cleanUpMenu (CDKMENU *menu)
{
/* Erase the sub-menu. */
eraseCDKMenuSubwin (menu);
wnoutrefresh (menu->pullWin[menu->currentTitle]);
/* Refresh the screen. */
refreshCDKScreen (ScreenOf(menu));
}
/*
* This function sets the pre-process function.
*/
void setCDKMenuPreProcess (CDKMENU *menu, PROCESSFN callback, void *data)
{
menu->preProcessFunction = callback;
menu->preProcessData = data;
}
/*
* This function sets the post-process function.
*/
void setCDKMenuPostProcess (CDKMENU *menu, PROCESSFN callback, void *data)
{
menu->postProcessFunction = callback;
menu->postProcessData = data;
}