995 lines
22 KiB
C
995 lines
22 KiB
C
#include <cdk.h>
|
|
|
|
/*
|
|
* $Author: garbled $
|
|
* $Date: 2001/01/04 20:15:30 $
|
|
* $Revision: 1.2 $
|
|
*/
|
|
|
|
/*
|
|
* Declare file local prototypes.
|
|
*/
|
|
static void CDKEntryCallBack (CDKENTRY *entry, chtype character);
|
|
static void drawCDKEntryField (CDKENTRY *entry);
|
|
|
|
/*
|
|
* Declare file local variables.
|
|
*/
|
|
extern char *GPasteBuffer;
|
|
|
|
DeclareCDKObjects(my_funcs,Entry);
|
|
|
|
/*
|
|
* This creates a pointer to an entry widget.
|
|
*/
|
|
CDKENTRY *newCDKEntry (CDKSCREEN *cdkscreen, int xplace, int yplace, char *title, char *label, chtype fieldAttr, chtype filler, EDisplayType dispType, int fWidth, int min, int max, boolean Box, boolean shadow)
|
|
{
|
|
/* Set up some variables. */
|
|
CDKENTRY *entry = newCDKObject(CDKENTRY, &my_funcs);
|
|
chtype *holder = 0;
|
|
int parentWidth = getmaxx(cdkscreen->window);
|
|
int parentHeight = getmaxy(cdkscreen->window);
|
|
int fieldWidth = fWidth;
|
|
int boxWidth = 0;
|
|
int boxHeight = 3;
|
|
int maxWidth = INT_MIN;
|
|
int xpos = xplace;
|
|
int ypos = yplace;
|
|
int junk = 0;
|
|
int horizontalAdjust = 0;
|
|
char **temp = 0;
|
|
int x, len, junk2;
|
|
|
|
/*
|
|
* If the fieldWidth is a negative value, the fieldWidth will
|
|
* be COLS-fieldWidth, otherwise, the fieldWidth will be the
|
|
* given width.
|
|
*/
|
|
fieldWidth = setWidgetDimension (parentWidth, fieldWidth, 0);
|
|
boxWidth = fieldWidth + 2;
|
|
|
|
/* Set some basic values of the entry field. */
|
|
entry->label = 0;
|
|
entry->labelLen = 0;
|
|
entry->labelWin = 0;
|
|
entry->titleLines = 0;
|
|
|
|
/* Translate the label char *pointer to a chtype pointer. */
|
|
if (label != 0)
|
|
{
|
|
entry->label = char2Chtype (label, &entry->labelLen, &junk);
|
|
boxWidth += entry->labelLen;
|
|
}
|
|
|
|
/* Translate the char * items to chtype * */
|
|
if (title != 0)
|
|
{
|
|
/* We need to split the title on \n. */
|
|
temp = CDKsplitString (title, '\n');
|
|
entry->titleLines = CDKcountStrings (temp);
|
|
|
|
/* We need to determine the widest title line. */
|
|
for (x=0; x < entry->titleLines; x++)
|
|
{
|
|
holder = char2Chtype (temp[x], &len, &junk2);
|
|
maxWidth = MAXIMUM (maxWidth, len);
|
|
freeChtype (holder);
|
|
}
|
|
|
|
/*
|
|
* If one of the title lines is wider than the field and the label,
|
|
* the box width will expand to accomodate.
|
|
*/
|
|
if (maxWidth > boxWidth)
|
|
{
|
|
horizontalAdjust = (int)((maxWidth - boxWidth) / 2) + 1;
|
|
boxWidth = maxWidth + 2;
|
|
}
|
|
|
|
/* For each line in the title, convert from char * to chtype * */
|
|
for (x=0; x < entry->titleLines; x++)
|
|
{
|
|
entry->title[x] = char2Chtype (temp[x], &entry->titleLen[x], &entry->titlePos[x]);
|
|
entry->titlePos[x] = justifyString (boxWidth - 2, entry->titleLen[x], entry->titlePos[x]);
|
|
}
|
|
CDKfreeStrings(temp);
|
|
}
|
|
else
|
|
{
|
|
/* No title? Set the required variables. */
|
|
entry->titleLines = 0;
|
|
}
|
|
boxHeight += entry->titleLines;
|
|
|
|
/*
|
|
* Make sure we didn't extend beyond the dimensions of the window.
|
|
*/
|
|
boxWidth = MINIMUM (boxWidth, parentWidth);
|
|
boxHeight = MINIMUM (boxHeight, parentHeight);
|
|
fieldWidth = (fieldWidth > (boxWidth - entry->labelLen - 2) ? (boxWidth - entry->labelLen - 2) : fieldWidth);
|
|
|
|
/* Rejustify the x and y positions if we need to. */
|
|
alignxy (cdkscreen->window, &xpos, &ypos, boxWidth, boxHeight);
|
|
|
|
/* Make the label window. */
|
|
entry->win = newwin (boxHeight + !!shadow, boxWidth + !!shadow, ypos, xpos);
|
|
|
|
/* Is the window null? */
|
|
if (entry->win == 0)
|
|
{
|
|
/* Clean up the pointers. */
|
|
freeChtype (entry->label);
|
|
free (entry);
|
|
|
|
/* Exit with null. */
|
|
return (0);
|
|
}
|
|
keypad (entry->win, TRUE);
|
|
|
|
if (entry->titleLines > 0)
|
|
{
|
|
/* Make the title window. */
|
|
entry->titleWin = subwin (entry->win,
|
|
entry->titleLines, boxWidth - 2,
|
|
ypos + 1, xpos + 1);
|
|
}
|
|
|
|
/* Make the label win, if we need to. */
|
|
if (label != 0)
|
|
{
|
|
entry->labelWin = subwin (entry->win, 1, entry->labelLen,
|
|
ypos + entry->titleLines + 1,
|
|
xpos + horizontalAdjust + 1);
|
|
}
|
|
|
|
/* Make the field window. */
|
|
entry->fieldWin = subwin (entry->win, 1, fieldWidth,
|
|
ypos + entry->titleLines + 1,
|
|
xpos + entry->labelLen + horizontalAdjust + 1);
|
|
keypad (entry->fieldWin, TRUE);
|
|
|
|
/* Make room for the info char * pointer. */
|
|
entry->infoWidth = max + 3;
|
|
entry->info = (char *)malloc (entry->infoWidth);
|
|
cleanChar (entry->info, entry->infoWidth, '\0');
|
|
|
|
/* Set up the rest of the structure. */
|
|
ScreenOf(entry) = cdkscreen;
|
|
entry->parent = cdkscreen->window;
|
|
entry->fieldAttr = fieldAttr;
|
|
entry->fieldWidth = fieldWidth;
|
|
entry->filler = filler;
|
|
entry->hidden = filler;
|
|
ObjOf(entry)->box = Box;
|
|
entry->shadow = shadow;
|
|
entry->screenCol = 0;
|
|
entry->leftChar = 0;
|
|
entry->min = min;
|
|
entry->max = max;
|
|
entry->boxWidth = boxWidth;
|
|
entry->boxHeight = boxHeight;
|
|
entry->ULChar = ACS_ULCORNER;
|
|
entry->URChar = ACS_URCORNER;
|
|
entry->LLChar = ACS_LLCORNER;
|
|
entry->LRChar = ACS_LRCORNER;
|
|
entry->HChar = ACS_HLINE;
|
|
entry->VChar = ACS_VLINE;
|
|
entry->BoxAttrib = A_NORMAL;
|
|
entry->exitType = vNEVER_ACTIVATED;
|
|
entry->dispType = dispType;
|
|
entry->callbackfn = (void *)&CDKEntryCallBack;
|
|
entry->preProcessFunction = 0;
|
|
entry->preProcessData = 0;
|
|
entry->postProcessFunction = 0;
|
|
entry->postProcessData = 0;
|
|
|
|
/* Clean the key bindings. */
|
|
cleanCDKObjectBindings (vENTRY, entry);
|
|
|
|
/* Register this baby. */
|
|
registerCDKObject (cdkscreen, vENTRY, entry);
|
|
|
|
/* Return the pointer to the structure. */
|
|
return (entry);
|
|
}
|
|
|
|
/*
|
|
* This means you want to use the given entry field. It takes input
|
|
* from the keyboard, and when its done, it fills the entry info
|
|
* element of the structure with what was typed.
|
|
*/
|
|
char *activateCDKEntry (CDKENTRY *entry, chtype *actions)
|
|
{
|
|
/* Declare local variables. */
|
|
chtype input = 0;
|
|
char *ret = 0;
|
|
|
|
/* Draw the widget. */
|
|
drawCDKEntry (entry, ObjOf(entry)->box);
|
|
|
|
/* Check if 'actions' is null. */
|
|
if (actions == 0)
|
|
{
|
|
for (;;)
|
|
{
|
|
/* Get the input. */
|
|
wrefresh (entry->fieldWin);
|
|
input = wgetch (entry->fieldWin);
|
|
|
|
/* Inject the character into the widget. */
|
|
ret = injectCDKEntry (entry, input);
|
|
if (entry->exitType != vEARLY_EXIT)
|
|
{
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int length = chlen (actions);
|
|
int x =0;
|
|
|
|
/* Inject each character one at a time. */
|
|
for (x=0; x < length; x++)
|
|
{
|
|
ret = injectCDKEntry (entry, actions[x]);
|
|
if (entry->exitType != vEARLY_EXIT)
|
|
{
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Make sure we return the correct info. */
|
|
if (entry->exitType == vNORMAL)
|
|
{
|
|
return entry->info;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This injects a single character into the widget.
|
|
*/
|
|
char *injectCDKEntry (CDKENTRY *entry, chtype input)
|
|
{
|
|
/* Declare local variables. */
|
|
int ppReturn = 1;
|
|
int temp, x, charCount, stringLen;
|
|
char holder;
|
|
|
|
/* Check if there is a pre-process function to be called. */
|
|
if (entry->preProcessFunction != 0)
|
|
{
|
|
/* Call the pre-process function. */
|
|
ppReturn = ((PROCESSFN)(entry->preProcessFunction)) (vENTRY, entry, entry->preProcessData, input);
|
|
}
|
|
|
|
/* Should we continue? */
|
|
if (ppReturn != 0)
|
|
{
|
|
/* Check a predefined binding... */
|
|
if (checkCDKObjectBind (vENTRY, entry, input) != 0)
|
|
{
|
|
entry->exitType = vEARLY_EXIT;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
switch (input)
|
|
{
|
|
case KEY_UP :
|
|
case KEY_DOWN :
|
|
Beep();
|
|
break;
|
|
|
|
case CDK_BEGOFLINE :
|
|
entry->leftChar = 0;
|
|
entry->screenCol = 0;
|
|
break;
|
|
|
|
case CDK_TRANSPOSE :
|
|
stringLen = (int)strlen (entry->info);
|
|
temp = entry->leftChar + entry->screenCol;
|
|
if (temp >= stringLen-1)
|
|
{
|
|
Beep();
|
|
}
|
|
else
|
|
{
|
|
holder = entry->info[temp];
|
|
entry->info[temp] = entry->info[temp + 1];
|
|
entry->info[temp + 1] = holder;
|
|
}
|
|
break;
|
|
|
|
case CDK_ENDOFLINE :
|
|
stringLen = (int)strlen (entry->info);
|
|
if (stringLen >= entry->fieldWidth)
|
|
{
|
|
charCount = (int)(entry->fieldWidth * .8);
|
|
entry->leftChar = stringLen - charCount;
|
|
entry->screenCol = charCount;
|
|
}
|
|
else
|
|
{
|
|
entry->leftChar = 0;
|
|
entry->screenCol = stringLen;
|
|
}
|
|
break;
|
|
|
|
case KEY_LEFT :
|
|
case CDK_BACKCHAR :
|
|
if (entry->screenCol == 0)
|
|
{
|
|
if (entry->leftChar == 0)
|
|
{
|
|
Beep();
|
|
}
|
|
else
|
|
{
|
|
/* Scroll left. */
|
|
entry->leftChar--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
--entry->screenCol;
|
|
}
|
|
break;
|
|
|
|
case KEY_RIGHT :
|
|
case CDK_FORCHAR :
|
|
temp = (int)strlen (entry->info);
|
|
if (entry->screenCol == entry->fieldWidth-1)
|
|
{
|
|
if ((entry->leftChar + entry->screenCol + 1) == temp)
|
|
{
|
|
Beep();
|
|
}
|
|
else
|
|
{
|
|
/* Scroll to the right. */
|
|
entry->leftChar++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Move right. */
|
|
if ((entry->leftChar + entry->screenCol) == temp)
|
|
{
|
|
Beep();
|
|
}
|
|
else
|
|
{
|
|
++entry->screenCol;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DELETE :
|
|
case CONTROL('H') :
|
|
case KEY_BACKSPACE :
|
|
case KEY_DC :
|
|
if (entry->dispType == vVIEWONLY)
|
|
{
|
|
Beep();
|
|
}
|
|
else
|
|
{
|
|
/* Get the length of the widget information. */
|
|
int infoLength = (int)strlen (entry->info);
|
|
if ((entry->leftChar + entry->screenCol) < infoLength)
|
|
{
|
|
/* We are deleteing from inside the string. */
|
|
int currPos = entry->screenCol + entry->leftChar;
|
|
for (x=currPos; x < infoLength; x++)
|
|
{
|
|
entry->info[x] = entry->info[x + 1];
|
|
}
|
|
entry->info[infoLength] = '\0';
|
|
}
|
|
else
|
|
{
|
|
/* We are deleting from the end of the string. */
|
|
if (infoLength > 0)
|
|
{
|
|
/* Update the character pointer. */
|
|
entry->info[infoLength-1] = '\0';
|
|
infoLength--;
|
|
|
|
/* Adjust the cursor. */
|
|
if (entry->screenCol > 0)
|
|
{
|
|
entry->screenCol--;
|
|
}
|
|
|
|
/*
|
|
* If we deleted the last character on the
|
|
* screen and the information has scrolled,
|
|
* adjust the entry field to show the info.
|
|
*/
|
|
if (entry->leftChar > 0 && entry->screenCol == 1)
|
|
{
|
|
if (infoLength < entry->fieldWidth-1)
|
|
{
|
|
entry->leftChar = 0;
|
|
entry->screenCol = infoLength;
|
|
}
|
|
else
|
|
{
|
|
entry->leftChar -= (entry->fieldWidth-3);
|
|
entry->screenCol = entry->fieldWidth-2;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Beep();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEY_ESC :
|
|
entry->exitType = vESCAPE_HIT;
|
|
return 0;
|
|
|
|
case CDK_ERASE :
|
|
if ((int)strlen(entry->info) != 0)
|
|
{
|
|
cleanCDKEntry (entry);
|
|
}
|
|
break;
|
|
|
|
case CDK_CUT:
|
|
if ((int)strlen(entry->info) != 0)
|
|
{
|
|
freeChar (GPasteBuffer);
|
|
GPasteBuffer = copyChar (entry->info);
|
|
cleanCDKEntry (entry);
|
|
}
|
|
else
|
|
{
|
|
Beep();
|
|
}
|
|
break;
|
|
|
|
case CDK_COPY:
|
|
if ((int)strlen(entry->info) != 0)
|
|
{
|
|
freeChar (GPasteBuffer);
|
|
GPasteBuffer = copyChar (entry->info);
|
|
}
|
|
else
|
|
{
|
|
Beep();
|
|
}
|
|
break;
|
|
|
|
case CDK_PASTE:
|
|
if (GPasteBuffer != 0)
|
|
{
|
|
setCDKEntryValue (entry, GPasteBuffer);
|
|
}
|
|
else
|
|
{
|
|
Beep();
|
|
}
|
|
break;
|
|
|
|
case KEY_RETURN : case KEY_TAB : case KEY_ENTER : case KEY_CR :
|
|
if ((int)strlen (entry->info) >= entry->min)
|
|
{
|
|
entry->exitType = vNORMAL;
|
|
return (entry->info);
|
|
}
|
|
else
|
|
{
|
|
Beep();
|
|
}
|
|
break;
|
|
|
|
case CDK_REFRESH :
|
|
eraseCDKScreen (ScreenOf(entry));
|
|
refreshCDKScreen (ScreenOf(entry));
|
|
break;
|
|
|
|
default :
|
|
((ENTRYCB)entry->callbackfn)(entry, input);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Should we do a post-process? */
|
|
if (entry->postProcessFunction != 0)
|
|
{
|
|
((PROCESSFN)(entry->postProcessFunction)) (vENTRY, entry, entry->postProcessData, input);
|
|
}
|
|
}
|
|
|
|
/* Refresh the entry field. */
|
|
drawCDKEntryField (entry);
|
|
|
|
/* Return and indicate that we exited early. */
|
|
entry->exitType = vEARLY_EXIT;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This moves the entry field to the given location.
|
|
*/
|
|
static void _moveCDKEntry (CDKOBJS *object, int xplace, int yplace, boolean relative, boolean refresh_flag)
|
|
{
|
|
CDKENTRY *entry = (CDKENTRY *)object;
|
|
|
|
/*
|
|
* If this is a relative move, then we will adjust where we want
|
|
* to move to.
|
|
*/
|
|
if (relative)
|
|
{
|
|
xplace += getbegx(entry->win);
|
|
yplace += getbegy(entry->win);
|
|
}
|
|
|
|
/* Adjust the window if we need to. */
|
|
alignxy (WindowOf(entry), &xplace, &yplace, entry->boxWidth, entry->boxHeight);
|
|
|
|
/* Move the window to the new location. */
|
|
moveCursesWindow(entry->win, xplace, yplace);
|
|
|
|
/* Redraw the window, if they asked for it. */
|
|
if (refresh_flag)
|
|
{
|
|
drawCDKEntry (entry, ObjOf(entry)->box);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This is a generic character parser for the entry field. It is used as a
|
|
* callback function, so any personal modifications can be made by creating
|
|
* a new function and calling the activation with its name.
|
|
*/
|
|
static void CDKEntryCallBack (CDKENTRY *entry, chtype character)
|
|
{
|
|
/* Declare local variables. */
|
|
char plainchar = (character & A_CHARTEXT);
|
|
int temp, x;
|
|
|
|
/* Start checking the input. */
|
|
if ((entry->dispType == vINT ||
|
|
entry->dispType == vHINT) &&
|
|
!isdigit((int)plainchar))
|
|
{
|
|
Beep();
|
|
}
|
|
else if ((entry->dispType == vCHAR ||
|
|
entry->dispType == vUCHAR ||
|
|
entry->dispType == vLCHAR ||
|
|
entry->dispType == vUHCHAR ||
|
|
entry->dispType == vLHCHAR) &&
|
|
isdigit((int)plainchar))
|
|
{
|
|
Beep();
|
|
}
|
|
else if (entry->dispType == vVIEWONLY)
|
|
{
|
|
Beep();
|
|
}
|
|
else
|
|
{
|
|
if ((int)strlen (entry->info) == entry->max)
|
|
{
|
|
Beep();
|
|
}
|
|
else
|
|
{
|
|
/* We will make any adjustments to the case of the character. */
|
|
if ((entry->dispType == vUCHAR ||
|
|
entry->dispType == vUHCHAR ||
|
|
entry->dispType == vUMIXED ||
|
|
entry->dispType == vUHMIXED)
|
|
&& !isdigit((int)plainchar))
|
|
{
|
|
plainchar = toupper (plainchar);
|
|
}
|
|
else if ((entry->dispType == vLCHAR ||
|
|
entry->dispType == vLHCHAR ||
|
|
entry->dispType == vLMIXED ||
|
|
entry->dispType == vLHMIXED) &&
|
|
!isdigit((int)plainchar))
|
|
{
|
|
plainchar = tolower (plainchar);
|
|
}
|
|
|
|
/* Update the screen and pointer. */
|
|
if (entry->screenCol != entry->fieldWidth-1)
|
|
{
|
|
/* Update the character pointer. */
|
|
temp = (int)strlen (entry->info);
|
|
for (x=temp; x > entry->screenCol + entry->leftChar; x--)
|
|
{
|
|
entry->info[x] = entry->info[x-1];
|
|
}
|
|
entry->info[entry->screenCol + entry->leftChar] = plainchar;
|
|
entry->screenCol++;
|
|
}
|
|
else
|
|
{
|
|
/* Update the character pointer. */
|
|
temp = (int)strlen (entry->info);
|
|
entry->info[temp] = plainchar;
|
|
entry->info[temp + 1] = '\0';
|
|
entry->leftChar++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This erases the information in the entry field
|
|
* and redraws a clean and empty entry field.
|
|
*/
|
|
void cleanCDKEntry (CDKENTRY *entry)
|
|
{
|
|
/* Erase the information in the character pointer. */
|
|
cleanChar (entry->info, entry->infoWidth, '\0');
|
|
|
|
/* Clean the entry screen field. */
|
|
mvwhline (entry->fieldWin, 0, 0, entry->filler, entry->fieldWidth);
|
|
|
|
/* Reset some variables. */
|
|
entry->screenCol = 0;
|
|
entry->leftChar = 0;
|
|
|
|
/* Refresh the entry field. */
|
|
wmove (entry->fieldWin, 0, entry->screenCol);
|
|
wnoutrefresh (entry->fieldWin);
|
|
wnoutrefresh (entry->win);
|
|
}
|
|
|
|
/*
|
|
* This draws the entry field.
|
|
*/
|
|
static void _drawCDKEntry (CDKOBJS *object, boolean Box)
|
|
{
|
|
CDKENTRY *entry = (CDKENTRY *)object;
|
|
int x;
|
|
|
|
/* Box the widget if asked. */
|
|
if (Box)
|
|
{
|
|
attrbox (entry->win,
|
|
entry->ULChar, entry->URChar,
|
|
entry->LLChar, entry->LRChar,
|
|
entry->HChar, entry->VChar,
|
|
entry->BoxAttrib,
|
|
entry->shadow);
|
|
}
|
|
|
|
if (entry->titleLines > 0)
|
|
{
|
|
/* Draw in the title if there is one. */
|
|
for (x=0; x < entry->titleLines; x++)
|
|
{
|
|
writeChtype (entry->titleWin,
|
|
entry->titlePos[x], x,
|
|
entry->title[x],
|
|
HORIZONTAL, 0,
|
|
entry->titleLen[x]);
|
|
}
|
|
wnoutrefresh (entry->titleWin);
|
|
}
|
|
|
|
/* Draw in the label to the widget. */
|
|
if (entry->label != 0)
|
|
{
|
|
writeChtype (entry->labelWin, 0, 0,
|
|
entry->label,
|
|
HORIZONTAL, 0,
|
|
entry->labelLen);
|
|
wnoutrefresh (entry->labelWin);
|
|
}
|
|
|
|
/* Redraw the entry field. */
|
|
drawCDKEntryField (entry);
|
|
}
|
|
|
|
/*
|
|
* This redraws the entry field.
|
|
*/
|
|
static void drawCDKEntryField (CDKENTRY *entry)
|
|
{
|
|
/* Declare variables. */
|
|
int infoLength;
|
|
|
|
/* Draw in the filler characters.*/
|
|
mvwhline (entry->fieldWin, 0, 0, entry->filler, entry->fieldWidth);
|
|
|
|
/* If there is information in the field. Then draw it in. */
|
|
if (entry->info != 0)
|
|
{
|
|
infoLength = (int)strlen (entry->info);
|
|
|
|
/* Redraw the field. */
|
|
if (entry->dispType == vHINT ||
|
|
entry->dispType == vHCHAR ||
|
|
entry->dispType == vHMIXED ||
|
|
entry->dispType == vUHCHAR ||
|
|
entry->dispType == vLHCHAR ||
|
|
entry->dispType == vUHMIXED ||
|
|
entry->dispType == vLHMIXED)
|
|
{
|
|
mvwhline (entry->fieldWin, 0, 0, entry->hidden,
|
|
infoLength - entry->leftChar);
|
|
}
|
|
else
|
|
{
|
|
writeCharAttrib (entry->fieldWin, 0, 0, entry->info,
|
|
entry->fieldAttr, HORIZONTAL, entry->leftChar,
|
|
infoLength);
|
|
}
|
|
}
|
|
|
|
/* Refresh the entry field. */
|
|
wmove (entry->fieldWin, 0, entry->screenCol);
|
|
wnoutrefresh (entry->fieldWin);
|
|
wnoutrefresh (entry->win);
|
|
}
|
|
|
|
/*
|
|
* This erases an entry widget from the screen.
|
|
*/
|
|
static void _eraseCDKEntry (CDKOBJS *object)
|
|
{
|
|
CDKENTRY *entry = (CDKENTRY *)object;
|
|
|
|
eraseCursesWindow (entry->win);
|
|
}
|
|
|
|
/*
|
|
* This destroys an entry widget.
|
|
*/
|
|
void destroyCDKEntry (CDKENTRY *entry)
|
|
{
|
|
int x;
|
|
|
|
/* Erase the object. */
|
|
eraseCDKEntry (entry);
|
|
|
|
/* Clear out the character pointers. */
|
|
for (x=0; x < entry->titleLines; x++)
|
|
{
|
|
freeChtype (entry->title[x]);
|
|
}
|
|
freeChtype (entry->label);
|
|
freeChar (entry->info);
|
|
|
|
/* Delete the windows. */
|
|
deleteCursesWindow (entry->win);
|
|
|
|
/* Unregister this object. */
|
|
unregisterCDKObject (vENTRY, entry);
|
|
|
|
/* Finish cleaning up. */
|
|
free (entry);
|
|
}
|
|
|
|
/*
|
|
* This sets specific attributes of the entry field.
|
|
*/
|
|
void setCDKEntry (CDKENTRY *entry, char *value, int min, int max, boolean Box)
|
|
{
|
|
setCDKEntryValue (entry, value);
|
|
setCDKEntryMin (entry, min);
|
|
setCDKEntryMax (entry, max);
|
|
setCDKEntryBox (entry, Box);
|
|
}
|
|
|
|
/*
|
|
* This removes the old information in the entry field and keeps the
|
|
* new information given.
|
|
*/
|
|
void setCDKEntryValue (CDKENTRY *entry, char *newValue)
|
|
{
|
|
/* Declare local variables. */
|
|
int copychars = 0;
|
|
int stringLen = 0;
|
|
int charCount = 0;
|
|
|
|
/* If the pointer sent in is the same pointer as before, do nothing. */
|
|
if (entry->info == newValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* Just to be sure, if lets make sure the new value isn't null. */
|
|
if (newValue == 0)
|
|
{
|
|
/* Then we want to just erase the old value. */
|
|
cleanChar (entry->info, entry->infoWidth, '\0');
|
|
|
|
/* Set the pointers back to zero. */
|
|
entry->leftChar = 0;
|
|
entry->screenCol = 0;
|
|
return;
|
|
}
|
|
|
|
/* Determine how many characters we need to copy. */
|
|
copychars = MINIMUM ((int)strlen(newValue), entry->max);
|
|
|
|
/* OK, erase the old value, and copy in the new value. */
|
|
cleanChar (entry->info, entry->max, '\0');
|
|
strncpy (entry->info, newValue, copychars);
|
|
stringLen = (int)strlen (entry->info);
|
|
|
|
/* Now determine the values of leftChar and screenCol. */
|
|
if (stringLen >= entry->fieldWidth)
|
|
{
|
|
charCount = (int)(entry->fieldWidth * .8);
|
|
entry->leftChar = stringLen - charCount;
|
|
entry->screenCol = charCount;
|
|
}
|
|
else
|
|
{
|
|
entry->leftChar = 0;
|
|
entry->screenCol = stringLen;
|
|
}
|
|
}
|
|
char *getCDKEntryValue (CDKENTRY *entry)
|
|
{
|
|
return entry->info;
|
|
}
|
|
|
|
/*
|
|
* This sets the maximum length of the string that will be accepted.
|
|
*/
|
|
void setCDKEntryMax (CDKENTRY *entry, int max)
|
|
{
|
|
entry->max = max;
|
|
}
|
|
int getCDKEntryMax (CDKENTRY *entry)
|
|
{
|
|
return entry->max;
|
|
}
|
|
|
|
/*
|
|
* This sets the minimum length of the string that will
|
|
* be accepted.
|
|
*/
|
|
void setCDKEntryMin (CDKENTRY *entry, int min)
|
|
{
|
|
entry->min = min;
|
|
}
|
|
int getCDKEntryMin (CDKENTRY *entry)
|
|
{
|
|
return entry->min;
|
|
}
|
|
|
|
/*
|
|
* This sets the filler character to be used in the entry field.
|
|
*/
|
|
void setCDKEntryFillerChar (CDKENTRY *entry, chtype fillerCharacter)
|
|
{
|
|
entry->filler = fillerCharacter;
|
|
}
|
|
chtype getCDKEntryFillerChar (CDKENTRY *entry)
|
|
{
|
|
return entry->filler;
|
|
}
|
|
|
|
/*
|
|
* This sets the character to use when a hidden type is used.
|
|
*/
|
|
void setCDKEntryHiddenChar (CDKENTRY *entry, chtype hiddenCharacter)
|
|
{
|
|
entry->hidden = hiddenCharacter;
|
|
}
|
|
chtype getCDKEntryHiddenChar (CDKENTRY *entry)
|
|
{
|
|
return entry->hidden;
|
|
}
|
|
|
|
/*
|
|
* This sets whether or not the entry field will be boxed.
|
|
*/
|
|
void setCDKEntryBox (CDKENTRY *entry, boolean Box)
|
|
{
|
|
ObjOf(entry)->box = Box;
|
|
}
|
|
boolean getCDKEntryBox (CDKENTRY *entry)
|
|
{
|
|
return ObjOf(entry)->box;
|
|
}
|
|
|
|
/*
|
|
* These functions set the drawing characters of the widget.
|
|
*/
|
|
void setCDKEntryULChar (CDKENTRY *entry, chtype character)
|
|
{
|
|
entry->ULChar = character;
|
|
}
|
|
void setCDKEntryURChar (CDKENTRY *entry, chtype character)
|
|
{
|
|
entry->URChar = character;
|
|
}
|
|
void setCDKEntryLLChar (CDKENTRY *entry, chtype character)
|
|
{
|
|
entry->LLChar = character;
|
|
}
|
|
void setCDKEntryLRChar (CDKENTRY *entry, chtype character)
|
|
{
|
|
entry->LRChar = character;
|
|
}
|
|
void setCDKEntryVerticalChar (CDKENTRY *entry, chtype character)
|
|
{
|
|
entry->VChar = character;
|
|
}
|
|
void setCDKEntryHorizontalChar (CDKENTRY *entry, chtype character)
|
|
{
|
|
entry->HChar = character;
|
|
}
|
|
void setCDKEntryBoxAttribute (CDKENTRY *entry, chtype character)
|
|
{
|
|
entry->BoxAttrib = character;
|
|
}
|
|
|
|
/*
|
|
* This sets the background color of the widget.
|
|
*/
|
|
void setCDKEntryBackgroundColor (CDKENTRY *entry, char *color)
|
|
{
|
|
chtype *holder = 0;
|
|
int 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. */
|
|
wbkgd (entry->win, holder[0]);
|
|
wbkgd (entry->fieldWin, holder[0]);
|
|
if (entry->label != 0)
|
|
{
|
|
wbkgd (entry->labelWin, holder[0]);
|
|
}
|
|
|
|
/* Clean up. */
|
|
freeChtype (holder);
|
|
}
|
|
|
|
/*
|
|
* This sets the entry field callback function.
|
|
*/
|
|
void setCDKEntryCB (CDKENTRY *entry, ENTRYCB callback)
|
|
{
|
|
entry->callbackfn = (void *)callback;
|
|
}
|
|
|
|
/*
|
|
* This function sets the pre-process function.
|
|
*/
|
|
void setCDKEntryPreProcess (CDKENTRY *entry, PROCESSFN callback, void *data)
|
|
{
|
|
entry->preProcessFunction = callback;
|
|
entry->preProcessData = data;
|
|
}
|
|
|
|
/*
|
|
* This function sets the post-process function.
|
|
*/
|
|
void setCDKEntryPostProcess (CDKENTRY *entry, PROCESSFN callback, void *data)
|
|
{
|
|
entry->postProcessFunction = callback;
|
|
entry->postProcessData = data;
|
|
}
|