#include /* * $Author: Thorsten.Glaser $ * $Date: 2005/04/24 20:39:53 $ * $Revision: 1.133 $ */ /* * Declare file local prototypes. */ static int createList(CDKSELECTION *selection, char **list, int listSize); static void drawCDKSelectionList (CDKSELECTION *selection, boolean Box); static void setViewSize(CDKSELECTION *scrollp, int listSize); static int maxViewSize(CDKSELECTION *scrollp); /* Determine how many characters we can shift to the right */ /* before all the items have been scrolled off the screen. */ #define AvailableWidth(w) ((w)->boxWidth - 2*BorderOf(w) - (w)->maxchoicelen) #define updateViewWidth(w, widest) \ (w)->maxLeftChar = (((w)->boxWidth > widest) \ ? 0 \ : (widest - AvailableWidth(w))) #define WidestItem(w) ((w)->maxLeftChar + AvailableWidth(w)) DeclareCDKObjects(SELECTION, Selection, setCdk, Int); /* * This function creates a selection widget. */ CDKSELECTION *newCDKSelection (CDKSCREEN *cdkscreen, int xplace, int yplace, int splace, int height, int width, char *title, char **list, int listSize, char **choices, int choiceCount, chtype highlight, boolean Box, boolean shadow) { CDKSELECTION *selection = 0; int widestItem = -1; int parentWidth = getmaxx(cdkscreen->window); int parentHeight = getmaxy(cdkscreen->window); int boxWidth = width; int boxHeight = height; int xpos = xplace; int ypos = yplace; int j = 0; int junk2; static const struct { int from; int to; } bindings[] = { { CDK_BACKCHAR, KEY_PPAGE }, { CDK_FORCHAR, KEY_NPAGE }, { 'g', KEY_HOME }, { '1', KEY_HOME }, { 'G', KEY_END }, { '<', KEY_HOME }, { '>', KEY_END }, }; if (choiceCount <= 0 || (selection = newCDKObject(CDKSELECTION, &my_funcs)) == 0 || (selection->choice = typeCallocN(chtype *, choiceCount + 1)) == 0 || (selection->choicelen = typeCallocN(int, choiceCount + 1)) == 0) { destroyCDKObject(selection); return (0); } setCDKSelectionBox (selection, Box); /* * If the height is a negative value, the height will * be ROWS-height, otherwise, the height will be the * given height. */ boxHeight = setWidgetDimension (parentHeight, height, 0); /* * If the width is a negative value, the width will * be COLS-width, otherwise, the width will be the * given width. */ boxWidth = setWidgetDimension (parentWidth, width, 0); boxWidth = setCdkTitle(ObjOf(selection), title, boxWidth); /* Set the box height. */ if (TitleLinesOf(selection) > boxHeight) { boxHeight = TitleLinesOf(selection) + MINIMUM(listSize, 8) + 2 * BorderOf(selection); } selection->maxchoicelen = 0; /* Adjust the box width if there is a scroll bar. */ if (splace == LEFT || splace == RIGHT) { boxWidth++; selection->scrollbar = TRUE; } else { selection->scrollbar = FALSE; } /* * Make sure we didn't extend beyond the dimensions of the window. */ selection->boxWidth = (boxWidth > parentWidth ? parentWidth : boxWidth); selection->boxHeight = (boxHeight > parentHeight ? parentHeight : boxHeight); setViewSize(selection, listSize); /* Rejustify the x and y positions if we need to. */ alignxy (cdkscreen->window, &xpos, &ypos, selection->boxWidth, selection->boxHeight); /* Make the selection window */ selection->win = newwin (selection->boxHeight, selection->boxWidth, ypos, xpos); /* Is the window null?? */ if (selection->win == 0) { destroyCDKObject(selection); return (0); } /* Turn the keypad on for this window. */ keypad (selection->win, TRUE); /* Create the scrollbar window. */ if (splace == RIGHT) { selection->scrollbarWin = subwin (selection->win, maxViewSize(selection), 1, SCREEN_YPOS(selection, ypos), xpos + selection->boxWidth - BorderOf(selection) - 1); } else if (splace == LEFT) { selection->scrollbarWin = subwin (selection->win, maxViewSize(selection), 1, SCREEN_YPOS(selection, ypos), SCREEN_XPOS(selection, xpos)); } else { selection->scrollbarWin = 0; } /* Set the rest of the variables */ ScreenOf(selection) = cdkscreen; selection->parent = cdkscreen->window; selection->scrollbarPlacement = splace; selection->maxLeftChar = 0; selection->leftChar = 0; selection->highlight = highlight; selection->choiceCount = choiceCount; initExitType(selection); ObjOf(selection)->acceptsFocus = TRUE; ObjOf(selection)->inputWindow = selection->win; selection->shadow = shadow; setCDKSelectionCurrent (selection, 0); /* Each choice has to be converted from char * to chtype * */ for (j = 0; j < choiceCount; j++) { selection->choice[j] = char2Chtype (choices[j], &selection->choicelen[j], &junk2); selection->maxchoicelen = MAXIMUM (selection->maxchoicelen, selection->choicelen[j]); } /* Each item in the needs to be converted to chtype * */ widestItem = createList(selection, list, listSize); if (widestItem <= 0) { destroyCDKObject(selection); return (0); } updateViewWidth(selection, widestItem); /* Do we need to create a shadow. */ if (shadow) { selection->shadowWin = newwin (boxHeight, boxWidth, ypos + 1, xpos + 1); } /* Setup the key bindings. */ for (j = 0; j < (int) SIZEOF(bindings); ++j) bindCDKObject (vSELECTION, selection, bindings[j].from, getcCDKBind, (void *)(long)bindings[j].to); /* Register this baby. */ registerCDKObject (cdkscreen, vSELECTION, selection); /* Return the selection list */ return (selection); } /* * This actually manages the selection widget... */ int activateCDKSelection (CDKSELECTION *selection, chtype *actions) { /* Draw the selection list */ drawCDKSelection (selection, ObjOf(selection)->box); /* Check if actions is null. */ if (actions == 0) { chtype input; int ret; for (;;) { /* Get the input. */ input = getcCDKObject (ObjOf(selection)); /* Inject the character into the widget. */ ret = injectCDKSelection (selection, input); if (selection->exitType != vEARLY_EXIT) { return ret; } } } else { int length = chlen (actions); int j = 0; int ret; /* Inject each character one at a time. */ for (j = 0; j < length; j++) { ret = injectCDKSelection (selection, actions[j]); if (selection->exitType != vEARLY_EXIT) { return ret; } } } /* Set the exit type and return. */ setExitType(selection, 0); return 0; } /* * This injects a single character into the widget. */ static int _injectCDKSelection (CDKOBJS *object, chtype input) { CDKSELECTION *selection = (CDKSELECTION *)object; int ppReturn = 1; int ret = unknownInt; bool complete = FALSE; /* Set the exit type. */ setExitType(selection, 0); /* Draw the selection list */ drawCDKSelectionList (selection, ObjOf(selection)->box); /* Check if there is a pre-process function to be called. */ if (PreProcessFuncOf(selection) != 0) { /* Call the pre-process function. */ ppReturn = PreProcessFuncOf(selection) (vSELECTION, selection, PreProcessDataOf(selection), input); } /* Should we continue? */ if (ppReturn != 0) { /* Check for a predefined binding. */ if (checkCDKObjectBind (vSELECTION, selection, input) != 0) { checkEarlyExit(selection); complete = TRUE; } else { switch (input) { case KEY_UP : scroller_KEY_UP(selection); break; case KEY_DOWN : scroller_KEY_DOWN(selection); break; case KEY_RIGHT : scroller_KEY_RIGHT(selection); break; case KEY_LEFT : scroller_KEY_LEFT(selection); break; case KEY_PPAGE : scroller_KEY_PPAGE(selection); break; case KEY_NPAGE : scroller_KEY_NPAGE(selection); break; case KEY_HOME : scroller_KEY_HOME(selection); break; case KEY_END : scroller_KEY_END(selection); break; case '$' : selection->leftChar = selection->maxLeftChar; break; case '|' : selection->leftChar = 0; break; case SPACE : if (selection->mode[selection->currentItem] == 0) { if (selection->selections[selection->currentItem] == selection->choiceCount - 1) { selection->selections[selection->currentItem] = 0; } else { selection->selections[selection->currentItem]++; } } else { Beep(); } break; case KEY_ESC : setExitType(selection, input); complete = TRUE; break; case KEY_TAB : case KEY_ENTER : setExitType(selection, input); ret = 1; complete = TRUE; break; case CDK_REFRESH : eraseCDKScreen (ScreenOf(selection)); refreshCDKScreen (ScreenOf(selection)); break; default : break; } } /* Should we call a post-process? */ if (!complete && (PostProcessFuncOf(selection) != 0)) { PostProcessFuncOf(selection) (vSELECTION, selection, PostProcessDataOf(selection), input); } } if (!complete) { drawCDKSelectionList (selection, ObjOf(selection)->box); setExitType(selection, 0); } ResultOf(selection).valueInt = ret; return (ret != unknownInt); } /* * This moves the selection field to the given location. */ static void _moveCDKSelection (CDKOBJS *object, int xplace, int yplace, boolean relative, boolean refresh_flag) { CDKSELECTION *selection = (CDKSELECTION *)object; int currentX = getbegx(selection->win); int currentY = getbegy(selection->win); int xpos = xplace; int ypos = yplace; int xdiff = 0; int ydiff = 0; /* * If this is a relative move, then we will adjust where we want * to move to. */ if (relative) { xpos = getbegx(selection->win) + xplace; ypos = getbegy(selection->win) + yplace; } /* Adjust the window if we need to. */ alignxy (WindowOf(selection), &xpos, &ypos, selection->boxWidth, selection->boxHeight); /* Get the difference. */ xdiff = currentX - xpos; ydiff = currentY - ypos; /* Move the window to the new location. */ moveCursesWindow(selection->win, -xdiff, -ydiff); moveCursesWindow(selection->scrollbarWin, -xdiff, -ydiff); moveCursesWindow(selection->shadowWin, -xdiff, -ydiff); /* Touch the windows so they 'move'. */ refreshCDKWindow (WindowOf(selection)); /* Redraw the window, if they asked for it. */ if (refresh_flag) { drawCDKSelection (selection, ObjOf(selection)->box); } } /* * This function draws the selection list. */ static void _drawCDKSelection (CDKOBJS *object, boolean Box) { CDKSELECTION *selection = (CDKSELECTION *)object; /* Draw in the shadow if we need to. */ if (selection->shadowWin != 0) { drawShadow (selection->shadowWin); } drawCdkTitle (selection->win, object); /* Redraw the list */ drawCDKSelectionList (selection, Box); } static int maxViewSize(CDKSELECTION *widget) { return scroller_MaxViewSize(widget); } /* * Set variables that depend upon the list-size. */ static void setViewSize(CDKSELECTION *widget, int listSize) { scroller_SetViewSize(widget, listSize); } #define SCREENPOS(w,n) (w)->itemPos[n] - (w)->leftChar + scrollbarAdj /* + BorderOf(w) */ /* * This function draws the selection list window. */ static void drawCDKSelectionList (CDKSELECTION *selection, boolean Box GCC_UNUSED) { int scrollbarAdj = (selection->scrollbarPlacement == LEFT) ? 1 : 0; int screenPos = 0; int xpos, ypos; int j; /* draw the list... */ for (j = 0; j < selection->viewSize; j++) { screenPos = SCREENPOS(selection, j + selection->currentTop); ypos = SCREEN_YPOS(selection, j); xpos = SCREEN_XPOS(selection, 0); /* Draw the empty line. */ writeBlanks (selection->win, xpos, ypos, HORIZONTAL, 0, getmaxx(selection->win)); /* Draw the selection item. */ writeChtype (selection->win, (screenPos >= 0) ? screenPos : 1, ypos, selection->item[j + selection->currentTop], HORIZONTAL, (screenPos >= 0) ? 0 : (1 - screenPos), selection->itemLen[j + selection->currentTop]); /* Draw the choice value. */ writeChtype (selection->win, xpos + scrollbarAdj, ypos, selection->choice[selection->selections[j + selection->currentTop]], HORIZONTAL, 0, selection->choicelen[selection->selections[j + selection->currentTop]]); } /* Draw in the current highlight. */ if (ObjOf(selection)->hasFocus) { screenPos = SCREENPOS(selection, selection->currentItem); ypos = SCREEN_YPOS(selection, selection->currentHigh); writeChtypeAttrib (selection->win, (screenPos >= 0) ? screenPos : 1, ypos, selection->item[selection->currentItem], selection->highlight, HORIZONTAL, selection->leftChar, selection->itemLen[selection->currentItem]); } /* Determine where the toggle is supposed to be. */ if (selection->scrollbar) { selection->togglePos = floorCDK(selection->currentItem * selection->step); selection->togglePos = MINIMUM(selection->togglePos, getmaxy(selection->scrollbarWin) - 1); mvwvline (selection->scrollbarWin, 0, 0, ACS_CKBOARD, getmaxy(selection->scrollbarWin)); mvwvline (selection->scrollbarWin, selection->togglePos, 0, ' ' | A_REVERSE, selection->toggleSize); } /* Box it if needed */ if (ObjOf(selection)->box) { drawObjBox (selection->win, ObjOf(selection)); } /* Refresh the window. */ refreshCDKWindow (selection->win); } /* * This sets the background attribute of the widget. */ static void _setBKattrSelection (CDKOBJS *object, chtype attrib) { if (object != 0) { CDKSELECTION *widget = (CDKSELECTION *) object; wbkgd (widget->win, attrib); if (widget->scrollbarWin != 0) { wbkgd (widget->scrollbarWin, attrib); } } } /* * This function destroys the selection list. */ static void _destroyCDKSelection (CDKOBJS *object) { if (object != 0) { CDKSELECTION *selection = (CDKSELECTION *)object; cleanCdkTitle (object); CDKfreeChtypes (selection->choice); freeChecked (selection->choicelen); CDKfreeChtypes (selection->item); freeChecked (selection->itemPos); freeChecked (selection->itemLen); freeChecked (selection->selections); freeChecked (selection->mode); /* Clean up the windows. */ deleteCursesWindow (selection->scrollbarWin); deleteCursesWindow (selection->shadowWin); deleteCursesWindow (selection->win); /* Unregister this object. */ unregisterCDKObject (vSELECTION, selection); } } /* * This function erases the selection list from the screen. */ static void _eraseCDKSelection (CDKOBJS *object) { if (validCDKObject (object)) { CDKSELECTION *selection = (CDKSELECTION *)object; eraseCursesWindow (selection->win); eraseCursesWindow (selection->shadowWin); } } /* * This function sets a couple of the selection list attributes. */ void setCDKSelection (CDKSELECTION *selection, chtype highlight, int choices[], boolean Box) { setCDKSelectionChoices (selection, choices); setCDKSelectionHighlight(selection, highlight); setCDKSelectionBox (selection, Box); } /* * This sets the selection list items. */ void setCDKSelectionItems (CDKSELECTION *selection, char **list, int listSize) { int widestItem = -1; int j = 0; widestItem = createList(selection, list, listSize); if (widestItem <= 0) return; /* Clean up the display. */ for (j = 0; j < selection->viewSize ; j++) { writeBlanks (selection->win, SCREEN_XPOS(selection, 0), SCREEN_YPOS(selection, j), HORIZONTAL, 0, getmaxx(selection->win)); } setViewSize(selection, listSize); setCDKSelectionCurrent (selection, 0); updateViewWidth(selection, widestItem); } int getCDKSelectionItems (CDKSELECTION *selection, char *list[]) { int j; for (j = 0; j < selection->listSize; j++) { list[j] = chtype2Char (selection->item[j]); } return selection->listSize; } /* * */ void setCDKSelectionTitle (CDKSELECTION *selection, char *title) { /* Make sure the title isn't null. */ if (title == 0) { return; } (void) setCdkTitle(ObjOf(selection), title, - (selection->boxWidth + 1)); setViewSize(selection, selection->listSize); } char *getCDKSelectionTitle (CDKSELECTION *selection GCC_UNUSED) { /* FIXME: this is not implemented */ return ("HELLO"); } /* * This sets the highlight bar. */ void setCDKSelectionHighlight (CDKSELECTION *selection, chtype highlight) { selection->highlight = highlight; } chtype getCDKSelectionHighlight (CDKSELECTION *selection) { return selection->highlight; } /* * This sets the default choices for the selection list. */ void setCDKSelectionChoices (CDKSELECTION *selection, int choices[]) { int j; /* Set the choice values in the selection list. */ for (j = 0; j < selection->listSize; j++) { if (choices[j] < 0) { selection->selections[j] = 0; } else if (choices[j] > selection->choiceCount) { selection->selections[j] = selection->choiceCount - 1; } else { selection->selections[j] = choices[j]; } } } int *getCDKSelectionChoices (CDKSELECTION *selection) { return selection->selections; } /* * This sets a single item's choice value. */ void setCDKSelectionChoice (CDKSELECTION *selection, int Index, int choice) { int correctChoice = choice; int correctIndex = Index; /* Verify that the choice value is in range. */ if (choice < 0) { correctChoice = 0; } else if (choice > selection->choiceCount) { correctChoice = selection->choiceCount - 1; } /* Make sure the index isn't out of range. */ if (Index < 0) { Index = 0; } else if (Index > selection->listSize) { Index = selection->listSize - 1; } /* Set the choice value. */ selection->selections[correctIndex] = correctChoice; } int getCDKSelectionChoice (CDKSELECTION *selection, int Index) { /* Make sure the index isn't out of range. */ if (Index < 0) { return selection->selections[0]; } else if (Index > selection->listSize) { return selection->selections[selection->listSize - 1]; } else { return selection->selections[Index]; } } /* * This sets the modes of the items in the selection list. Currently * there are only two: editable=0 and read-only=1 */ void setCDKSelectionModes (CDKSELECTION *selection, int modes[]) { int j; /* Make sure the widget pointer is not null. */ if (selection == 0) { return; } /* Set the modes. */ for (j = 0; j < selection->listSize; j++) { selection->mode[j] = modes[j]; } } int *getCDKSelectionModes (CDKSELECTION *selection) { return selection->mode; } /* * This sets a single mode of an item in the selection list. */ void setCDKSelectionMode (CDKSELECTION *selection, int Index, int mode) { /* Make sure the widget pointer is not null. */ if (selection == 0) { return; } /* Make sure the index isn't out of range. */ if (Index < 0) { selection->mode[0] = mode; } else if (Index > selection->listSize) { selection->mode[selection->listSize - 1] = mode; } else { selection->mode[Index] = mode; } } int getCDKSelectionMode (CDKSELECTION *selection, int Index) { /* Make sure the index isn't out of range. */ if (Index < 0) { return selection->mode[0]; } else if (Index > selection->listSize) { return selection->mode[selection->listSize - 1]; } else { return selection->mode[Index]; } } /* * This sets the box attribute of the widget. */ void setCDKSelectionBox (CDKSELECTION *selection, boolean Box) { ObjOf(selection)->box = Box; ObjOf(selection)->borderSize = Box ? 1 : 0; } boolean getCDKSelectionBox (CDKSELECTION *selection) { return ObjOf(selection)->box; } /* * set/get the current item index */ void setCDKSelectionCurrent (CDKSELECTION *selection, int item) { scroller_SetPosition(selection, item); } int getCDKSelectionCurrent (CDKSELECTION *selection) { return selection->currentItem; } /* * methods for generic type methods */ static void _focusCDKSelection(CDKOBJS *object) { CDKSELECTION *selection = (CDKSELECTION *)object; drawCDKSelectionList (selection, ObjOf(selection)->box); } static void _unfocusCDKSelection(CDKOBJS *object) { CDKSELECTION *selection = (CDKSELECTION *)object; drawCDKSelectionList (selection, ObjOf(selection)->box); } dummyRefreshData(Selection) dummySaveData(Selection) static int createList(CDKSELECTION *selection, char **list, int listSize) { int status = 0; int widestItem = 0; int j; if (listSize > 0) { chtype ** newList = typeCallocN(chtype *, listSize + 1); int * newLen = typeCallocN(int, listSize + 1); int * newPos = typeCallocN(int, listSize + 1); int * newSel = typeCallocN(int, listSize + 1); int * newMode = typeCallocN(int, listSize + 1); if (newList != 0 && newLen != 0 && newPos != 0 && newSel != 0 && newMode != 0) { int boxWidth = AvailableWidth(selection); int adjust = selection->maxchoicelen + BorderOf(selection); status = 1; for (j = 0; j < listSize; j++) { newList[j] = char2Chtype (list[j], &newLen[j], &newPos[j]); if (newList[j] == 0) { status = 0; break; } newPos[j] = justifyString (boxWidth, newLen[j], newPos[j]) + adjust; widestItem = MAXIMUM (widestItem, newLen[j]); } if (status) { CDKfreeChtypes (selection->item); freeChecked (selection->itemPos); freeChecked (selection->itemLen); freeChecked (selection->selections); freeChecked (selection->mode); selection->item = newList; selection->itemPos = newPos; selection->itemLen = newLen; selection->selections = newSel; selection->mode = newMode; } else { CDKfreeChtypes (newList); freeChecked (newPos); freeChecked (newLen); freeChecked (newSel); freeChecked (newMode); } } } return status ? widestItem : 0; }