/*
* This demonstrates the Cdk preprocess feature.
*/
int main (void)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKENTRY *widget = 0;
const char *title = "<C>Type in anything you want\n<C>but the dreaded letter </B>G<!B>!";
char *info;
const char *mesg[10];
char temp[256];
cdkscreen = initCDKScreen (NULL);
/* Start CDK colors. */
initCDKColor ();
/* Create the entry field widget. */
widget = newCDKEntry (cdkscreen, CENTER, CENTER,
title, 0, A_NORMAL, '.', vMIXED,
40, 0, 256, TRUE, FALSE);
/* Is the widget null? */
if (widget == 0)
{
/* Clean up. */
destroyCDKScreen (cdkscreen);
endCDK ();
printf ("Cannot create the entry box. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
setCDKEntryPreProcess (widget, entryPreProcessCB, 0);
/* Activate the entry field. */
info = activateCDKEntry (widget, 0);
/* Tell them what they typed. */
if (widget->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape. No information passed back.";
mesg[1] = "",
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2)mesg, 3);
}
else if (widget->exitType == vNORMAL)
{
mesg[0] = "<C>You typed in the following";
sprintf (temp, "<C>(%.*s)", (int)(sizeof (temp) - 20), info);
mesg[1] = temp;
mesg[2] = "";
mesg[3] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2)mesg, 4);
}
/* Clean up and exit. */
destroyCDKEntry (widget);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
/* Declare variables. */
CDKSCREEN *cdkscreen;
CDKLABEL *demo;
WINDOW *cursesWin;
char *mesg[4];
CDK_PARAMS params;
CDKparseParams(argc, argv, ¶ms, CDK_MIN_PARAMS);
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Colors. */
initCDKColor();
/* Set the labels up. */
mesg[0] = "</5><#UL><#HL(30)><#UR>";
mesg[1] = "</5><#VL(10)>Hello World!<#VL(10)>";
mesg[2] = "</5><#LL><#HL(30)><#LR>";
/* Declare the labels. */
demo = newCDKLabel (cdkscreen,
CDKparamValue(¶ms, 'X', CENTER),
CDKparamValue(¶ms, 'Y', CENTER),
mesg, 3,
CDKparamValue(¶ms, 'N', TRUE),
CDKparamValue(¶ms, 'S', TRUE));
setCDKLabelBackgroundAttrib (demo, COLOR_PAIR(2));
/* Is the label null? */
if (demo == 0)
{
/* Clean up the memory. */
destroyCDKScreen (cdkscreen);
/* End curses... */
endCDK();
/* Spit out a message. */
printf ("Oops. Can't seem to create the label. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
/* Draw the CDK screen. */
refreshCDKScreen (cdkscreen);
waitCDKLabel (demo, ' ');
/* Clean up. */
destroyCDKLabel (demo);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
void hacer(int opcion)
{
switch(opcion)
{
case 0:
waddstr(stdscr,"0000esuuaaa");
destroyCDKScreen(cdkScreen);
endCDK();
exit(0);
break;
case 1:
waddstr(stdscr,"111111esuuaaa");
break;
case 2:
waddstr(stdscr,"222222esuuaaa");
break;
case 3:
waddstr(stdscr,"33333esuuaaa");
break;
case 4:
waddstr(stdscr,"4444444esaaa");
break;
case 5:
waddstr(stdscr,"55555");
break;
default:
waddstr(stdscr,"nada");
}
}
void UiFactoryCurses::deinit()
{
delete m_browser;
m_browser = 0;
delete m_renderer;
m_renderer = 0;
destroyCDKScreen(m_screen);
endCDK();
delwin(m_scr);
}
void quit()
{
destroyCDKScreen (cdkscreen);
delwin (cursesWin);
/* Shutdown CDK. */
endCDK();
/* Exit cleanly. */
exit (0);
}
int wifi_handler(WINDOW *win, void *ptr)
{
CDKSCREEN *screen;
screen = initCDKScreen(win);
load_driver();
show_info(screen);
unload_driver();
destroyCDKScreen(screen);
return 0;
}
int autorun_handler(WINDOW *win, void *ptr)
{
char *mesg[2];
CDKSCREEN *screen;
screen = initCDKScreen(win);
mesg[0] = "<C>Auto Running Hardware Test ...";
mesg[1] = "<C>Hit any key to continue.";
popupLabel(screen, mesg, 2);
run_modules(screen, ptr);
destroyCDKScreen(screen);
return 0;
}
int
gp_cmd_config (Camera *camera, GPContext *context)
{
CmdConfig cmd_config;
CameraWidget *config;
int result;
CDKSCREEN *screen = NULL;
WINDOW *window = NULL;
if (!camera)
return (GP_ERROR_BAD_PARAMETERS);
result = gp_camera_get_config (camera, &config, context);
if (result < 0)
return (result);
/* Set up CDK. */
window = initscr ();
screen = initCDKScreen (window);
/* Set up CDK Colors. */
initCDKColor ();
/* Go! */
cmd_config.camera = camera;
cmd_config.screen = screen;
cmd_config.window = config;
cmd_config.context = context;
result = show_widget (&cmd_config, config);
/* Clean up */
destroyCDKScreen (screen);
delwin (window);
endCDK ();
return (result);
}
/*
* This program demonstrates the Cdk calendar widget.
*/
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKCALENDAR *calendar = 0;
WINDOW *cursesWin = 0;
const char *title = "<C></U>CDK Appointment Book\n<C><#HL(30)>\n";
char *filename = 0;
struct tm *dateInfo = 0;
time_t clck = 0;
struct AppointmentInfo appointmentInfo;
int day, month, year, ret, x;
char temp[1000];
/*
* Get the current dates and set the default values for
* the day/month/year values for the calendar.
*/
/* *INDENT-EQLS* */
time (&clck);
dateInfo = gmtime (&clck);
day = dateInfo->tm_mday;
month = dateInfo->tm_mon + 1;
year = dateInfo->tm_year + 1900;
/* Check the command line for options. */
while (1)
{
/* Are there any more command line options to parse. */
if ((ret = getopt (argc, argv, "d:m:y:t:f:")) == -1)
{
break;
}
switch (ret)
{
case 'd':
day = atoi (optarg);
break;
case 'm':
month = atoi (optarg);
break;
case 'y':
year = atoi (optarg);
break;
case 't':
title = copyChar (optarg);
break;
case 'f':
filename = copyChar (optarg);
break;
}
}
/* Create the appointment book filename. */
if (filename == 0)
{
char *home = getenv ("HOME");
if (home != 0)
{
sprintf (temp, "%.*s/.appointment", (int)sizeof (temp) - 20, home);
}
else
{
strcat (temp, ".appointment");
}
filename = copyChar (temp);
}
/* Read the appointment book information. */
readAppointmentFile (filename, &appointmentInfo);
/* Set up CDK. */
cursesWin = initscr ();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Colors. */
initCDKColor ();
/* Create the calendar widget. */
calendar = newCDKCalendar (cdkscreen, CENTER, CENTER,
title, day, month, year,
A_NORMAL, A_NORMAL,
A_NORMAL, A_REVERSE,
TRUE, FALSE);
/* Is the widget null? */
if (calendar == 0)
{
/* Clean up the memory. */
destroyCDKScreen (cdkscreen);
/* End curses... */
endCDK ();
/* Spit out a message. */
printf ("Cannot create the calendar. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
/* Create a key binding to mark days on the calendar. */
bindCDKObject (vCALENDAR, calendar, 'm', createCalendarMarkCB, &appointmentInfo);
bindCDKObject (vCALENDAR, calendar, 'M', createCalendarMarkCB, &appointmentInfo);
bindCDKObject (vCALENDAR, calendar, 'r', removeCalendarMarkCB, &appointmentInfo);
bindCDKObject (vCALENDAR, calendar, 'R', removeCalendarMarkCB, &appointmentInfo);
bindCDKObject (vCALENDAR, calendar, '?', displayCalendarMarkCB, &appointmentInfo);
bindCDKObject (vCALENDAR, calendar, 'j', accelerateToDateCB, &appointmentInfo);
bindCDKObject (vCALENDAR, calendar, 'J', accelerateToDateCB, &appointmentInfo);
/* Set all the appointments read from the file. */
for (x = 0; x < appointmentInfo.appointmentCount; x++)
{
chtype marker = GPAppointmentAttributes[appointmentInfo.appointment[x].type];
setCDKCalendarMarker (calendar,
appointmentInfo.appointment[x].day,
appointmentInfo.appointment[x].month,
appointmentInfo.appointment[x].year,
marker);
}
/* Draw the calendar widget. */
drawCDKCalendar (calendar, ObjOf (calendar)->box);
/* Let the user play with the widget. */
activateCDKCalendar (calendar, 0);
/* Save the appointment information. */
saveAppointmentFile (filename, &appointmentInfo);
free (filename);
/* Clean up and exit. */
destroyCDKCalendar (calendar);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkScreen = 0;
CDKMATRIX *widget = 0;
CDKBUTTONBOX *buttonWidget = 0;
chtype *holder = 0;
char *buttons = 0;
char *CDK_WIDGET_COLOR = 0;
char *temp = 0;
chtype filler = A_NORMAL | '.';
int rows = -1;
int cols = -1;
int buttonCount = 0;
int selection = 0;
int shadowHeight = 0;
FILE *fp = stderr;
char **rowTitles;
char **colTitles;
char **rowTemp = 0;
char **colTemp = 0;
char **kolTemp = 0;
char **buttonList = 0;
int *colWidths;
int *colTypes;
int count, infoLines, x, y, j1, j2;
CDK_PARAMS params;
boolean boxWidget;
boolean shadowWidget;
char *defaultValue;
char *myColTitles;
char *myColTypes;
char *myColWidths;
char *myFiller;
char *myRowTitles;
char *outputFile;
char *title;
int vrows;
int xpos;
int ypos;
CDKparseParams (argc, argv, ¶ms, "c:d:r:t:w:v:B:F:O:T:" CDK_MIN_PARAMS);
/* *INDENT-EQLS* */
xpos = CDKparamValue (¶ms, 'X', CENTER);
ypos = CDKparamValue (¶ms, 'Y', CENTER);
boxWidget = CDKparamValue (¶ms, 'N', TRUE);
shadowWidget = CDKparamValue (¶ms, 'S', FALSE);
vrows = CDKparamValue (¶ms, 'v', -1);
myColTitles = CDKparamString (¶ms, 'c');
defaultValue = CDKparamString (¶ms, 'd');
myRowTitles = CDKparamString (¶ms, 'r');
myColTypes = CDKparamString (¶ms, 't');
myColWidths = CDKparamString (¶ms, 'w');
buttons = CDKparamString (¶ms, 'B');
myFiller = CDKparamString (¶ms, 'F');
outputFile = CDKparamString (¶ms, 'O');
title = CDKparamString (¶ms, 'T');
/* If the user asked for an output file, try to open it. */
if (outputFile != 0)
{
if ((fp = fopen (outputFile, "w")) == 0)
{
fprintf (stderr, "%s: Can not open output file %s\n", argv[0], outputFile);
ExitProgram (CLI_ERROR);
}
}
/* Make sure all the needed command line parameters were provided. */
if ((myRowTitles == 0) ||
(myColTitles == 0) ||
(myColWidths == 0) ||
(vrows == -1))
{
fprintf (stderr, "Usage: %s %s\n", argv[0], FPUsage);
ExitProgram (CLI_ERROR);
}
/* Convert the char * titles to a char **, offset by one */
rowTemp = CDKsplitString (myRowTitles, '\n');
rows = (int)CDKcountStrings ((CDK_CSTRING2)rowTemp);
rowTitles = (char **)calloc ((size_t) rows + 1, sizeof (char *));
for (x = 0; x < rows; x++)
{
rowTitles[x + 1] = rowTemp[x];
}
colTemp = CDKsplitString (myColTitles, '\n');
cols = (int)CDKcountStrings ((CDK_CSTRING2)colTemp);
colTitles = (char **)calloc ((size_t) cols + 1, sizeof (char *));
for (x = 0; x < cols; x++)
{
colTitles[x + 1] = colTemp[x];
}
/* Convert the column widths. */
kolTemp = CDKsplitString (myColWidths, '\n');
count = (int)CDKcountStrings ((CDK_CSTRING2)kolTemp);
colWidths = (int *)calloc ((size_t) count + 1, sizeof (int));
for (x = 0; x < count; x++)
{
colWidths[x + 1] = atoi (kolTemp[x]);
}
/* If they passed in the column types, convert them. */
if (myColTypes != 0)
{
char **ss = CDKsplitString (myColTypes, '\n');
count = (int)CDKcountStrings ((CDK_CSTRING2)ss);
colTypes = (int *)calloc ((size_t) MAXIMUM (cols, count) + 1, sizeof (int));
for (x = 0; x < count; x++)
{
colTypes[x + 1] = char2DisplayType (ss[x]);
}
CDKfreeStrings (ss);
}
else
{
/* If they didn't set default values. */
colTypes = (int *)calloc ((size_t) cols + 1, sizeof (int));
for (x = 0; x < cols; x++)
{
colTypes[x + 1] = vMIXED;
}
}
cdkScreen = initCDKScreen (NULL);
/* Start color. */
initCDKColor ();
/* Check if the user wants to set the background of the main screen. */
if ((temp = getenv ("CDK_SCREEN_COLOR")) != 0)
{
holder = char2Chtype (temp, &j1, &j2);
wbkgd (cdkScreen->window, holder[0]);
wrefresh (cdkScreen->window);
freeChtype (holder);
}
/* Get the widget color background color. */
if ((CDK_WIDGET_COLOR = getenv ("CDK_WIDGET_COLOR")) == 0)
{
CDK_WIDGET_COLOR = 0;
}
/* If the set the filler character, set it now. */
if (myFiller != 0)
{
holder = char2Chtype (myFiller, &j1, &j2);
filler = holder[0];
freeChtype (holder);
}
/* Create the matrix widget. */
widget = newCDKMatrix (cdkScreen, xpos, ypos,
rows, cols, vrows, cols,
title, (CDK_CSTRING2)rowTitles, (CDK_CSTRING2)colTitles,
colWidths, colTypes, 1, 1,
filler, COL,
boxWidget, TRUE, shadowWidget);
free (rowTitles);
free (colTitles);
/* Make sure we could create the widget. */
if (widget == 0)
{
/* Shut down curses and CDK. */
destroyCDKScreen (cdkScreen);
endCDK ();
fprintf (stderr,
"Error: Cannot create the matrix. "
"Is the window too small?\n");
ExitProgram (CLI_ERROR);
}
/*
* If the user sent in a file of default values, read it and
* stick the values read in from the file into the matrix.
*/
if (defaultValue != 0)
{
size_t limit = (size_t) ((rows + 1) * (cols + 1));
char **info = (char **)calloc (limit, sizeof (char *));
char **lineTemp = 0;
/* Read the file. */
infoLines = CDKreadFile (defaultValue, &lineTemp);
if (infoLines > 0)
{
int *subSize = (int *)calloc ((size_t) infoLines + 1, sizeof (int));
/* For each line, split on a CTRL-V. */
for (x = 0; x < infoLines; x++)
{
char **ss = CDKsplitString (lineTemp[x], CTRL ('V'));
subSize[x + 1] = (int)CDKcountStrings ((CDK_CSTRING2)ss);
for (y = 0; y < subSize[x + 1]; y++)
{
MY_INFO (x, y) = ss[y];
}
free (ss);
}
CDKfreeStrings (lineTemp);
setCDKMatrixCells (widget, (CDK_CSTRING2)info, rows, cols, subSize);
for (x = 0; x < infoLines; x++)
{
for (y = 0; y < subSize[x + 1]; y++)
{
freeChar (MY_INFO (x, y));
}
}
free (info);
free (subSize);
}
}
/* Split the buttons if they supplied some. */
if (buttons != 0)
{
/* Split the button list up. */
buttonList = CDKsplitString (buttons, '\n');
buttonCount = (int)CDKcountStrings ((CDK_CSTRING2)buttonList);
/* We need to create a buttonbox widget. */
buttonWidget = newCDKButtonbox (cdkScreen,
getbegx (widget->win),
(getbegy (widget->win)
+ widget->boxHeight - 1),
1, widget->boxWidth - 1,
NULL, 1, buttonCount,
(CDK_CSTRING2)buttonList, buttonCount,
A_REVERSE, boxWidget, FALSE);
setCDKButtonboxULChar (buttonWidget, ACS_LTEE);
setCDKButtonboxURChar (buttonWidget, ACS_RTEE);
/*
* We need to set the lower left and right
* characters of the widget.
*/
setCDKMatrixLLChar (widget, ACS_LTEE);
setCDKMatrixLRChar (widget, ACS_RTEE);
/*
* Bind the Tab key in the widget to send a
* Tab key to the button box widget.
*/
bindCDKObject (vMATRIX, widget, KEY_TAB, widgetCB, buttonWidget);
bindCDKObject (vMATRIX, widget, CDK_NEXT, widgetCB, buttonWidget);
bindCDKObject (vMATRIX, widget, CDK_PREV, widgetCB, buttonWidget);
/* Check if the user wants to set the background of the widget. */
setCDKButtonboxBackgroundColor (buttonWidget, CDK_WIDGET_COLOR);
/* Draw the button widget. */
drawCDKButtonbox (buttonWidget, boxWidget);
}
/*
* If the user asked for a shadow, we need to create one. Do this instead
* of using the shadow parameter because the button widget is not part of
* the main widget and if the user asks for both buttons and a shadow, we
* need to create a shadow big enough for both widgets. Create the shadow
* window using the widgets shadowWin element, so screen refreshes will draw
* them as well.
*/
if (shadowWidget == TRUE)
{
/* Determine the height of the shadow window. */
shadowHeight = (buttonWidget == (CDKBUTTONBOX *)NULL ?
widget->boxHeight :
widget->boxHeight + buttonWidget->boxHeight - 1);
/* Create the shadow window. */
widget->shadowWin = newwin (shadowHeight,
widget->boxWidth,
getbegy (widget->win) + 1,
getbegx (widget->win) + 1);
/* Make sure we could have created the shadow window. */
if (widget->shadowWin != 0)
{
widget->shadow = TRUE;
/*
* We force the widget and buttonWidget to be drawn so the
* buttonbox widget will be drawn when the widget is activated.
* Otherwise the shadow window will draw over the button widget.
*/
drawCDKMatrix (widget, ObjOf (widget)->box);
eraseCDKButtonbox (buttonWidget);
drawCDKButtonbox (buttonWidget, ObjOf (buttonWidget)->box);
}
}
/* Check if the user wants to set the background of the widget. */
setCDKMatrixBackgroundColor (widget, CDK_WIDGET_COLOR);
/* Let them play. */
activateCDKMatrix (widget, 0);
/* Print out the matrix cells. */
if (widget->exitType == vNORMAL)
{
for (x = 0; x < widget->rows; x++)
{
for (y = 0; y < widget->cols; y++)
{
char *data = getCDKMatrixCell (widget, x, y);
if (data != 0)
{
fprintf (fp, "%s%c", data, CTRL ('V'));
}
else
{
fprintf (fp, "%c", CTRL ('V'));
}
}
fprintf (fp, "\n");
}
}
/* If there were buttons, get the button selected. */
if (buttonWidget != 0)
{
selection = buttonWidget->currentButton;
destroyCDKButtonbox (buttonWidget);
}
/* cleanup (not really needed) */
CDKfreeStrings (buttonList);
free (colTypes);
free (colWidths);
CDKfreeStrings (rowTemp);
CDKfreeStrings (colTemp);
CDKfreeStrings (kolTemp);
destroyCDKMatrix (widget);
destroyCDKScreen (cdkScreen);
endCDK ();
/* do this late, in case it was stderr */
fclose (fp);
ExitProgram (selection);
}
int main (int argc, char **argv)
{
/* Declare variables. */
CDKSCREEN *cdkScreen = 0;
CDKENTRY *widget = 0;
CDKBUTTONBOX *buttonWidget = 0;
WINDOW *cursesWindow = 0;
chtype *holder = 0;
chtype fieldAttr = A_NORMAL;
char *answer = 0;
char *CDK_WIDGET_COLOR = 0;
char *temp = 0;
char filler = '.';
EDisplayType dType = vMIXED;
int buttonCount = 0;
int selection = 0;
int shadowHeight = 0;
FILE *fp = stderr;
char **buttonList = 0;
int j1, j2;
CDK_PARAMS params;
boolean boxWidget;
boolean shadowWidget;
char *buttons;
char *filename;
char *outputFile;
char *initValue;
char *title;
char *label;
char *tempFiller;
int maxValue;
int fieldWidth;
int minValue;
int xpos;
int ypos;
CDKparseParams(argc, argv, ¶ms, "d:f:i:m:B:F:L:M:O:T:" "X:Y:NS");
xpos = CDKparamValue(¶ms, 'X', CENTER);
ypos = CDKparamValue(¶ms, 'Y', CENTER);
boxWidget = CDKparamValue(¶ms, 'N', TRUE);
shadowWidget = CDKparamValue(¶ms, 'S', FALSE);
minValue = CDKparamValue(¶ms, 'm', 0);
fieldWidth = CDKparamValue(¶ms, 'f', 0);
maxValue = CDKparamValue(¶ms, 'M', 256);
filename = CDKparamString(¶ms, 'f');
initValue = CDKparamString(¶ms, 'i');
buttons = CDKparamString(¶ms, 'B');
tempFiller = CDKparamString(¶ms, 'F');
label = CDKparamString(¶ms, 'L');
outputFile = CDKparamString(¶ms, 'O');
title = CDKparamString(¶ms, 'T');
if ((temp = CDKparamString(¶ms, 'd')) != 0)
dType = char2DisplayType (temp);
/* Make sure all the command line parameters were provided. */
if (fieldWidth <= 0)
{
fprintf (stderr, "Usage: %s %s\n", argv[0], FPUsage);
ExitProgram (CLI_ERROR);
}
/* If the user asked for an output file, try to open it. */
if (outputFile != 0)
{
if ((fp = fopen (outputFile, "w")) == 0)
{
fprintf (stderr, "%s: Can not open output file %s\n", argv[0], outputFile);
ExitProgram (CLI_ERROR);
}
}
/* Set up CDK. */
cursesWindow = initscr();
cdkScreen = initCDKScreen (cursesWindow);
/* Start color. */
initCDKColor();
/* Check if the user wants to set the background of the main screen. */
if ((temp = getenv ("CDK_SCREEN_COLOR")) != 0)
{
holder = char2Chtype (temp, &j1, &j2);
wbkgd (cdkScreen->window, holder[0]);
wrefresh (cdkScreen->window);
freeChtype (holder);
}
/* Get the widget color background color. */
if ((CDK_WIDGET_COLOR = getenv ("CDK_WIDGET_COLOR")) == 0)
{
CDK_WIDGET_COLOR = 0;
}
/* If the set the filler character, set it now. */
if (tempFiller != 0)
{
holder = char2Chtype (tempFiller, &j1, &j2);
fieldAttr = A_ATTRIBUTES & holder[0];
filler = (chtype)holder[0];
freeChtype (holder);
}
/* Create the entry widget. */
widget = newCDKEntry (cdkScreen, xpos, ypos,
title, label,
fieldAttr, filler | fieldAttr,
dType, fieldWidth,
minValue, maxValue,
boxWidget, FALSE);
/* Check to make sure we created the dialog box. */
if (widget == 0)
{
/* Shut down curses and CDK. */
destroyCDKScreen (cdkScreen);
endCDK();
fprintf (stderr, "Error: Could not create the entry field. Is the window too small?\n");
ExitProgram (CLI_ERROR);
}
/* Split the buttons if they supplied some. */
if (buttons != 0)
{
buttonList = CDKsplitString (buttons, '\n');
buttonCount = CDKcountStrings (buttonList);
buttonWidget = newCDKButtonbox (cdkScreen,
getbegx (widget->win),
getbegy (widget->win) + widget->boxHeight - 1,
1, widget->boxWidth - 1,
0, 1, buttonCount,
buttonList, buttonCount,
A_REVERSE, boxWidget, FALSE);
CDKfreeStrings (buttonList);
setCDKButtonboxULChar (buttonWidget, ACS_LTEE);
setCDKButtonboxURChar (buttonWidget, ACS_RTEE);
/*
* We need to set the lower left and right
* characters of the entry field.
*/
setCDKEntryLLChar (widget, ACS_LTEE);
setCDKEntryLRChar (widget, ACS_RTEE);
/*
* Bind the Tab key in the entry field to send a
* Tab key to the button box widget.
*/
bindCDKObject (vENTRY, widget, KEY_TAB, widgetCB, buttonWidget);
bindCDKObject (vENTRY, widget, CDK_NEXT, widgetCB, buttonWidget);
bindCDKObject (vENTRY, widget, CDK_PREV, widgetCB, buttonWidget);
/* Check if the user wants to set the background of the widget. */
setCDKButtonboxBackgroundColor (buttonWidget, CDK_WIDGET_COLOR);
/* Draw the button widget. */
drawCDKButtonbox (buttonWidget, boxWidget);
}
/*
* If the user asked for a shadow, we need to create one. Do this instead
* of using the shadow parameter because the button widget is not part of
* the main widget and if the user asks for both buttons and a shadow, we
* need to create a shadow big enough for both widgets. Create the shadow
* window using the widgets shadowWin element, so screen refreshes will draw
* them as well.
*/
if (shadowWidget == TRUE)
{
/* Determine the height of the shadow window. */
shadowHeight = (buttonWidget == 0 ?
widget->boxHeight :
widget->boxHeight + buttonWidget->boxHeight - 1);
/* Create the shadow window. */
widget->shadowWin = newwin (shadowHeight,
widget->boxWidth,
getbegy (widget->win) + 1,
getbegx (widget->win) + 1);
/* Make sure we could have created the shadow window. */
if (widget->shadowWin != 0)
{
widget->shadow = TRUE;
/*
* We force the widget and buttonWidget to be drawn so the
* buttonbox widget will be drawn when the widget is activated.
* Otherwise the shadow window will draw over the button widget.
*/
drawCDKEntry (widget, ObjOf(widget)->box);
eraseCDKButtonbox (buttonWidget);
drawCDKButtonbox (buttonWidget, ObjOf(buttonWidget)->box);
}
}
/* Check if the user wants to set the background of the widget. */
setCDKEntryBackgroundColor (widget, CDK_WIDGET_COLOR);
/* If there was an initial value, set it. */
if (initValue != 0)
{
setCDKEntryValue (widget, initValue);
}
/* Activate the widget. */
answer = copyChar (activateCDKEntry (widget, 0));
/* If there were buttons, get the button selected. */
if (buttonWidget != 0)
{
selection = buttonWidget->currentButton;
destroyCDKButtonbox (buttonWidget);
}
/* End CDK. */
destroyCDKEntry (widget);
destroyCDKScreen (cdkScreen);
endCDK();
/* Print the value from the widget. */
if (answer != 0)
{
fprintf (fp, "%s\n", answer);
freeChar (answer);
}
fclose (fp);
/* Exit with the button number picked. */
ExitProgram (selection);
}
/*
* This program demonstrates the Cdk scale widget.
*/
int main (int argc, char **argv)
{
/* Declare variables. */
CDKSCREEN *cdkscreen = 0;
CDKSCALE *widget = 0;
WINDOW *cursesWin = 0;
char *title = "<C>Select a value";
char *label = "</5>Current value";
char temp[256], *mesg[5];
int selection;
CDK_PARAMS params;
int high;
int inc;
int low;
CDKparseParams(argc, argv, ¶ms, "h:i:l:w:" CDK_MIN_PARAMS);
high = CDKparamNumber2(¶ms, 'h', 100);
inc = CDKparamNumber2(¶ms, 'i', 1);
low = CDKparamNumber2(¶ms, 'l', 0);
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Colors. */
initCDKColor();
/* Create the widget. */
widget = newCDKScale (cdkscreen,
CDKparamValue(¶ms, 'X', CENTER),
CDKparamValue(¶ms, 'Y', CENTER),
title, label,
A_NORMAL,
CDKparamNumber2(¶ms, 'w', 5),
low, low, high,
inc, (inc*2),
CDKparamValue(¶ms, 'N', TRUE),
CDKparamValue(¶ms, 'S', FALSE));
/* Is the widget null? */
if (widget == 0)
{
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message. */
printf ("Oops. Can't make the widget. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
/* Activate the widget. */
selection = activateCDKScale (widget, 0);
/* Check the exit value of the widget. */
if (widget->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape. No value selected.";
mesg[1] = "",
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, mesg, 3);
}
else if (widget->exitType == vNORMAL)
{
sprintf (temp, "<C>You selected %d", selection);
mesg[0] = copyChar (temp);
mesg[1] = "",
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, mesg, 3);
freeChar (mesg[0]);
}
/* Clean up. */
destroyCDKScale (widget);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
int main (int argc, char **argv)
{
/* Declare variables. */
CDKSCREEN *cdkscreen = 0;
CDKLABEL *demo = 0;
WINDOW *cursesWin = 0;
int boxLabel = 0;
char *mesg[4], temp[256];
struct tm *currentTime;
time_t clck;
int ret;
/* Parse up the command line. */
while ((ret = getopt (argc, argv, "b")) != -1)
{
switch (ret)
{
case 'b' :
boxLabel = 1;
}
}
/* Set up CDK */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Colors */
initCDKColor();
/* Set the labels up. */
mesg[0] = "</1/B>HH:MM:SS";
/* Declare the labels. */
demo = newCDKLabel (cdkscreen, CENTER, CENTER, mesg, 1, boxLabel, FALSE);
/* Is the label null??? */
if (demo == 0)
{
/* Clean up the memory. */
destroyCDKScreen (cdkscreen);
/* End curses... */
endCDK();
/* Spit out a message. */
printf ("Oops. Can't seem to create the label. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
curs_set(0);
wtimeout (WindowOf(demo), 50);
/* Do this for-a-while... */
do
{
/* Get the current time. */
time(&clck);
currentTime = localtime (&clck);
/* Put the current time in a string. */
sprintf (temp, "<C></B/29>%02d:%02d:%02d", currentTime->tm_hour, currentTime->tm_min, currentTime->tm_sec);
mesg[0] = copyChar (temp);
/* Set the label contents. */
setCDKLabel (demo, mesg, 1, ObjOf(demo)->box);
/* Clean up the memory used. */
freeChar (mesg[0]);
/* Draw the label, and sleep. */
drawCDKLabel (demo, ObjOf(demo)->box);
napms (500);
}
while (wgetch(WindowOf(demo)) == ERR);
/* Clean up */
destroyCDKLabel (demo);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
/*
* This program demonstrates the file selector and the viewer widget.
*/
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKVIEWER *example = 0;
CDKFSELECT *fSelect = 0;
WINDOW *cursesWin = 0;
const char *title = "<C>Pick a file.";
const char *label = "File: ";
const char *directory = ".";
char *filename = 0;
char **info = 0;
const char *button[5];
const char *mesg[4];
char vtitle[256];
char temp[256];
int selected, lines, ret;
/* Parse up the command line. */
while (1)
{
ret = getopt (argc, argv, "d:f:");
if (ret == -1)
{
break;
}
switch (ret)
{
case 'd':
directory = strdup (optarg);
break;
case 'f':
filename = strdup (optarg);
break;
}
}
/* Create the viewer buttons. */
button[0] = "</5><OK><!5>";
button[1] = "</5><Cancel><!5>";
/* Set up CDK. */
cursesWin = initscr ();
cdkscreen = initCDKScreen (cursesWin);
/* Start color. */
initCDKColor ();
/* Get the filename. */
if (filename == 0)
{
fSelect = newCDKFselect (cdkscreen, CENTER, CENTER, 20, 65,
title, label, A_NORMAL, '_', A_REVERSE,
"</5>", "</48>", "</N>", "</N>", TRUE, FALSE);
/*
* Set the starting directory. This is not neccessary because when
* the file selector starts it uses the present directory as a default.
*/
setCDKFselect (fSelect, directory, A_NORMAL, '.', A_REVERSE,
"</5>", "</48>", "</N>", "</N>", ObjOf (fSelect)->box);
/* Activate the file selector. */
filename = copyChar (activateCDKFselect (fSelect, 0));
/* Check how the person exited from the widget. */
if (fSelect->exitType == vESCAPE_HIT)
{
/* Pop up a message for the user. */
mesg[0] = "<C>Escape hit. No file selected.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
/* Destroy the file selector. */
destroyCDKFselect (fSelect);
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
}
/* Destroy the file selector. */
destroyCDKFselect (fSelect);
/* Create the file viewer to view the file selected. */
example = newCDKViewer (cdkscreen, CENTER, CENTER, 20, -2,
(CDK_CSTRING2) button, 2,
A_REVERSE, TRUE, FALSE);
/* Could we create the viewer widget? */
if (example == 0)
{
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK ();
/* Print out a message and exit. */
printf ("Cannot create viewer. Is the window too small?\n");
ExitProgram (EXIT_SUCCESS);
}
/* Open the file and read the contents. */
lines = CDKreadFile (filename, &info);
if (lines == -1)
{
printf ("Could not open %s\n", filename);
ExitProgram (EXIT_FAILURE);
}
/* Set up the viewer title, and the contents to the widget. */
sprintf (vtitle, "<C></B/22>%20s<!22!B>", filename);
setCDKViewer (example, vtitle,
(CDK_CSTRING2) info, lines,
A_REVERSE, TRUE, TRUE, TRUE);
/* Activate the viewer widget. */
selected = activateCDKViewer (example, 0);
/* Check how the person exited from the widget. */
if (example->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>Escape hit. No Button selected.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
}
else if (example->exitType == vNORMAL)
{
sprintf (temp, "<C>You selected button %d", selected);
mesg[0] = temp;
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
}
/* Clean up. */
destroyCDKViewer (example);
destroyCDKScreen (cdkscreen);
CDKfreeStrings (info);
freeChar (filename);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
/*
* Demonstrate a scrolling-window.
*/
int main (int argc, char **argv)
{
/* Declare variables. */
CDKSCREEN *cdkscreen = 0;
CDKSWINDOW *swindow = 0;
WINDOW *cursesWin = 0;
char *title = "<C></5>Error Log";
char *mesg[5];
CDK_PARAMS params;
CDKparseParams(argc, argv, ¶ms, CDK_CLI_PARAMS);
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK colors. */
initCDKColor();
/* Create the scrolling window. */
swindow = newCDKSwindow (cdkscreen,
CDKparamValue(¶ms, 'X', CENTER),
CDKparamValue(¶ms, 'Y', CENTER),
CDKparamValue(¶ms, 'H', 6),
CDKparamValue(¶ms, 'W', 65),
title, 100,
CDKparamValue(¶ms, 'N', TRUE),
CDKparamValue(¶ms, 'S', FALSE));
/* Is the window null. */
if (swindow == 0)
{
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message and exit. */
printf ("Oops. Can not seem to create the scrolling window. Is the window too small??\n");
ExitProgram (EXIT_FAILURE);
}
/* Draw the scrolling window. */
drawCDKSwindow (swindow, ObjOf(swindow)->box);
/* Load up the scrolling window. */
addCDKSwindow (swindow, "<C></11>TOP: This is the first line.", BOTTOM);
addCDKSwindow (swindow, "<C>Sleeping for 1 second.", BOTTOM);
sleep (1);
addCDKSwindow (swindow, "<L></11>1: This is another line.", BOTTOM);
addCDKSwindow (swindow, "<C>Sleeping for 1 second.", BOTTOM);
sleep (1);
addCDKSwindow (swindow, "<C></11>2: This is another line.", BOTTOM);
addCDKSwindow (swindow, "<C>Sleeping for 1 second.", BOTTOM);
sleep (1);
addCDKSwindow (swindow, "<R></11>3: This is another line.", BOTTOM);
addCDKSwindow (swindow, "<C>Sleeping for 1 second.", BOTTOM);
sleep (1);
addCDKSwindow (swindow, "<C></11>4: This is another line.", BOTTOM);
addCDKSwindow (swindow, "<C>Sleeping for 1 second.", BOTTOM);
sleep (1);
addCDKSwindow (swindow, "<L></11>5: This is another line.", BOTTOM);
addCDKSwindow (swindow, "<C>Sleeping for 1 second.", BOTTOM);
sleep (1);
addCDKSwindow (swindow, "<C></11>6: This is another line.", BOTTOM);
addCDKSwindow (swindow, "<C>Sleeping for 1 second.", BOTTOM);
sleep (1);
addCDKSwindow (swindow, "<C>Done. You can now play.", BOTTOM);
addCDKSwindow (swindow, "<C>This is being added to the top.", TOP);
/* Activate the scrolling window. */
activateCDKSwindow (swindow, 0);
/* Check how the user exited this widget. */
if (swindow->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape to leave this widget.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, mesg, 3);
}
else if (swindow->exitType == vNORMAL)
{
mesg[0] = "<C>You hit return to exit this widget.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, mesg, 3);
}
/* Clean up. */
destroyCDKSwindow (swindow);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
/* Declare vars. */
CDKSCREEN *cdkscreen = 0;
CDKHISTOGRAM *volume = 0;
CDKHISTOGRAM *bass = 0;
CDKHISTOGRAM *treble = 0;
WINDOW *cursesWin = 0;
char *volumeTitle = "<C></5>Volume<!5>";
char *bassTitle = "<C></5>Bass <!5>";
char *trebleTitle = "<C></5>Treble<!5>";
CDK_PARAMS params;
boolean Box;
CDKparseParams(argc, argv, ¶ms, CDK_CLI_PARAMS);
Box = CDKparamValue(¶ms, 'N', TRUE);
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Color. */
initCDKColor();
/* Create the histogram objects. */
volume = newCDKHistogram (cdkscreen,
CDKparamValue(¶ms, 'X', 10),
CDKparamValue(¶ms, 'Y', 10),
CDKparamValue(¶ms, 'H', 1),
CDKparamValue(¶ms, 'W', -2),
HORIZONTAL, volumeTitle,
Box,
CDKparamValue(¶ms, 'S', FALSE));
if (volume == 0)
{
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message and exit. */
printf ("Oops. Can not make volume histogram. Is the window big enough??\n");
ExitProgram (EXIT_FAILURE);
}
bass = newCDKHistogram (cdkscreen,
CDKparamValue(¶ms, 'X', 10),
CDKparamValue(¶ms, 'Y', 14),
CDKparamValue(¶ms, 'H', 1),
CDKparamValue(¶ms, 'W', -2),
HORIZONTAL, bassTitle,
Box,
CDKparamValue(¶ms, 'S', FALSE));
if (bass == 0)
{
/* Exit CDK. */
destroyCDKHistogram (volume);
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message and exit. */
printf ("Oops. Can not make bass histogram. Is the window big enough??\n");
ExitProgram (EXIT_FAILURE);
}
treble = newCDKHistogram (cdkscreen,
CDKparamValue(¶ms, 'X', 10),
CDKparamValue(¶ms, 'Y', 18),
CDKparamValue(¶ms, 'H', 1),
CDKparamValue(¶ms, 'W', -2),
HORIZONTAL, trebleTitle,
Box,
CDKparamValue(¶ms, 'S', FALSE));
if (treble == 0)
{
/* Exit CDK. */
destroyCDKHistogram (volume);
destroyCDKHistogram (bass);
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message and exit. */
printf ("Oops. Can not make treble histogram. Is the window big enough??\n");
ExitProgram (EXIT_FAILURE);
}
#define BAR(a,b,c) A_BOLD, a, b, c, ' '|A_REVERSE|COLOR_PAIR(3), Box
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 6));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 3));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 7));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 8));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 1));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 9));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 10));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 7));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 10));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 1));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 8));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 3));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 3));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 3));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 3));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 10));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 10));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 10));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Clean up. */
destroyCDKHistogram (volume);
destroyCDKHistogram (bass);
destroyCDKHistogram (treble);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkScreen = 0;
CDKTEMPLATE *widget = 0;
CDKBUTTONBOX *buttonWidget = 0;
WINDOW *cursesWindow = 0;
char *answer = 0;
char *tmp = 0;
char *CDK_WIDGET_COLOR = 0;
char *temp = 0;
chtype *holder = 0;
int buttonCount = 0;
int selection = 0;
int shadowHeight = 0;
FILE *fp = stderr;
char **buttonList = 0;
int j1, j2;
CDK_PARAMS params;
boolean boxWidget;
boolean mixPlate;
boolean shadowWidget;
char *buttons;
char *defaultAnswer;
char *label;
char *my_overlay;
char *outputFile;
char *plate;
char *title;
int minimum;
int xpos;
int ypos;
CDKparseParams (argc, argv, ¶ms, "d:m:o:p:B:L:O:P:T:" CDK_MIN_PARAMS);
/* *INDENT-EQLS* */
xpos = CDKparamValue (¶ms, 'X', CENTER);
ypos = CDKparamValue (¶ms, 'Y', CENTER);
boxWidget = CDKparamValue (¶ms, 'N', TRUE);
shadowWidget = CDKparamValue (¶ms, 'S', FALSE);
minimum = CDKparamValue (¶ms, 'm', 0);
mixPlate = CDKparamValue (¶ms, 'P', FALSE);
defaultAnswer = CDKparamString (¶ms, 'd');
my_overlay = CDKparamString (¶ms, 'o');
plate = CDKparamString (¶ms, 'p');
buttons = CDKparamString (¶ms, 'B');
label = CDKparamString (¶ms, 'L');
outputFile = CDKparamString (¶ms, 'O');
title = CDKparamString (¶ms, 'T');
/* Make sure all the command line parameters were provided. */
if (plate == 0)
{
fprintf (stderr, "Usage: %s %s\n", argv[0], FPUsage);
ExitProgram (CLI_ERROR);
}
/* If the user asked for an output file, try to open it. */
if (outputFile != 0)
{
if ((fp = fopen (outputFile, "w")) == 0)
{
fprintf (stderr, "%s: Can not open output file %s\n", argv[0], outputFile);
ExitProgram (CLI_ERROR);
}
}
/* Set up CDK. */
cursesWindow = initscr ();
cdkScreen = initCDKScreen (cursesWindow);
/* Start color. */
initCDKColor ();
/* Check if the user wants to set the background of the main screen. */
if ((temp = getenv ("CDK_SCREEN_COLOR")) != 0)
{
holder = char2Chtype (temp, &j1, &j2);
wbkgd (cdkScreen->window, holder[0]);
wrefresh (cdkScreen->window);
freeChtype (holder);
}
/* Get the widget color background color. */
if ((CDK_WIDGET_COLOR = getenv ("CDK_WIDGET_COLOR")) == 0)
{
CDK_WIDGET_COLOR = 0;
}
/* Create the template widget. */
widget = newCDKTemplate (cdkScreen, xpos, ypos,
title, label,
plate, my_overlay,
boxWidget, shadowWidget);
/* Check to make sure we created the widget. */
if (widget == 0)
{
/* Shut down curses and CDK. */
destroyCDKScreen (cdkScreen);
endCDK ();
fprintf (stderr,
"Error: Could not create the template field. "
"Is the window too small?\n");
ExitProgram (CLI_ERROR);
}
/* Split the buttons if they supplied some. */
if (buttons != 0)
{
/* Split the button list up. */
buttonList = CDKsplitString (buttons, '\n');
buttonCount = (int)CDKcountStrings ((CDK_CSTRING2) buttonList);
/* We need to create a buttonbox widget. */
buttonWidget = newCDKButtonbox (cdkScreen,
getbegx (widget->win),
(getbegy (widget->win)
+ widget->boxHeight - 1),
1, widget->boxWidth - 1,
0, 1, buttonCount,
(CDK_CSTRING2) buttonList, buttonCount,
A_REVERSE, boxWidget, FALSE);
setCDKButtonboxULChar (buttonWidget, ACS_LTEE);
setCDKButtonboxURChar (buttonWidget, ACS_RTEE);
/*
* We need to set the lower left and right
* characters of the widget.
*/
setCDKTemplateLLChar (widget, ACS_LTEE);
setCDKTemplateLRChar (widget, ACS_RTEE);
/*
* Bind the Tab key in the widget to send a
* Tab key to the button box widget.
*/
bindCDKObject (vTEMPLATE, widget, KEY_TAB, widgetCB, buttonWidget);
bindCDKObject (vTEMPLATE, widget, CDK_NEXT, widgetCB, buttonWidget);
bindCDKObject (vTEMPLATE, widget, CDK_PREV, widgetCB, buttonWidget);
/* Check if the user wants to set the background of the widget. */
setCDKButtonboxBackgroundColor (buttonWidget, CDK_WIDGET_COLOR);
/* Draw the button widget. */
drawCDKButtonbox (buttonWidget, boxWidget);
}
/*
* If the user asked for a shadow, we need to create one. Do this instead
* of using the shadow parameter because the button widget is not part of
* the main widget and if the user asks for both buttons and a shadow, we
* need to create a shadow big enough for both widgets. Create the shadow
* window using the widgets shadowWin element, so screen refreshes will draw
* them as well.
*/
if (shadowWidget == TRUE)
{
/* Determine the height of the shadow window. */
shadowHeight = (buttonWidget == 0 ?
widget->boxHeight :
widget->boxHeight + buttonWidget->boxHeight - 1);
/* Create the shadow window. */
widget->shadowWin = newwin (shadowHeight,
widget->boxWidth,
getbegy (widget->win) + 1,
getbegx (widget->win) + 1);
/* Make sure we could have created the shadow window. */
if (widget->shadowWin != 0)
{
widget->shadow = TRUE;
/*
* We force the widget and buttonWidget to be drawn so the
* buttonbox widget will be drawn when the widget is activated.
* Otherwise the shadow window will draw over the button widget.
*/
drawCDKTemplate (widget, ObjOf (widget)->box);
eraseCDKButtonbox (buttonWidget);
drawCDKButtonbox (buttonWidget, ObjOf (buttonWidget)->box);
}
}
/* Check if the user wants to set the background of the widget. */
setCDKTemplateBackgroundColor (widget, CDK_WIDGET_COLOR);
/* If a default answer were proivded, set it in the widget. */
if (defaultAnswer != 0)
{
setCDKTemplateValue (widget, defaultAnswer);
}
/* If the user asked for a minimum value, set it. */
setCDKTemplateMin (widget, minimum);
/* Activate the widget. */
tmp = activateCDKTemplate (widget, 0);
/* If the user asked for plate mixing, give it to them. */
if (mixPlate == TRUE)
{
answer = mixCDKTemplate (widget);
}
else
{
answer = copyChar (tmp);
}
/* If there were buttons, get the button selected. */
if (buttonWidget != 0)
{
selection = buttonWidget->currentButton;
destroyCDKButtonbox (buttonWidget);
}
/* End CDK. */
destroyCDKTemplate (widget);
destroyCDKScreen (cdkScreen);
endCDK ();
/* Print the value from the widget. */
if (answer != 0)
{
fprintf (fp, "%s\n", answer);
freeChar (answer);
}
fclose (fp);
/* Exit with the button number picked. */
ExitProgram (selection);
}
/*
* This program demonstrates the Cdk itemlist widget.
*
* Options (in addition to minimal CLI parameters):
* -c create the data after the widget
*/
int main(int argc, char **argv)
{
/* Declare local variables. */
CDKSCREEN *cdkscreen = 0;
CDKITEMLIST *monthlist = 0;
WINDOW *cursesWin = 0;
char *title = "<C>Pick A Month";
char *label = "</U/5>Month:";
char *info[MONTHS], temp[256], *mesg[10];
int choice, startMonth;
struct tm *dateInfo;
time_t clck;
CDK_PARAMS params;
CDKparseParams(argc, argv, ¶ms, "c" CDK_MIN_PARAMS);
/*
* Get the current date and set the default month to the
* current month.
*/
time (&clck);
dateInfo = localtime (&clck);
startMonth = dateInfo->tm_mon;
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK colors. */
initCDKColor();
/* Create the choice list. */
info[0] = "<C></5>January";
info[1] = "<C></5>February";
info[2] = "<C></B/19>March";
info[3] = "<C></5>April";
info[4] = "<C></5>May";
info[5] = "<C></K/5>June";
info[6] = "<C></12>July";
info[7] = "<C></5>August";
info[8] = "<C></5>September";
info[9] = "<C></32>October";
info[10] = "<C></5>November";
info[11] = "<C></11>December";
/* Create the itemlist widget. */
monthlist = newCDKItemlist (cdkscreen,
CDKparamValue(¶ms, 'X', CENTER),
CDKparamValue(¶ms, 'Y', CENTER),
title,
label,
CDKparamNumber(¶ms, 'c') ? 0 : info,
CDKparamNumber(¶ms, 'c') ? 0 : MONTHS,
startMonth,
CDKparamValue(¶ms, 'N', TRUE),
CDKparamValue(¶ms, 'S', FALSE));
/* Is the widget null? */
if (monthlist == 0)
{
/* Clean up. */
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a little message. */
printf ("Oops. Can't seem to create the itemlist box. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
if (CDKparamNumber(¶ms, 'c'))
{
setCDKItemlistValues (monthlist, info, MONTHS, 0);
}
/* Activate the widget. */
choice = activateCDKItemlist (monthlist, 0);
/* Check how they exited from the widget. */
if (monthlist->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape. No item selected.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (ScreenOf(monthlist), mesg, 3);
}
else if (monthlist->exitType == vNORMAL)
{
sprintf (temp, "<C>You selected the %dth item which is", choice);
mesg[0] = copyChar (temp);
mesg[1] = info[choice];
mesg[2] = "";
mesg[3] = "<C>Press any key to continue.";
popupLabel (ScreenOf(monthlist), mesg, 4);
freeChar (mesg[0]);
}
/* Clean up. */
destroyCDKItemlist (monthlist);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
/*
* This program demonstrates the Cdk radio widget.
*
* Options (in addition to normal CLI parameters):
* -c create the data after the widget
* -s SPOS location for the scrollbar
* -t TEXT title for the widget
*
*/
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKRADIO *radio = 0;
WINDOW *cursesWin = 0;
const char *title = "<C></5>Select a filename";
char **item = 0;
const char *mesg[5];
char temp[256];
int selection, count;
CDK_PARAMS params;
CDKparseParams (argc, argv, ¶ms, "cs:t:" CDK_CLI_PARAMS);
/* Use the current diretory list to fill the radio list. */
count = CDKgetDirectoryContents (".", &item);
if (count <= 0)
{
fprintf (stderr, "Cannot get directory list\n");
ExitProgram (EXIT_FAILURE);
}
/* Set up CDK. */
cursesWin = initscr ();
cdkscreen = initCDKScreen (cursesWin);
/* Set up CDK Colors. */
initCDKColor ();
/* Create the radio list. */
radio = newCDKRadio (cdkscreen,
CDKparamValue (¶ms, 'X', CENTER),
CDKparamValue (¶ms, 'Y', CENTER),
CDKparsePosition (CDKparamString2 (¶ms,
's',
"RIGHT")),
CDKparamValue (¶ms, 'H', 10),
CDKparamValue (¶ms, 'W', 40),
CDKparamString2 (¶ms, 't', title),
CDKparamNumber (¶ms, 'c') ? 0 : (CDK_CSTRING2) item,
CDKparamNumber (¶ms, 'c') ? 0 : count,
'#' | A_REVERSE, 1,
A_REVERSE,
CDKparamValue (¶ms, 'N', TRUE),
CDKparamValue (¶ms, 'S', FALSE));
/* Check if the radio list is null. */
if (radio == 0)
{
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK ();
printf ("Cannot create the radio widget. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
if (CDKparamNumber (¶ms, 'c'))
{
setCDKRadioItems (radio, (CDK_CSTRING2) item, count);
}
/* loop until user selects a file, or cancels */
for (;;)
{
/* Activate the radio list. */
selection = activateCDKRadio (radio, 0);
/* Check the exit status of the widget. */
if (radio->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape. No item selected.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
break;
}
else if (radio->exitType == vNORMAL)
{
struct stat sb;
if (stat (item[selection], &sb) == 0
&& (sb.st_mode & S_IFMT) == S_IFDIR)
{
char **nitem = 0;
mesg[0] = "<C>You selected a directory";
sprintf (temp, "<C>%.*s", (int)(sizeof (temp) - 20), item[selection]);
mesg[1] = temp;
mesg[2] = "";
mesg[3] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 4);
count = CDKgetDirectoryContents (item[selection], &nitem);
if (count > 0)
{
CDKfreeStrings (item);
item = nitem;
if (chdir (item[selection]) == 0)
setCDKRadioItems (radio, (CDK_CSTRING2) item, count);
}
}
else
{
mesg[0] = "<C>You selected the filename";
sprintf (temp, "<C>%.*s", (int)(sizeof (temp) - 20), item[selection]);
mesg[1] = temp;
mesg[2] = "";
mesg[3] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 4);
break;
}
}
}
/* Clean up. */
CDKfreeStrings (item);
destroyCDKRadio (radio);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKVIEWER *example = 0;
CDKFSELECT *fSelect = 0;
WINDOW *cursesWin = 0;
const char *title = "<C>Pick\n<C>A\n<C>File";
const char *label = "File: ";
char **info = 0;
const char *button[5];
const char *mesg[4];
char *filename;
char vTitle[256];
char temp[256];
int selected, lines;
CDK_PARAMS params;
char *directory;
CDKparseParams (argc, argv, ¶ms, "d:" CDK_CLI_PARAMS);
directory = CDKparamString2 (¶ms, 'd', ".");
/* Create the viewer buttons. */
button[0] = "</5><OK><!5>";
button[1] = "</5><Cancel><!5>";
/* Set up CDK. */
cursesWin = initscr ();
cdkscreen = initCDKScreen (cursesWin);
/* Start color. */
initCDKColor ();
/* Get the filename. */
fSelect = newCDKFselect (cdkscreen,
CDKparamValue (¶ms, 'X', CENTER),
CDKparamValue (¶ms, 'Y', CENTER),
CDKparamValue (¶ms, 'H', 20),
CDKparamValue (¶ms, 'W', 65),
title, label, A_NORMAL, '_', A_REVERSE,
"</5>", "</48>", "</N>", "</N>",
CDKparamValue (¶ms, 'N', TRUE),
CDKparamValue (¶ms, 'S', FALSE));
if (fSelect == 0)
{
destroyCDKScreen (cdkscreen);
endCDK ();
fprintf (stderr, "Cannot create widget\n");
ExitProgram (EXIT_FAILURE);
}
bindCDKObject (vFSELECT, fSelect, '?', do_help, NULL);
bindCDKObject (vFSELECT, fSelect, KEY_F1, do_help, NULL);
bindCDKObject (vFSELECT, fSelect, KEY_F2, do_delete, fSelect);
bindCDKObject (vFSELECT, fSelect, KEY_F3, do_delete1, fSelect);
bindCDKObject (vFSELECT, fSelect, KEY_F4, do_reload, fSelect);
bindCDKObject (vFSELECT, fSelect, KEY_F5, do_undo, fSelect);
/*
* Set the starting directory. This is not necessary because when
* the file selector starts it uses the present directory as a default.
*/
setCDKFselect (fSelect, directory, A_NORMAL, ' ', A_REVERSE,
"</5>", "</48>", "</N>", "</N>", ObjOf (fSelect)->box);
myUserList = copyCharList ((const char **)getCDKFselectContents (fSelect, &userSize));
myUndoList = (UNDO *) malloc ((size_t) userSize * sizeof (UNDO));
undoSize = 0;
/* Activate the file selector. */
filename = activateCDKFselect (fSelect, 0);
/* Check how the person exited from the widget. */
if (fSelect->exitType == vESCAPE_HIT)
{
/* Pop up a message for the user. */
mesg[0] = "<C>Escape hit. No file selected.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2)mesg, 3);
/* Exit CDK. */
destroyCDKFselect (fSelect);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
/* Create the file viewer to view the file selected. */
example = newCDKViewer (cdkscreen, CENTER, CENTER, 20, -2,
(CDK_CSTRING2)button, 2, A_REVERSE, TRUE, FALSE);
/* Could we create the viewer widget? */
if (example == 0)
{
/* Exit CDK. */
destroyCDKFselect (fSelect);
destroyCDKScreen (cdkscreen);
endCDK ();
printf ("Can't seem to create viewer. Is the window too small?\n");
ExitProgram (EXIT_SUCCESS);
}
/* Open the file and read the contents. */
lines = CDKreadFile (filename, &info);
if (lines == -1)
{
filename = copyChar (filename);
destroyCDKFselect (fSelect);
destroyCDKScreen (cdkscreen);
endCDK ();
printf ("Could not open \"%s\"\n", filename);
ExitProgram (EXIT_FAILURE);
}
/* Set up the viewer title, and the contents to the widget. */
sprintf (vTitle, "<C></B/21>Filename:<!21></22>%20s<!22!B>", filename);
setCDKViewer (example, vTitle,
(CDK_CSTRING2)info, lines,
A_REVERSE, TRUE, TRUE, TRUE);
CDKfreeStrings (info);
/* Destroy the file selector widget. */
destroyCDKFselect (fSelect);
/* Activate the viewer widget. */
selected = activateCDKViewer (example, 0);
/* Check how the person exited from the widget. */
if (example->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>Escape hit. No Button selected.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2)mesg, 3);
}
else if (example->exitType == vNORMAL)
{
sprintf (temp, "<C>You selected button %d", selected);
mesg[0] = temp;
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2)mesg, 3);
}
/* Clean up. */
destroyCDKViewer (example);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKMENTRY *widget = 0;
char *info = 0;
const char *label = "</R>Message";
const char *title =
"<C></5>Enter a message (\".\" to exit).<!5>\n"
"<C>It can be </3>multi<!3>-line!";
int boxWidth;
CDK_PARAMS params;
CDKparseParams (argc, argv, ¶ms, "w:h:l:" CDK_MIN_PARAMS);
cdkscreen = initCDKScreen (NULL);
/* Start CDK Colors. */
initCDKColor ();
/* Set up the multi-line entry field. */
boxWidth = CDKparamValue (¶ms, 'w', 40);
widget = newCDKMentry (cdkscreen,
CDKparamValue (¶ms, 'X', CENTER),
CDKparamValue (¶ms, 'Y', CENTER),
title, label, A_BOLD, '.', vMIXED,
boxWidth,
CDKparamValue (¶ms, 'h', 5),
CDKparamValue (¶ms, 'l', 20),
0,
CDKparamValue (¶ms, 'N', TRUE),
CDKparamValue (¶ms, 'S', FALSE));
/* Is the object null? */
if (widget == 0)
{
/* Shut down CDK. */
destroyCDKScreen (cdkscreen);
endCDK ();
printf ("Cannot create CDK object. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
refreshCDKScreen (cdkscreen);
for (;;)
{
info = getCdkTitle (ObjOf (widget));
setCDKMentry (widget, info, 0, TRUE);
free (info);
activateCDKMentry (widget, 0);
if (strlen (widget->info) > 1)
{
setCdkTitle (ObjOf (widget), widget->info, getmaxx (widget->win));
eraseCDKScreen (ScreenOf (widget));
drawCDKScreen (ScreenOf (widget));
}
else
{
break;
}
}
destroyCDKMentry (widget);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkScreen = 0;
CDKSLIDER *widget = 0;
CDKBUTTONBOX *buttonWidget = 0;
WINDOW *cursesWindow = 0;
char *CDK_WIDGET_COLOR = 0;
char *temp = 0;
chtype *holder = 0;
chtype fieldAttr = A_REVERSE | ' ';
int answer = 0;
int buttonCount = 0;
int selection = 0;
int shadowHeight = 0;
FILE *fp = stderr;
char **buttonList = 0;
int j1, j2, tmp;
CDK_PARAMS params;
boolean boxWidget;
boolean shadowWidget;
char *barAttribute;
char *buttons;
char *label;
char *outputFile;
char *title;
int fieldWidth;
int incrementStep;
int acceleratedStep;
int initValue;
int lowValue;
int highValue;
int xpos;
int ypos;
CDKparseParams (argc, argv, ¶ms, "a:f:h:i:l:s:B:F:L:O:T:" CDK_MIN_PARAMS);
/* *INDENT-EQLS* */
xpos = CDKparamValue (¶ms, 'X', CENTER);
ypos = CDKparamValue (¶ms, 'Y', CENTER);
boxWidget = CDKparamValue (¶ms, 'N', TRUE);
shadowWidget = CDKparamValue (¶ms, 'S', FALSE);
acceleratedStep = CDKparamValue (¶ms, 'a', -1);
fieldWidth = CDKparamValue (¶ms, 'f', 0);
highValue = CDKparamValue (¶ms, 'h', INT_MIN);
incrementStep = CDKparamValue (¶ms, 'i', 1);
lowValue = CDKparamValue (¶ms, 'l', INT_MAX);
initValue = CDKparamValue (¶ms, 's', INT_MIN);
buttons = CDKparamString (¶ms, 'B');
barAttribute = CDKparamString (¶ms, 'F');
label = CDKparamString (¶ms, 'L');
outputFile = CDKparamString (¶ms, 'O');
title = CDKparamString (¶ms, 'T');
incrementStep = abs (incrementStep);
/* Make sure all the command line parameters were provided. */
if (fieldWidth <= 0)
{
fprintf (stderr, "Usage: %s %s\n", argv[0], FPUsage);
ExitProgram (CLI_ERROR);
}
/* Make sure the user supplied the low/high values. */
if ((lowValue == INT_MAX) || (highValue == INT_MIN))
{
fprintf (stderr, "Usage: %s %s\n", argv[0], FPUsage);
ExitProgram (CLI_ERROR);
}
/* If the user asked for an output file, try to open it. */
if (outputFile != 0)
{
if ((fp = fopen (outputFile, "w")) == 0)
{
fprintf (stderr, "%s: Can not open output file %s\n", argv[0], outputFile);
ExitProgram (CLI_ERROR);
}
}
/* Make sure the low is lower than the high (and vice versa). */
if (lowValue > highValue)
{
tmp = lowValue;
lowValue = highValue;
highValue = tmp;
}
/* Make sure the starting value is in range. */
if (initValue < lowValue)
{
initValue = lowValue;
}
else if (initValue > highValue)
{
initValue = highValue;
}
/* Check if the accelerated incremnt value was set. */
if (acceleratedStep <= 0)
{
acceleratedStep = (int)((highValue - lowValue) / 10);
acceleratedStep = MAXIMUM (1, acceleratedStep);
}
/* Set up CDK. */
cursesWindow = initscr ();
cdkScreen = initCDKScreen (cursesWindow);
/* Start color. */
initCDKColor ();
/* Check if the user wants to set the background of the main screen. */
if ((temp = getenv ("CDK_SCREEN_COLOR")) != 0)
{
holder = char2Chtype (temp, &j1, &j2);
wbkgd (cdkScreen->window, holder[0]);
wrefresh (cdkScreen->window);
freeChtype (holder);
}
/* Get the widget color background color. */
if ((CDK_WIDGET_COLOR = getenv ("CDK_WIDGET_COLOR")) == 0)
{
CDK_WIDGET_COLOR = 0;
}
/* Did the user ask to change the bar attribute? */
if (barAttribute != 0)
{
holder = char2Chtype (barAttribute, &j1, &j2);
fieldAttr = holder[0];
freeChtype (holder);
}
/* Create the entry widget. */
widget = newCDKSlider (cdkScreen, xpos, ypos,
title, label,
fieldAttr, fieldWidth,
initValue, lowValue, highValue,
incrementStep, acceleratedStep,
boxWidget, shadowWidget);
/* Check to make sure we created the dialog box. */
if (widget == 0)
{
/* Shut down curses and CDK. */
destroyCDKScreen (cdkScreen);
endCDK ();
fprintf (stderr,
"Error: Could not create the numeric slider field. "
"Is the window too small?\n");
ExitProgram (CLI_ERROR);
}
/* Split the buttons if they supplied some. */
if (buttons != 0)
{
/* Split the button list up. */
buttonList = CDKsplitString (buttons, '\n');
buttonCount = (int)CDKcountStrings ((CDK_CSTRING2) buttonList);
/* We need to create a buttonbox widget. */
buttonWidget = newCDKButtonbox (cdkScreen,
getbegx (widget->win),
(getbegy (widget->win)
+ widget->boxHeight - 1),
1, widget->boxWidth - 1,
0, 1, buttonCount,
(CDK_CSTRING2) buttonList, buttonCount,
A_REVERSE, boxWidget, FALSE);
CDKfreeStrings (buttonList);
setCDKButtonboxULChar (buttonWidget, ACS_LTEE);
setCDKButtonboxURChar (buttonWidget, ACS_RTEE);
/*
* We need to set the lower left and right
* characters of the widget.
*/
setCDKSliderLLChar (widget, ACS_LTEE);
setCDKSliderLRChar (widget, ACS_RTEE);
/*
* Bind the Tab key in the widget to send a
* Tab key to the button box widget.
*/
bindCDKObject (vSLIDER, widget, KEY_TAB, widgetCB, buttonWidget);
bindCDKObject (vSLIDER, widget, CDK_NEXT, widgetCB, buttonWidget);
bindCDKObject (vSLIDER, widget, CDK_PREV, widgetCB, buttonWidget);
/* Check if the user wants to set the background of the widget. */
setCDKButtonboxBackgroundColor (buttonWidget, CDK_WIDGET_COLOR);
/* Draw the button widget. */
drawCDKButtonbox (buttonWidget, boxWidget);
}
/*
* If the user asked for a shadow, we need to create one. Do this instead
* of using the shadow parameter because the button widget is not part of
* the main widget and if the user asks for both buttons and a shadow, we
* need to create a shadow big enough for both widgets. Create the shadow
* window using the widgets shadowWin element, so screen refreshes will draw
* them as well.
*/
if (shadowWidget == TRUE)
{
/* Determine the height of the shadow window. */
shadowHeight = (buttonWidget == 0 ?
widget->boxHeight :
widget->boxHeight + buttonWidget->boxHeight - 1);
/* Create the shadow window. */
widget->shadowWin = newwin (shadowHeight,
widget->boxWidth,
getbegy (widget->win) + 1,
getbegx (widget->win) + 1);
/* Make sure we could have created the shadow window. */
if (widget->shadowWin != 0)
{
widget->shadow = TRUE;
/*
* We force the widget and buttonWidget to be drawn so the
* buttonbox widget will be drawn when the widget is activated.
* Otherwise the shadow window will draw over the button widget.
*/
drawCDKSlider (widget, ObjOf (widget)->box);
eraseCDKButtonbox (buttonWidget);
drawCDKButtonbox (buttonWidget, ObjOf (buttonWidget)->box);
}
}
/* Check if the user wants to set the background of the widget. */
setCDKSliderBackgroundColor (widget, CDK_WIDGET_COLOR);
/* Activate the widget. */
answer = activateCDKSlider (widget, 0);
/* If there were buttons, get the button selected. */
if (buttonWidget != 0)
{
selection = buttonWidget->currentButton;
destroyCDKButtonbox (buttonWidget);
}
/* End CDK. */
destroyCDKSlider (widget);
destroyCDKScreen (cdkScreen);
endCDK ();
/* Print the value from the widget. */
fprintf (fp, "%d\n", answer);
fclose (fp);
/* Exit with the button selected. */
ExitProgram (selection);
}
/*
* This program demonstrates the Cdk calendar widget.
*/
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKCALENDAR *calendar = 0;
const char *mesg[5];
char temp[256];
struct tm *dateInfo;
time_t clck, retVal;
CDK_PARAMS params;
char *title;
int day;
int month;
int year;
/*
* Get the current dates and set the default values for
* the day/month/year values for the calendar.
*/
time (&clck);
dateInfo = gmtime (&clck);
/* *INDENT-EQLS* */
CDKparseParams (argc, argv, ¶ms, "d:m:y:t:w:" CDK_MIN_PARAMS);
day = CDKparamNumber2 (¶ms, 'd', dateInfo->tm_mday);
month = CDKparamNumber2 (¶ms, 'm', dateInfo->tm_mon + 1);
year = CDKparamNumber2 (¶ms, 'y', dateInfo->tm_year + 1900);
title = CDKparamString2 (¶ms, 't', "<C></U>CDK Calendar Widget\n<C>Demo");
cdkscreen = initCDKScreen (NULL);
/* Start CDK Colors. */
initCDKColor ();
/* Create the calendar widget. */
calendar = newCDKCalendar (cdkscreen,
CDKparamValue (¶ms, 'X', CENTER),
CDKparamValue (¶ms, 'Y', CENTER),
title, day, month, year,
COLOR_PAIR (16) | A_BOLD,
COLOR_PAIR (24) | A_BOLD,
COLOR_PAIR (32) | A_BOLD,
COLOR_PAIR (40) | A_REVERSE,
CDKparamValue (¶ms, 'N', TRUE),
CDKparamValue (¶ms, 'S', FALSE));
/* Is the widget null? */
if (calendar == 0)
{
/* Clean up the memory. */
destroyCDKScreen (cdkscreen);
/* End curses... */
endCDK ();
printf ("Cannot create the calendar. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
/* Create a key binding to mark days on the calendar. */
bindCDKObject (vCALENDAR, calendar, 'm', createCalendarMarkCB, calendar);
bindCDKObject (vCALENDAR, calendar, 'M', createCalendarMarkCB, calendar);
bindCDKObject (vCALENDAR, calendar, 'r', removeCalendarMarkCB, calendar);
bindCDKObject (vCALENDAR, calendar, 'R', removeCalendarMarkCB, calendar);
calendar->weekBase = CDKparamNumber (¶ms, 'w');
/* Draw the calendar widget. */
drawCDKCalendar (calendar, ObjOf (calendar)->box);
/* Let the user play with the widget. */
retVal = activateCDKCalendar (calendar, 0);
/* Check which day they selected. */
if (calendar->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape. No date selected.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
}
else if (calendar->exitType == vNORMAL)
{
mesg[0] = "You selected the following date";
sprintf (temp, "<C></B/16>%02d/%02d/%d (dd/mm/yyyy)",
calendar->day,
calendar->month,
calendar->year);
mesg[1] = temp;
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
}
/* Clean up and exit. */
destroyCDKCalendar (calendar);
destroyCDKScreen (cdkscreen);
endCDK ();
fflush (stdout);
printf ("Selected Time: %s\n", ctime (&retVal));
ExitProgram (EXIT_SUCCESS);
}
/*
* This program demonstrates the Cdk buttonbox widget.
*/
int main (void)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKBUTTONBOX *buttonWidget = 0;
CDKENTRY *entry = 0;
WINDOW *cursesWin = 0;
const char *buttons[] =
{
" OK ",
" Cancel "
};
char *info = 0;
int selection;
/* Set up CDK. */
cursesWin = initscr ();
cdkscreen = initCDKScreen (cursesWin);
/* Start color. */
initCDKColor ();
/* Create the entry widget. */
entry = newCDKEntry (cdkscreen, CENTER, CENTER,
"<C>Enter a name", "Name ", A_NORMAL, '.', vMIXED,
40, 0, 256, TRUE, FALSE);
if (entry == 0)
{
destroyCDKScreen (cdkscreen);
endCDK ();
fprintf (stderr, "Cannot create entry-widget\n");
ExitProgram (EXIT_FAILURE);
}
/* Create the button box widget. */
buttonWidget = newCDKButtonbox (cdkscreen,
getbegx (entry->win),
getbegy (entry->win) + entry->boxHeight - 1,
1, entry->boxWidth - 1,
0, 1, 2,
(CDK_CSTRING2) buttons, 2, A_REVERSE,
TRUE, FALSE);
if (buttonWidget == 0)
{
destroyCDKScreen (cdkscreen);
endCDK ();
fprintf (stderr, "Cannot create buttonbox-widget\n");
ExitProgram (EXIT_FAILURE);
}
/* Set the lower left and right characters of the box. */
setCDKEntryLLChar (entry, ACS_LTEE);
setCDKEntryLRChar (entry, ACS_RTEE);
setCDKButtonboxULChar (buttonWidget, ACS_LTEE);
setCDKButtonboxURChar (buttonWidget, ACS_RTEE);
/*
* Bind the Tab key in the entry field to send a
* Tab key to the button box widget.
*/
bindCDKObject (vENTRY, entry, KEY_TAB, entryCB, buttonWidget);
/* Activate the entry field. */
drawCDKButtonbox (buttonWidget, TRUE);
info = copyChar (activateCDKEntry (entry, 0));
selection = buttonWidget->currentButton;
/* Clean up. */
destroyCDKButtonbox (buttonWidget);
destroyCDKEntry (entry);
destroyCDKScreen (cdkscreen);
endCDK ();
printf ("You typed in (%s) and selected button (%s)\n",
(info != 0) ? info : "<null>",
buttons[selection]);
freeChar (info);
ExitProgram (EXIT_SUCCESS);
}
int main (void)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKLABEL *stopSign = 0;
CDKLABEL *title = 0;
const char *mesg[5];
const char *sign[4];
chtype key;
boolean functionKey;
cdkscreen = initCDKScreen (NULL);
/* Start CDK Colors. */
initCDKColor ();
/* Set the labels up. */
mesg[0] = "<C><#HL(40)>";
mesg[1] = "<C>Press </B/16>r<!B!16> for the </B/16>red light";
mesg[2] = "<C>Press </B/32>y<!B!32> for the </B/32>yellow light";
mesg[3] = "<C>Press </B/24>g<!B!24> for the </B/24>green light";
mesg[4] = "<C><#HL(40)>";
sign[0] = " <#DI> ";
sign[1] = " <#DI> ";
sign[2] = " <#DI> ";
/* Declare the labels. */
title = newCDKLabel (cdkscreen, CENTER, TOP,
(CDK_CSTRING2) mesg, 5,
FALSE, FALSE);
stopSign = newCDKLabel (cdkscreen, CENTER, CENTER,
(CDK_CSTRING2) sign, 3,
TRUE, TRUE);
/* Do this until they hit q or escape. */
for (;;)
{
drawCDKLabel (title, FALSE);
drawCDKLabel (stopSign, TRUE);
key = (chtype)getchCDKObject (ObjOf (stopSign), &functionKey);
if (key == KEY_ESC || key == 'q' || key == 'Q')
{
break;
}
else if (key == 'r' || key == 'R')
{
sign[0] = " </B/16><#DI> ";
sign[1] = " o ";
sign[2] = " o ";
}
else if (key == 'y' || key == 'Y')
{
sign[0] = " o ";
sign[1] = " </B/32><#DI> ";
sign[2] = " o ";
}
else if (key == 'g' || key == 'G')
{
sign[0] = " o ";
sign[1] = " o ";
sign[2] = " </B/24><#DI> ";
}
/* Set the contents of the label and re-draw it. */
setCDKLabel (stopSign, (CDK_CSTRING2) sign, 3, TRUE);
}
/* Clean up. */
destroyCDKLabel (title);
destroyCDKLabel (stopSign);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
/*
* This program demonstrates the Cdk slider widget.
*/
int main (int argc, char **argv)
{
/* Declare variables. */
CDKSCREEN *cdkscreen = 0;
CDKFSLIDER *widget = 0;
WINDOW *cursesWin = 0;
char *title = "<C></U>Enter a value:";
char *label = "</B>Current Value:";
char temp[256], *mesg[5];
float selection;
CDK_PARAMS params;
float high;
float inc;
float low;
float scale;
int n, digits;
CDKparseParams(argc, argv, ¶ms, "h:i:l:w:p:" CDK_MIN_PARAMS);
digits = CDKparamNumber2(¶ms, 'p', 0);
scale = 1.0;
for (n = 0; n < digits; ++n) {
scale = scale * 10.0;
}
high = CDKparamNumber2(¶ms, 'h', 100) / scale;
inc = CDKparamNumber2(¶ms, 'i', 1) / scale;
low = CDKparamNumber2(¶ms, 'l', 1) / scale;
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Colors. */
initCDKColor();
/* Create the widget. */
widget = newCDKFSlider (cdkscreen,
CDKparamValue(¶ms, 'X', CENTER),
CDKparamValue(¶ms, 'Y', CENTER),
title, label,
A_REVERSE | COLOR_PAIR (29) | ' ',
CDKparamNumber2(¶ms, 'w', 50),
low, low, high,
inc, (inc*2),
digits,
CDKparamValue(¶ms, 'N', TRUE),
CDKparamValue(¶ms, 'S', FALSE));
/* Is the widget null? */
if (widget == 0)
{
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message. */
printf ("Oops. Can't make the widget. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
/* Activate the widget. */
selection = activateCDKFSlider (widget, 0);
/* Check the exit value of the widget. */
if (widget->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape. No value selected.";
mesg[1] = "",
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, mesg, 3);
}
else if (widget->exitType == vNORMAL)
{
sprintf (temp, "<C>You selected %.*f", digits, selection);
mesg[0] = copyChar (temp);
mesg[1] = "",
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, mesg, 3);
freeChar (mesg[0]);
}
/* Clean up.*/
destroyCDKFSlider (widget);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
int main (int argc, char **argv)
{
/* Declare variables. */
CDKSCREEN *cdkScreen = 0;
CDKVIEWER *widget = 0;
WINDOW *cursesWindow = 0;
char *filename = 0;
char *CDK_WIDGET_COLOR = 0;
char *temp = 0;
chtype *holder = 0;
int answer = 0;
int messageLines = -1;
int buttonCount = 0;
char **messageList = 0;
char **buttonList = 0;
char tempTitle[256];
int j1, j2;
CDK_PARAMS params;
boolean boxWidget;
boolean interpret;
boolean shadowWidget;
boolean showInfoLine;
char *buttons;
char *title;
int height;
int width;
int xpos;
int ypos;
CDKparseParams(argc, argv, ¶ms, "f:il:B:T:" CDK_CLI_PARAMS);
xpos = CDKparamValue(¶ms, 'X', CENTER);
ypos = CDKparamValue(¶ms, 'Y', CENTER);
height = CDKparamValue(¶ms, 'H', 20);
width = CDKparamValue(¶ms, 'W', 60);
boxWidget = CDKparamValue(¶ms, 'N', TRUE);
shadowWidget = CDKparamValue(¶ms, 'S', FALSE);
interpret = CDKparamValue(¶ms, 'i', FALSE);
showInfoLine = CDKparamValue(¶ms, 'l', FALSE);
filename = CDKparamString(¶ms, 'f');
buttons = CDKparamString(¶ms, 'B');
title = CDKparamString(¶ms, 'T');
/* Make sure they gave us a file to read. */
if (filename == 0)
{
fprintf (stderr, "Usage: %s %s\n", argv[0], FPUsage);
ExitProgram (CLI_ERROR);
}
/* Read the file in. */
messageLines = CDKreadFile (filename, &messageList);
/* Check if there was an error. */
if (messageLines == -1)
{
fprintf (stderr, "Error: Could not open the file %s\n", filename);
ExitProgram (CLI_ERROR);
}
/* Set up the buttons of the viewer. */
if (buttons == 0)
{
buttonList[0] = copyChar ("OK");
buttonList[1] = copyChar ("Cancel");
buttonCount = 2;
}
else
{
/* Split the button list up. */
buttonList = CDKsplitString (buttons, '\n');
buttonCount = CDKcountStrings (buttonList);
}
/* Set up the title of the viewer. */
if (title == 0)
{
sprintf (tempTitle, "<C>Filename: </U>%s<!U>", filename);
title = copyChar (tempTitle);
}
/* Set up CDK. */
cursesWindow = initscr();
cdkScreen = initCDKScreen (cursesWindow);
/* Start color. */
initCDKColor();
/* Check if the user wants to set the background of the main screen. */
if ((temp = getenv ("CDK_SCREEN_COLOR")) != 0)
{
holder = char2Chtype (temp, &j1, &j2);
wbkgd (cdkScreen->window, holder[0]);
wrefresh (cdkScreen->window);
freeChtype (holder);
}
/* Get the widget color background color. */
if ((CDK_WIDGET_COLOR = getenv ("CDK_WIDGET_COLOR")) == 0)
{
CDK_WIDGET_COLOR = 0;
}
/* Create the viewer widget. */
widget = newCDKViewer (cdkScreen, xpos, ypos, height, width,
buttonList, buttonCount, A_REVERSE,
boxWidget, shadowWidget);
/* Check to make sure we created the file viewer. */
if (widget == 0)
{
CDKfreeStrings (messageList);
CDKfreeStrings (buttonList);
/* Shut down curses and CDK. */
destroyCDKScreen (cdkScreen);
endCDK();
fprintf (stderr, "Error: Could not create the file viewer. Is the window too small?\n");
ExitProgram (CLI_ERROR);
}
/* Check if the user wants to set the background of the widget. */
setCDKViewerBackgroundColor (widget, CDK_WIDGET_COLOR);
/* Set a binding for saving the info. */
bindCDKObject (vVIEWER, widget, 'S', widgetCB, 0);
/* Set the information needed for the viewer. */
setCDKViewer (widget, title, messageList, messageLines,
A_REVERSE, interpret, showInfoLine, TRUE);
/* Activate the viewer. */
answer = activateCDKViewer (widget, 0);
CDKfreeStrings (messageList);
CDKfreeStrings (buttonList);
destroyCDKViewer (widget);
destroyCDKScreen (cdkScreen);
endCDK();
/* Exit with the button number picked. */
ExitProgram (answer);
}
/*
* This program demonstrates the Cdk scale widget.
*/
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKFSCALE *scale = 0;
const char *title = "<C>Select a value";
const char *label = "</5>Current value";
char temp[256];
const char *mesg[5];
float selection;
CDK_PARAMS params;
float high;
float inc;
float low;
/* *INDENT-EQLS* */
CDKparseParams (argc, argv, ¶ms, "h:i:l:w:" CDK_MIN_PARAMS);
high = myFloatParam (¶ms, 'h', 2.4);
inc = myFloatParam (¶ms, 'i', 0.2);
low = myFloatParam (¶ms, 'l', -1.2);
cdkscreen = initCDKScreen (NULL);
/* Start CDK Colors. */
initCDKColor ();
/* Create the scale. */
scale = newCDKFScale (cdkscreen,
CDKparamValue (¶ms, 'X', CENTER),
CDKparamValue (¶ms, 'Y', CENTER),
title, label, A_NORMAL,
CDKparamNumber2 (¶ms, 'w', 10),
low, low, high,
inc, (inc * (float)2.), 1,
CDKparamValue (¶ms, 'N', TRUE),
CDKparamValue (¶ms, 'S', FALSE));
/* Is the scale null? */
if (scale == 0)
{
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK ();
printf ("Can't make the scale widget. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
/* Activate the scale. */
selection = activateCDKFScale (scale, 0);
/* Check the exit value of the scale widget. */
if (scale->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape. No value selected.";
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
}
else if (scale->exitType == vNORMAL)
{
sprintf (temp, "<C>You selected %f", selection);
mesg[0] = temp;
mesg[1] = "";
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, (CDK_CSTRING2) mesg, 3);
}
/* Clean up. */
destroyCDKFScale (scale);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
/*
* This program demonstrates the Cdk matrix widget.
*/
int main (int argc, char **argv)
{
/* Declare local variables. */
CDKSCREEN *cdkscreen = 0;
CDKMATRIX *form_prov = 0;
WINDOW *cursesWin = 0;
char *title = 0;
int rows = 5;
int cols = 1;
int vrows = 5;
int vcols = 1;
char *coltitle[10], *rowtitle[10], *mesg[10];
int colwidth[10], colvalue[10];
// CDK_PARAMS params;
// CDKparseParams (argc, argv, ¶ms, CDK_MIN_PARAMS);
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Colors. */
initCDKColor();
/* Create the horizontal and vertical matrix labels. */
#define set_col(n, width, string) \
coltitle[n] = string; colwidth[n] = width ; colvalue[n] = vUMIXED
set_col(1, 7, "</B/5>Proveedor");
set_col(2, 7, "</B/33>Lec 1");
set_col(3, 7, "</B/33>Lec 2");
set_col(4, 7, "</B/33>Lec 3");
set_col(5, 1, "</B/7>Flag");
#define set_row(n, string) \
rowtitle[n] = "</B/8>" string
set_row(1, "ID");
set_row(2, "Nombre");
set_row(3, "Apellido");
set_row(4, "Correo");
set_row(5, "Direccion");
set_row(6, "Course 6");
set_row(7, "Course 7");
set_row(8, "Course 8");
/* Create the title. */
/* Create the matrix object. */
form_prov = newCDKMatrix (cdkscreen,
CENTER,
CENTER,
rows, cols, vrows, vcols,
title, rowtitle, coltitle,
colwidth, colvalue,
-1, -1, '.',
COL, TRUE,
TRUE,
FALSE);
/* Check to see if the matrix is null. */
if (form_prov == 0)
{
/* Clean up. */
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a little message. */
printf ("Oops. Can't seem to create the matrix widget. Is the window too small ?\n");
exit (EXIT_FAILURE);
}
/* Activate the matrix. */
activateCDKMatrix (form_prov, 0);
/* Check if the user hit escape or not. */
if (form_prov->exitType == vESCAPE_HIT)
{
mesg[0] = "<C>You hit escape. No information passed back.";
mesg[1] = "",
mesg[2] = "<C>Press any key to continue.";
popupLabel (cdkscreen, mesg, 3);
}
else if (form_prov->exitType == vNORMAL)
{
char temp[80];
sprintf(temp, "Current cell (%d,%d)", form_prov->crow, form_prov->ccol);
mesg[0] = "<L>You exited the matrix normally.";
mesg[1] = temp;
mesg[2] = "<L>To get the contents of the matrix cell, you can";
mesg[3] = "<L>use getCDKMatrixCell():";
mesg[4] = getCDKMatrixCell(form_prov, form_prov->crow, form_prov->ccol);
mesg[5] = "";
mesg[6] = "<C>Press any key to continue.";
popupLabel (cdkscreen, mesg, 7);
}
/* Clean up. */
destroyCDKMatrix (form_prov);
destroyCDKScreen (cdkscreen);
endCDK();
exit (EXIT_SUCCESS);
}
void Simpletui::staticCleanup()
{
destroyCDKScreen(reinterpret_cast<CDKSCREEN*>(cdk));
endCDK();
}