int
main(int argc, char **argv)
{
Widget toplevel, widget, bb, list;
XtAppContext app;
XmString item;
Arg args[10];
int n = 0;
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app, "ComBox", NULL, 0, &argc, argv, NULL, NULL);
bb = XmCreateBulletinBoard(toplevel, "bb", NULL, 0);
XtManageChild(bb);
XtSetArg(args[n], XmNwidth, 100); n++;
XtSetArg(args[n], XmNheight, 100); n++;
widget = XmCreateDrawnButton(bb, "drawnButton", args, n);
XtAddCallback(widget, XmNexposeCallback, (XtCallbackProc) onExpose,
(XtPointer)bb);
XtManageChild(widget);
XtRealizeWidget(toplevel);
LessTifTestMainLoop(toplevel);
exit(0);
}
void Resize(void)
{
Arg args[10];
Cardinal argcount;
Widget Label;
if( HelpBoard ) {
XtDestroyWidget( HelpBoard );
XmUpdateDisplay( mainbull );
printf( "Resize! Helpboard destroyed!\n" );
}
argcount = 0;
XtSetArg( args[argcount], XmNresizePolicy, XmRESIZE_ANY ); argcount++;
XtSetArg( args[argcount], XmNunitType, XmPIXELS ); argcount++;
HelpBoard = XmCreateBulletinBoard( mainbull, "Board2", args, argcount );
XtRealizeWidget( HelpBoard );
XtManageChild( HelpBoard );
printf( "Resize! XtWidth: %d\n", XtWidth( pgHelpMainWindow ) );
argcount = 0;
XtSetArg( args[argcount], XmNx, XtWidth( pgHelpMainWindow ) -50 ); argcount++;
XtSetArg( args[argcount], XmNy, 50 ); argcount++;
Label = XmCreateLabel( mainbull, "xxx", args, argcount );
XtManageChild( Label );
}
static void make_width_slider(QSP_ARG_DECL Screen_Obj *sop)
{
Arg al[16];
int ac = 0;
Widget bb;
char buf[4];
sop->so_frame = generic_frame(curr_panel->po_panel_obj,
sop, XmSHADOW_IN);
/* create a bulletin board to hold the slider */
strcpy(buf,"bb");
bb=XmCreateBulletinBoard(sop->so_frame,buf,NULL,0);
XtManageChild(bb);
/* set slider parameters */
XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
XtSetArg(al[ac], XmNshowValue, TRUE); ac++;
XtSetArg(al[ac], XmNminimum, sop->so_min); ac++;
XtSetArg(al[ac], XmNmaximum, sop->so_max); ac++;
XtSetArg(al[ac], XmNvalue, sop->so_val); ac++;
XtSetArg(al[ac], XmNprocessingDirection, XmMAX_ON_RIGHT); ac++;
XtSetArg(al[ac], XmNdecimalPoints, 0); ac++;
XtSetArg(al[ac], XmNscaleMultiple, 1); ac++;
XtSetArg(al[ac], XmNscaleHeight, 15); ac++;
XtSetArg(al[ac], XmNscaleWidth, sop->so_width); ac++;
/* create slider */
sop->so_obj = XmCreateScale(bb, (char *)sop->so_name, al, ac);
/* arrange for slider to become visible */
XtManageChild(sop->so_obj);
}
int
main(int argc, char **argv)
{
int i;
Widget toplevel, bb, label, pressme, pb;
XtAppContext app;
XmString item;
Arg args[5];
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app, "GrabShell", NULL, 0, &argc, argv, NULL, NULL);
bb = XmCreateBulletinBoard(toplevel, "bb", NULL, 0);
pressme = XmCreatePushButton(bb,"Press me and let's see what the grab shell does.",NULL,0);
XtManageChild(pressme);
XtManageChild(bb);
i = 0;
XtSetArg(args[i], XmNownerEvents, True); i++;
XtSetArg(args[i], XmNgrabStyle, GrabModeSync); i++;
grabshell = XmCreateGrabShell(bb, "grab", args, i);
label = XmCreateLabel(grabshell, "Hello World", NULL, 0);
XtManageChild(label);
i = 0;
XtSetArg(args[i], XmNy, 100); i++;
XtSetArg(args[i], XmNx, 0); i++;
pb = XmCreatePushButton(grabshell,"hello", args, i);
XtManageChild(pb);
/* setup callback for an activate action */
XtAddCallback(pressme,
XmNactivateCallback,
(XtCallbackProc) onActivate,
(XtPointer) grabshell);
XtAddCallback(grabshell,
XmNpopupCallback,
(XtCallbackProc) onPopup,
(XtPointer) grabshell);
XtRealizeWidget(toplevel);
#if 1
GrabShellResources(grabshell);
#endif
check_geometry();
LessTifTestMainLoop(toplevel);
exit(0);
}
int
main(int argc, char **argv)
{
XtAppContext app;
XmString item;
Arg al[10];
int ac;
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app, "SpinBox", NULL, 0,
&argc, argv, NULL, NULL);
#ifdef USE_BB
bb = XmCreateBulletinBoard(toplevel, "bb", NULL, 0);
XtManageChild(bb);
#else
bb = toplevel;
#endif
ac = 0;
spb = XmCreateSpinBox(bb, "spinbox", al, ac);
XtAddCallback(spb, XmNvalueChangedCallback, ModifyVerify, NULL);
ac = 0;
XtSetArg(al[ac], XmNspinBoxChildType, XmNUMERIC); ac++;
day = XmCreateText(spb, "day", al, ac);
XtManageChild(day);
ac = 0;
XtSetArg(al[ac], XmNspinBoxChildType, XmNUMERIC); ac++;
month = XmCreateText(spb, "month", al, ac);
XtManageChild(month);
ac = 0;
XtSetArg(al[ac], XmNspinBoxChildType, XmNUMERIC); ac++;
year = XmCreateText(spb, "year", al, ac);
XtManageChild(year);
XtManageChild(spb);
XtRealizeWidget(toplevel);
LessTifTestMainLoop(toplevel);
exit(0);
}
int
main(int argc, char **argv)
{
Widget toplevel, widget, bb, list;
XtAppContext app;
XmString item;
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app, "ComBox", NULL, 0, &argc, argv, NULL, NULL);
bb = XmCreateBulletinBoard(toplevel, "bb", NULL, 0);
XtManageChild(bb);
widget = XmCreateComboBox(bb, "widget", NULL, 0);
/* use list routine to add items */
list = CB_List(widget);
item = XmStringCreateSimple("Item 1");
XmListAddItem(list,item,0);
item = XmStringCreateSimple("Item 2");
XmListAddItem(list,item,0);
item = XmStringCreateSimple("Item 3");
XmListAddItem(list,item,0);
item = XmStringCreateSimple("Item 4");
XmListAddItem(list,item,0);
item = XmStringCreateSimple("Item 5");
XmListAddItem(list,item,0);
XmComboBoxUpdate(widget);
XtManageChild(widget);
XtRealizeWidget(toplevel);
check_geometry(widget);
LessTifTestMainLoop(toplevel);
exit(0);
}
int
main(int argc, char *argv[])
{
XtAppContext app;
Widget shell, w, bb;
void *before;
void *after;
int iter = 0;
int diff = 0;
int total = 0;
shell = XtAppInitialize(&app, "Test", NULL, 0,
&argc, argv, NULL, NULL, 0);
bb = XmCreateBulletinBoard(shell, "BB", NULL, 0);
while (iter < 10000)
{
before = sbrk((ptrdiff_t) 0);
w = XtCreateWidget("name", xmPushButtonGadgetClass, bb, NULL, 0);
XtDestroyWidget(w);
after = sbrk((ptrdiff_t) 0);
if ((int)((char *)after - (char *)before) > 0)
{
if (iter != 0)
{
/*
printf("%i %i %p %i\n", iter, iter - diff, after - before, (after - before) / (iter - diff));
*/
total += (int)((char *)after - (char *)before);
}
diff = iter;
}
iter++;
}
printf("leaking %i bytes per Create/Destroy\n", total / iter);
exit((int)(total / iter));
}
void
main(unsigned int argc, char **argv)
{
Arg args[MAX_ARGS];
Cardinal n;
XmFontList fontlist;
manager_needed = BULLETINBOARD;
CommonTestInit(argc, argv);
if (UserData != NULL)
ProcessCommandArgs();
fontlist = CommonGetFontList("9x15");
n = 0;
if (manager_needed == BULLETINBOARD)
Manager1 = XmCreateBulletinBoard(Shell1, "Manager1", args, n);
else if (manager_needed == FORM)
Manager1 = XmCreateForm(Shell1, "Manager1", args, n);
else if (manager_needed == PANEDWINDOW)
Manager1 = XmCreatePanedWindow(Shell1, "Manager1", args, n);
else if (manager_needed == ROWCOLUMN) {
XtSetArg(args[n], XmNcolumns, 1);
n++;
XtSetArg(args[n], XmNpacking, XmPACK_COLUMN);
n++;
Manager1 = XmCreateRowColumn(Shell1, "Manager1", args, n);
}
XtManageChild(Manager1);
n = 0;
XtSetArg(args[n], XmNindicatorOn, True);
n++;
XtSetArg(args[n], XmNfontList, fontlist);
n++;
if (manager_needed == FORM) {
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);
n++;
}
ToggleButton1 = XmCreateToggleButton(Manager1, "ToggleButton1", args, n);
XtManageChild(ToggleButton1);
n = 0;
XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY);
n++;
XtSetArg(args[n], XmNspacing, 10);
n++;
XtSetArg(args[n], XmNfillOnSelect, False);
n++;
if (manager_needed == FORM) {
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);
n++;
XtSetArg(args[n], XmNtopWidget, ToggleButton1);
n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);
n++;
}
if (manager_needed == BULLETINBOARD) {
XtSetArg(args[n], XmNy, 50);
n++;
}
ToggleButton2 = XmCreateToggleButton(Manager1, "ToggleButton2", args, n);
XtManageChild(ToggleButton2);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False);
n++;
if (manager_needed == FORM) {
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);
n++;
XtSetArg(args[n], XmNtopWidget, ToggleButton2);
n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);
n++;
}
if (manager_needed == BULLETINBOARD) {
XtSetArg(args[n], XmNy, 100);
n++;
}
ToggleButton3 = XmCreateToggleButton(Manager1, "ToggleButton3", args, n);
XtManageChild(ToggleButton3);
n = 0;
XtSetArg(args[n], XmNset, True);
n++;
XtSetArg(args[n], XmNfillOnSelect, True);
n++;
if (manager_needed == FORM) {
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);
n++;
XtSetArg(args[n], XmNtopWidget, ToggleButton3);
n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);
n++;
}
if (manager_needed == BULLETINBOARD) {
XtSetArg(args[n], XmNy, 150);
n++;
}
ToggleButton4 = XmCreateToggleButton(Manager1, "ToggleButton4", args, n);
XtManageChild(ToggleButton4);
px_unselect = XCreatePixmapFromBitmapData(display,
DefaultRootWindow(display),
XBMu_BITS,
XBMu_WIDTH,XBMu_HEIGHT,
WhitePixel(display,DefaultScreen(display)),
BlackPixel(display,DefaultScreen(display)),
DefaultDepth(display,DefaultScreen(display)));
px_select = XCreatePixmapFromBitmapData(display,
DefaultRootWindow(display),
XBMs_BITS, XBMs_WIDTH,XBMs_HEIGHT,
WhitePixel(display,DefaultScreen(display)),
BlackPixel(display,DefaultScreen(display)),
DefaultDepth(display,DefaultScreen(display)));
n = 0;
XtSetArg(args[n], XmNlabelType, XmPIXMAP);
n++;
XtSetArg(args[n], XmNselectPixmap, px_select);
n++;
XtSetArg(args[n], XmNlabelPixmap, px_unselect);
n++;
XtSetArg(args[n], XmNindicatorOn, False);
n++;
if (manager_needed == FORM) {
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);
n++;
XtSetArg(args[n], XmNtopWidget, ToggleButton4);
n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);
n++;
}
if (manager_needed == BULLETINBOARD) {
XtSetArg(args[n], XmNy, 200);
n++;
}
ToggleButton5 = XmCreateToggleButton(Manager1, "ToggleButton5", args, n);
XtManageChild(ToggleButton5);
n = 0;
XtSetArg(args[n], XmNindicatorOn, False);
n++;
XtSetArg(args[n], XmNshadowThickness, 4);
n++;
if (manager_needed == FORM) {
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);
n++;
XtSetArg(args[n], XmNtopWidget, ToggleButton5);
n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);
n++;
}
if (manager_needed == BULLETINBOARD) {
XtSetArg(args[n], XmNy, 300);
n++;
}
ToggleButton6 = XmCreateToggleButton(Manager1, "ToggleButton6", args, n);
XtManageChild(ToggleButton6);
XtRealizeWidget(Shell1);
for (n = 0; n < 5; n++)
CommonPause();
XmToggleButtonSetState(ToggleButton5, TRUE, FALSE);
CommonPause();
XmToggleButtonSetState(ToggleButton5, FALSE, FALSE);
CommonPause();
n = 0;
XtSetArg (args[n], XmNbackgroundPixmap, px_select);
n++;
XtSetValues (ToggleButton5, args, n);
CommonPause();
n = 0;
XtSetArg (args[n], XmNbackgroundPixmap, XmUNSPECIFIED_PIXMAP);
n++;
XtSetValues (ToggleButton5, args, n);
CommonPause();
/* Begin PIR3850 */
n = 0;
XtSetArg (args[n], XmNbackgroundPixmap, None);
n++;
XtSetValues (Manager1, args, n);
CommonPause();
/* End PIR3850 */
XtDestroyWidget(Manager1);
CommonPause();
XtAppMainLoop(app_context);
}
void
main (int argc, char **argv)
{
Arg args[10];
int n,i;
char buf[16];
Widget Parent;
Widget Notebook;
Widget Frame1,Form1,PW1,RC1,BB1,PB1;
Widget MajorTab[3];
Widget MinorTab[3];
Widget StatusArea[6];
Widget FrameKid1;
Widget FormKid[4];
Widget RCKid[4];
Widget BBKid[4];
Widget PWKid[4];
CommonTestInit (argc, argv);
/*
* Create the parent.
*/
n=0;
Parent = XmCreateFrame (Shell1, "Parent", args, n);
XtManageChild (Parent);
n=0;
Notebook = XmCreateNotebook (Parent, "Notebook", args, n);
XtManageChild (Notebook);
for (i=0; i< 3; i++)
{
n=0;
sprintf (buf, "MajorTab%d", i+1);
MajorTab[i] = XmCreatePushButton (Notebook,buf,args,n);
XtManageChild(MajorTab[i]);
}
for (i=0; i< 3; i++)
{
sprintf (buf, "MinorTab%d", i+1);
MinorTab[i] = XmCreatePushButton (Notebook,buf,args,n);
XtManageChild(MinorTab[i]);
}
for (i=0; i< 7; i++)
{
n=0;
sprintf (buf,"StatusArea%d", i+1);
StatusArea[i] = XmCreateText (Notebook, buf, args,n);
XtManageChild(StatusArea[i]);
}
/*
* Create Pages of Notebook
*/
n=0;
Frame1 = XmCreateFrame (Notebook, "Frame1", args, n);
XtManageChild (Frame1);
n=0;
Form1 = XmCreateForm (Notebook, "Form1", args, n);
XtManageChild (Form1);
n=0;
RC1 = XmCreateRowColumn (Notebook, "RC1", args, n);
XtManageChild (RC1);
n=0;
PW1 = XmCreatePanedWindow (Notebook, "PW1", args, n);
XtManageChild (PW1);
n=0;
BB1 = XmCreateBulletinBoard (Notebook, "BB1", args, n);
XtManageChild (BB1);
n=0;
PB1 = XmCreatePushButton (Notebook, "PB1", args, n);
XtManageChild (PB1);
n=0;
NB1 = XmCreateNotebook (Notebook, "NB1", args, n);
XtManageChild (NB1);
/*
* Create kids of pages
*/
n=0;
FrameKid1 = XmCreatePushButton (Frame1,"FrameKid1",args,n);
XtManageChild (FrameKid1);
for (i=0; i < 4; i++)
{
n=0;
sprintf (buf, "FormKid%d", i+1);
FormKid[i] = XmCreatePushButton (Form1,buf,args,n);
XtManageChild (FormKid[i]);
}
for (i=0; i < 4; i++)
{
n=0;
sprintf (buf, "RCKid%d", i+1);
RCKid[i] = XmCreatePushButton (RC1,buf,args,n);
XtManageChild (RCKid[i]);
}
for (i=0; i < 4; i++)
{
n=0;
sprintf (buf, "PWKid%d", i+1);
PWKid[i] = XmCreatePushButton (PW1,buf,args,n);
XtManageChild (PWKid[i]);
}
for (i=0; i < 4; i++)
{
n=0;
sprintf (buf, "BBKid%d", i+1);
BBKid[i] = XmCreatePushButton (BB1,buf,args,n);
XtManageChild (BBKid[i]);
}
n=0;
NBKid1 = XmCreateMessageBox (NB1, "NBKid1", args, n);
XtManageChild (NBKid1);
XtRealizeWidget (Shell1);
CommonPause();
CommonPause();
CommonPause();
CommonPause();
XtDestroyWidget (Notebook);
CommonPause();
/*
* destroy the widget
*/
CommonPause();
XtAppMainLoop (app_context);
}
void
main(unsigned int argc, char **argv)
{
Cardinal n;
Arg args[MAX_ARGS];
Boolean async_in;
Boolean wfw_in;
int wTo_in;
CommonTestInit(argc, argv);
/*
* test case for PIR 3058
* Create a Shell with TWO children - only one is managed. The
* SubstructureNotify eventhandler on the shell confuses it when
* the UNmanaged child is getting resized. See report for details.
*/
XtAddEventHandler(Shell1, SubstructureNotifyMask, True, Junk, NULL);
BBoard1 = XmCreateBulletinBoard(Shell1, "BBoard1", NULL, 0);
PushButton1 = XmCreatePushButton(Shell1, "PushButton1", NULL, 0);
XtManageChild(PushButton1);
XtAddCallback(PushButton1, XmNactivateCallback, activatePB, NULL);
/* end of test case for PIR 3058 */
XtRealizeWidget(Shell1);
CommonPause();
/*
* This case shows that it works as expected when there isn't
* an event handler registered for SubstructureNotify (PIR 3058)
*/
XtRemoveEventHandler(Shell1, SubstructureNotifyMask, True, Junk, NULL);
XtDestroyWidget(PushButton1);
XtDestroyWidget(BBoard1);
BBoard1 = XmCreateBulletinBoard(Shell1, "BBoard1", NULL, 0);
PushButton1 = XmCreatePushButton(Shell1, "PushButton1", NULL, 0);
XtManageChild(PushButton1);
XtAddCallback(PushButton1, XmNactivateCallback, activatePB, NULL);
CommonPause();
/*
* Text for CR 2940 - Check for changes in BulletinBoard noResize resource.
*/
XtDestroyWidget(PushButton1);
XtDestroyWidget(BBoard1);
n = 0;
toplevelShell = XtAppCreateShell("topLevelShell", "TopLevelShell",
topLevelShellWidgetClass, display,
args, n);
BBoard1 = XmCreateBulletinBoard(toplevelShell, "BBoard1", NULL, 0);
PushButton1 = XmCreatePushButton(BBoard1, "PushButton1", NULL, 0);
XtManageChild(PushButton1);
XtAddCallback(PushButton1, XmNactivateCallback, ChangeNoResize, NULL);
XtManageChild(BBoard1);
XtRealizeWidget(toplevelShell);
CommonPause();
XtDestroyWidget (toplevelShell);
/* make output on term window look nicer */
printf ("\n");
printf ("\n");
printf ("\n");
CommonPause();
/* begin test for CR 1684 */
bool_str[0] = "False";
bool_str[1] = "True";
result_str[0] = "Failed";
result_str[1] = "Passed";
/* Test 1 - Initialization */
async_in = True;
wfw_in = False;
wTo_in = 0;
n=0;
XtSetArg(args[n], XmNuseAsyncGeometry, async_in); n++;
XtSetValues (Shell1, args, n);
n=0;
BBoard1 = XmCreateBulletinBoard(Shell1, "BBoard1", args, n);
n=0;
PushButton1 = XmCreatePushButton(BBoard1, "PushButton1", args, n);
printf("Test1: Initialize UseAsyncGeo to True\n");
GetAndPrint(async_in, wfw_in, wTo_in);
/* Test 2 - Using SetValues, return UseAsyncGeo to False */
async_in = False;
wfw_in = True;
wTo_in = 5000;
n = 0;
XtSetArg(args[n], XmNuseAsyncGeometry, async_in); n++;
XtSetValues(Shell1, args, n);
printf("\nTest 2: Change UseAsyncGeo to False using SetValues\n");
GetAndPrint(async_in, wfw_in, wTo_in);
/* Test 3 - Using SetValues, return UseAsyncGeo to True */
async_in = True;
wfw_in = False;
wTo_in = 0;
n = 0;
XtSetArg(args[n], XmNuseAsyncGeometry, async_in); n++;
XtSetValues(Shell1, args, n);
printf("\nTest 3: Change UseAsyncGeo to True using SetValues\n");
GetAndPrint(async_in, wfw_in, wTo_in);
/* Test 4 - Using SetValues, change UseAsyncGeo to True and WaitForWm
to False and WmTimeout to 1000 */
async_in = False;
wfw_in = False;
wTo_in = 1000;
n = 0;
XtSetArg(args[n], XmNuseAsyncGeometry, False); n++;
XtSetArg(args[n], XmNwaitForWm, False); n++;
XtSetArg(args[n], XmNwmTimeout, 1000); n++;
XtSetValues(Shell1, args, n);
printf("\nTest 4: Change UseAsyncGeo to False, WaitForWm to False and WmTimeout to 1000 using SetValues\n");
GetAndPrint(async_in, wfw_in, wTo_in);
CommonPause();
/* Test 5 - Using SetValues, change UseAsyncGeo to True, WaitForWm to Ture,
and WmTimeout to 2000. */
async_in = True;
wfw_in = False;
wTo_in = 0;
n = 0;
XtSetArg(args[n], XmNuseAsyncGeometry, async_in); n++;
XtSetArg(args[n], XmNwaitForWm, True); n++;
XtSetArg(args[n], XmNwmTimeout, 2000); n++;
XtSetValues(Shell1, args, n);
printf("\nTest 5: Change UseAsyncGeo to True, WaitForWm to True, and WmTimeout to 2000 using SetValues\n");
GetAndPrint(async_in, wfw_in, wTo_in);
/* Test 6 - Using SetValues, change UseAsyncGeo to False to check the
results of Test 5 */
async_in = False;
wfw_in = True;
wTo_in = 2000;
n = 0;
XtSetArg(args[n], XmNuseAsyncGeometry, async_in); n++;
XtSetValues(Shell1, args, n);
printf("\nTest 6: Change UseAsyncGeo to False to verify values loaded in Test 5 using SetValues\n");
GetAndPrint(async_in, wfw_in, wTo_in);
/* Test 7 - Using SetValues, change UseAsyncGeo to True. Then change WaitForWm
to False and WmTimeout to 1000. */
async_in = True;
wfw_in = False;
wTo_in = 0;
n = 0;
XtSetArg(args[n], XmNuseAsyncGeometry, async_in); n++;
XtSetValues(Shell1, args, n);
n = 0;
XtSetArg(args[n], XmNwaitForWm, False); n++;
XtSetArg(args[n], XmNwmTimeout, 1000); n++;
XtSetValues(Shell1, args, n);
printf("\nTest 7: Change UseAsyncGeo to True. Then change WaitForWm to False, and WmTimeout to 1000 afterwards\n");
GetAndPrint(async_in, wfw_in, wTo_in);
/* Test 8 - Using SetValues, change UseAsyncGeo to False to check the
previously loaded data */
async_in = False;
wfw_in = False;
wTo_in = 1000;
n = 0;
XtSetArg(args[n], XmNuseAsyncGeometry, async_in); n++;
XtSetValues(Shell1, args, n);
printf("\nTest 8: Change UseAsyncGeo to False to check the previously loaded data\n");
GetAndPrint(async_in, wfw_in, wTo_in);
/* Test 9 - Using SetValues, change WaitForWm to True, and WmTimeout to 2000. */
async_in = False;
wfw_in = True;
wTo_in = 2000;
n = 0;
XtSetArg(args[n], XmNwaitForWm, True); n++;
XtSetArg(args[n], XmNwmTimeout, 2000); n++;
XtSetValues(Shell1, args, n);
printf("\nTest 9: Change WaitForWm to True and WmTimeout to 2000 while UseAsyncGeo is False using SetValues\n");
GetAndPrint(async_in, wfw_in, wTo_in);
/* End test for CR 1684 */
CommonPause();
XtAppMainLoop(app_context);
}
Widget XmCreateBulletinBoard_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateBulletinBoard(parent, name, arglist, argcount);}
int
main(int argc, char **argv)
{
Widget toplevel, widget, bb, list;
XtAppContext app;
XmString item;
Arg args[10];
int n = 0;
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app, "ComBox", NULL, 0, &argc, argv, NULL, NULL);
bb = XmCreateBulletinBoard(toplevel, "bb", NULL, 0);
XtManageChild(bb);
widget = XmCreateDropDownComboBox(bb, "combo", args, n);
#if 0
/* causes a core dump and reports a warning */
XtDestroyWidget(CB_EditBox(widget));
/* causes a core dump */
XtDestroyWidget(CB_List(widget));
/* reports warning if list or edit box are unmanaged */
XtUnmanageChild(CB_List(widget));
XtUnmanageChild(CB_EditBox(widget));
/* does not report warning if scrolled window is unmanaged */
XtUnmanageChild(CB_ScrolledW(widget));
#endif
/* use list routine to add items */
list = CB_List(widget);
item = XmStringCreateSimple("Item 1");
XmListAddItem(list,item,0);
item = XmStringCreateSimple("Item 2");
XmListAddItem(list,item,0);
item = XmStringCreateSimple("Item 3");
XmListAddItem(list,item,0);
item = XmStringCreateSimple("Item 4");
XmListAddItem(list,item,0);
item = XmStringCreateSimple("Item 5");
XmListAddItem(list,item,0);
XmComboBoxUpdate(widget);
XtManageChild(widget);
XtRealizeWidget(toplevel);
#if 1
XdbPrintResources(CB_ListShell(widget));
XdbPrintResources(widget);
#endif
check_geometry(widget);
LessTifTestMainLoop(toplevel);
exit(0);
}
int
main (int argc, char **argv)
{
Widget workRegion, simpleWidget, simpleGadget;
register int n;
Arg args[MAX_ARGS];
Position x, y;
Dimension width, height, border_width;
CommonTestInit(argc, argv);
n = 0;
XtSetArg(args[n], XmNwidth, 200); n++;
XtSetArg(args[n], XmNheight, 200); n++;
XtSetValues(Shell1, args, n);
XtRealizeWidget(Shell1);
/* set up a manager */
n = 0;
XtSetArg(args[n],XmNnoResize, True); n++;
XtSetArg(args[n],XmNresizePolicy, XmRESIZE_NONE); n++;
XtSetArg(args[n],XmNwidth, 200); n++;
XtSetArg(args[n],XmNheight, 200); n++;
workRegion = XmCreateBulletinBoard(Shell1,"WorkRegion", args, n);
XtManageChild(workRegion);
/* Instantiate a PushButton widget. */
n = 0;
XtSetArg(args[n],XmNrecomputeSize, False); n++;
XtSetArg(args[n],XmNshadowThickness, 5); n++;
XtSetArg(args[n],XmNmarginWidth, 5); n++;
XtSetArg(args[n],XmNx, 5); n++;
XtSetArg(args[n],XmNy, 5); n++;
XtSetArg(args[n],XmNborderWidth, 5); n++;
XtSetArg(args[n],XmNwidth, 90); n++;
XtSetArg(args[n],XmNheight, 50); n++;
simpleWidget = XmCreatePushButton(workRegion,"Widget", args, n);
XtManageChild(simpleWidget);
CommonPause();
/* move the child widget */
XmeConfigureObject(simpleWidget, 30, 30, 90, 50, 5);
XtVaGetValues(simpleWidget,
XmNx, &x,
XmNy, &y,
NULL);
if (x != 30 || y !=30)
printf("ERROR: incorrect position values\n");
CommonPause();
/* change the child widget's border */
XmeConfigureObject(simpleWidget, 30, 30, 90, 50, 25);
XtVaGetValues(simpleWidget,
XmNborderWidth, &border_width,
NULL);
if (border_width != 25)
printf("ERROR: incorrect border value\n");
CommonPause();
/* change the size of the widget */
XmeConfigureObject(simpleWidget, 30, 30, 150, 100, 5);
XtVaGetValues(simpleWidget,
XmNheight, &height,
XmNwidth, &width,
NULL);
if (width != 150 || height != 100)
printf("ERROR: incorrect size values\n");
CommonPause();
/* Instantiate a PushButton gadget. */
XtDestroyWidget(simpleWidget);
n = 0;
XtSetArg(args[n],XmNrecomputeSize, False); n++;
XtSetArg(args[n],XmNshadowThickness, 5); n++;
XtSetArg(args[n],XmNmarginWidth, 5); n++;
XtSetArg(args[n],XmNx, 5); n++;
XtSetArg(args[n],XmNy, 5); n++;
XtSetArg(args[n],XmNborderWidth, 5); n++;
XtSetArg(args[n],XmNwidth, 90); n++;
XtSetArg(args[n],XmNheight, 50); n++;
simpleGadget = XmCreatePushButtonGadget(workRegion,"Gadget", args, n);
XtManageChild(simpleGadget);
CommonPause();
/* move the child gadget */
XmeConfigureObject(simpleGadget, 80, 30, 90, 50, 5);
XtVaGetValues(simpleGadget,
XmNx, &x,
XmNy, &y,
NULL);
if (x != 80 || y !=30)
printf("ERROR: incorrect position values\n");
CommonPause();
/* change the child gadget's border */
XmeConfigureObject(simpleGadget, 30, 30, 90, 50, 25);
XtVaGetValues(simpleGadget,
XmNborderWidth, &border_width,
NULL);
if (border_width != 25)
printf("ERROR: incorrect border value: %d\n",border_width);
CommonPause();
/* change the size of the gadget */
XmeConfigureObject(simpleGadget, 30, 30, 150, 100, 5);
XtVaGetValues(simpleGadget,
XmNheight, &height,
XmNwidth, &width,
NULL);
if (width != 150 || height != 100)
printf("ERROR: incorrect size values\n");
CommonPause();
CommonPause(); /* quit */
XtAppMainLoop(app_context);
XtDestroyWidget(Shell1);
}
int main(int argc, char **argv)
{
register int n;
Arg args[MAX_ARGS];
XmString tcs;
void PostPopup();
void ButtonCB();
CommonTestInit(argc, argv);
n = 0;
XtSetArg(args[n], XmNwidth, 200); n++;
XtSetArg(args[n], XmNheight, 40); n++;
XtSetValues(Shell1, args, n);
XtRealizeWidget(Shell1);
Label = CreateLabel("Press MB3 to dismiss PopupMenu", Shell1);
/*
** PopupMenu1
*/
n = 0;
XtSetArg(args[n], XmNx, 100); n++;
XtSetArg(args[n], XmNy, 100); n++;
XtSetArg(args[n], XmNmenuAccelerator, NULL); n++;
PopupMenu1 = XmCreatePopupMenu(Label, "popupMenu", args, n);
/*
** Menu1
*/
Label1 = CreateLabel("Menu1", PopupMenu1);
Separator1 = CreateSeparator(PopupMenu1, "Separator1");
PushBtn1 = CreatePushButton("PushButton1", PopupMenu1);
ToggleBtn1 = CreateToggle("Toggle1", PopupMenu1);
XtManageChild(PopupMenu1);
CommonPause();
XtDestroyWidget(PopupMenu1);
n =0;
XtSetArg(args[n], XmNrowColumnType, XmMENU_POPUP); n++;
PopupMenu2 = XmCreateRowColumn(Shell1, "popupMenu2", args, n);
/*
** Menu2
*/
Label2 = CreateLabel("Menu2", PopupMenu2);
Separator2 = CreateSeparator(PopupMenu2, "Separator2");
PushBtn2 = CreatePushButton("PushButton2", PopupMenu2);
ToggleBtn2 = CreateToggle("Toggle2", PopupMenu2);
XtManageChild(PopupMenu2);
CommonPause();
XtDestroyWidget(Label);
XtDestroyWidget(PopupMenu2);
/*
* Test 3 for PIR 2669
*/
n = 0;
testingArea = XmCreateBulletinBoard(Shell1, "PushButtonHere", args, n);
n = 0;
XtSetArg(args[n], XmNx, 10); n++;
XtSetArg(args[n], XmNy, 30); n++;
MainButton = XmCreatePushButton(testingArea, "button0", args, n);
XtAddCallback(MainButton, XmNactivateCallback, ButtonCB, (XtPointer) 0);
XtManageChild(MainButton);
popup = XmCreatePopupMenu(testingArea, "Popups", NULL, 0);
XtAddEventHandler(testingArea, ButtonPressMask, FALSE, PostPopup, popup);
XmAddToPostFromList(popup, MainButton);
push = XmCreatePushButton(popup, "button1", NULL, 0);
XtAddCallback(push, XmNactivateCallback, ButtonCB, (XtPointer) 1);
XtManageChild(push);
push = XmCreatePushButton(popup, "button2", NULL, 0);
XtAddCallback(push, XmNactivateCallback, ButtonCB, (XtPointer) 2);
XtManageChild(push);
push = XmCreatePushButton(popup, "button3", NULL, 0);
XtAddCallback(push, XmNactivateCallback, ButtonCB, (XtPointer) 3);
XtManageChild(push);
XtManageChild(testingArea);
CommonPause();
XtDestroyWidget(testingArea);
CommonPause();
XtAppMainLoop(app_context);
}
void
main(unsigned int argc, char **argv)
{
register int n;
Arg args[MAX_ARGS];
XmString tcs;
Widget TopShell1, TopShell2;
Widget BB1, BB2;
Widget PrimaryButton1, PrimaryButton2;
Widget FullAppButton1, FullAppButton2;
Widget SystemButton1, SystemButton2;
Widget ModelessButton1, ModelessButton2;
for (n = 0; n < MAX_DIALOGS; n++) {
ModelessDia[n].Dialog = NULL;
ModelessDia[n].Parent = NULL;
ModelessDia[n].DialogIndex = -1;
PrimaryDia[n].Dialog = NULL;
PrimaryDia[n].Parent = NULL;
PrimaryDia[n].DialogIndex = -1;
FullAppDia[n].Dialog = NULL;
FullAppDia[n].Parent = NULL;
FullAppDia[n].DialogIndex = -1;
SystemDia[n].Dialog = NULL;
SystemDia[n].Parent = NULL;
SystemDia[n].DialogIndex = -1;
}
CommonTestInit(argc, argv);
n = 0;
XtSetArg(args[n], XmNmappedWhenManaged, True); n++;
XtSetArg(args[n], XmNallowShellResize, True); n++;
XtSetArg(args[n], XmNtitle, "TopShell1"); n++;
TopShell1 = XtCreatePopupShell("TopShell1", topLevelShellWidgetClass,
Shell1, args, n);
n = 0;
XtSetArg(args[n], XmNmappedWhenManaged, True); n++;
XtSetArg(args[n], XmNallowShellResize, True); n++;
XtSetArg(args[n], XmNtitle, "TopShell2"); n++;
XtSetArg(args[n], XtNgeometry, "+10+500"); n++;
TopShell2 = XtCreatePopupShell("TopShell2", topLevelShellWidgetClass,
Shell1, args, n);
/* The following is for while running under automation */
if (XtIsRealized(TopShell1)) {
XtUnmapWidget(TopShell1);
XtMapWidget(TopShell1);
}
/* Shell 1 children */
n = 0;
BB1 = XmCreateBulletinBoard (TopShell1, "BB1", args, n);
XtManageChild (BB1);
n = 0;
XtSetArg (args[n], XmNx, 10); n++;
XtSetArg (args[n], XmNy, 100); n++;
XtSetArg (args[n], XmNlabelString,
XmStringCreateSimple ("Create Primary Modal from TopShell1"));
n++;
PrimaryButton1 = XmCreatePushButton (BB1, "PrimaryButton1", args, n);
XtManageChild (PrimaryButton1);
XtAddCallback (PrimaryButton1, XmNactivateCallback,
PostPrimaryModalDialog, TopShell1);
n = 0;
XtSetArg (args[n], XmNx, 10); n++;
XtSetArg (args[n], XmNy, 150); n++;
XtSetArg (args[n], XmNlabelString,
XmStringCreateSimple ("Create Full App Modal from TopShell1"));
n++;
FullAppButton1 = XmCreatePushButton (BB1, "FullAppButton1", args, n);
XtManageChild (FullAppButton1);
XtAddCallback (FullAppButton1, XmNactivateCallback,
PostFullAppModalDialog, TopShell1);
n = 0;
XtSetArg (args[n], XmNx, 10); n++;
XtSetArg (args[n], XmNy, 200); n++;
XtSetArg (args[n], XmNlabelString,
XmStringCreateSimple ("Create System Modal from TopShell1"));
n++;
SystemButton1 = XmCreatePushButton (BB1, "SystemButton1", args, n);
XtManageChild (SystemButton1);
XtAddCallback (SystemButton1, XmNactivateCallback, PostSystemModalDialog,
TopShell1);
n = 0;
XtSetArg (args[n], XmNx, 10); n++;
XtSetArg (args[n], XmNy, 250); n++;
XtSetArg (args[n], XmNlabelString,
XmStringCreateSimple ("Create Modeless Dialog from TopShell1"));
n++;
ModelessButton1 = XmCreatePushButton (BB1, "ModelessButton1", args, n);
XtManageChild (ModelessButton1);
XtAddCallback (ModelessButton1, XmNactivateCallback, PostModelessDialog,
TopShell1);
/* Shell 2 children */
n = 0;
BB2 = XmCreateBulletinBoard (TopShell2, "BB2", args, n);
XtManageChild (BB2);
n = 0;
XtSetArg (args[n], XmNx, 10); n++;
XtSetArg (args[n], XmNy, 100); n++;
XtSetArg (args[n], XmNlabelString,
XmStringCreateSimple ("Create Primary Modal from TopShell2"));
n++;
PrimaryButton2 = XmCreatePushButton (BB2, "PrimaryButton2", args, n);
XtManageChild (PrimaryButton2);
XtAddCallback (PrimaryButton2, XmNactivateCallback, PostPrimaryModalDialog,
TopShell2);
n = 0;
XtSetArg (args[n], XmNx, 10); n++;
XtSetArg (args[n], XmNy, 150); n++;
XtSetArg (args[n], XmNlabelString,
XmStringCreateSimple ("Create Full App Modal from TopShell2"));
n++;
FullAppButton2 = XmCreatePushButton (BB2, "FullAppButton2", args, n);
XtManageChild (FullAppButton2);
XtAddCallback (FullAppButton2, XmNactivateCallback,
PostFullAppModalDialog, TopShell2);
n = 0;
XtSetArg (args[n], XmNx, 10); n++;
XtSetArg (args[n], XmNy, 200); n++;
XtSetArg (args[n], XmNlabelString,
XmStringCreateSimple ("Create System Modal from TopShell2"));
n++;
SystemButton2 = XmCreatePushButton (BB2, "SystemButton2", args, n);
XtManageChild (SystemButton2);
XtAddCallback (SystemButton2, XmNactivateCallback, PostSystemModalDialog,
TopShell2);
n = 0;
XtSetArg (args[n], XmNx, 10); n++;
XtSetArg (args[n], XmNy, 250); n++;
XtSetArg (args[n], XmNlabelString,
XmStringCreateSimple ("Create Modeless Dialog from TopShell2"));
n++;
ModelessButton2 = XmCreatePushButton (BB2, "ModelessButton2", args, n);
XtManageChild (ModelessButton2);
XtAddCallback (ModelessButton2, XmNactivateCallback, PostModelessDialog,
TopShell2);
XtRealizeWidget(TopShell1);
XtPopup(TopShell1, XtGrabNone);
XtRealizeWidget(TopShell2);
XtPopup(TopShell2, XtGrabNone);
CommonPause();
CommonPause();
CommonPause();
CommonPause();
#ifndef MOTIF1_1
CommonPause();
Test1_2 = True;
CommonPause();
CommonPause();
CommonPause();
#endif /* MOTIF1_1 */
CommonPause();
XtAppMainLoop(app_context);
}
void
CreateSpinBoxes(Widget parent_of_spin_box)
{
Cardinal n;
Position nextY;
Arg argList[25];
Widget parent;
XmString decoString;
/***** Set Y position for next SpinBox *****/
nextY = 10;
/***** Create BulletinBoard parent for SpinBox widgets *****/
n = 0;
XtSetArg(argList[n], XmNwidth, 250); n++;
XtSetArg(argList[n], XmNheight, 400); n++;
parent = XmCreateBulletinBoard(parent_of_spin_box, "Parent",
argList, n);
XtManageChild(parent);
/****************************************************************/
/*****
***** Create SpinBox spin0
*****
***** Choices: months of the year
*****
***** Callbacks:
***** - changedSpin0 Prints string desription of callback
***** reason, and prints 'new' year when boundary
***** is crossed (January to December, decrement year;
***** December to January, increment year);
*****/
/***** Create SpinBox parent *****/
n = 0;
XtSetArg(argList[n], XmNy, nextY); n++;
spin0 = XmCreateSpinBox(parent, "spin0", argList, n);
/***** Increment Y position for next SpinBox *****/
nextY += Y_OFFSET;
/***** Create XmString array of month names *****/
setMonths();
/***** Create TextField child *****/
n = 0;
XtSetArg(argList[n], XmNvalues, monthValues); n++;
XtSetArg(argList[n], XmNnumValues, 12); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmSTRING); n++;
XtSetArg(argList[n], XmNselectionPolicy, XmSINGLE_SELECT); n++;
XtSetArg(argList[n], XmNeditable, False); n++;
spin0_text = XmCreateTextField(spin0, "spin0_text", argList, n);
/***** Manage SpinBox *****/
XtManageChild(spin0);
/***** Call changedSpin0 AFTER displayed value has changed *****/
XtAddCallback(spin0, XmNvalueChangedCallback, changedSpin0, (XtPointer) 0);
/***** Manage SpinBox child *****/
XtManageChild(spin0_text);
/***** End of SpinBox spin0 *****/
/*****
***** Create SpinBox spin1
*****
***** Choices: letters of the alphabet
*****
***** Callbacks:
***** - modifySpin1 Callback prevents spinning beyond
***** positions 0 (letter a) and 6 (letter g)
*****
***** - changedSpin1 Sets arrow sensitivity to inhibit wrapping
*****
*****/
/***** Create SpinBox parent *****/
n = 0;
XtSetArg(argList[n], XmNy, nextY); n++;
XtSetArg(argList[n], XmNdefaultArrowSensitivity,
XmARROWS_DECREMENT_SENSITIVE); n++;
spin1 = XmCreateSpinBox(parent, "spin1", argList, n);
/***** Increment Y position for next SpinBox *****/
nextY += Y_OFFSET;
/***** Create XmString array of single letters *****/
setLetters();
/***** Create SpinBox child *****/
n = 0;
XtSetArg(argList[n], XmNvalues, letterValues); n++;
XtSetArg(argList[n], XmNnumValues, NUM_LETTERS); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmSTRING); n++;
XtSetArg(argList[n], XmNarrowSensitivity,
XmARROWS_INCREMENT_SENSITIVE); n++;
XtSetArg(argList[n], XmNeditable, False); n++;
spin1_text = XmCreateTextField(spin1, "spin0_text", argList, n);
/***** Manage SpinBox *****/
XtManageChild(spin1);
/***** Call modifySpin1 BEFORE displayed value is changed *****/
XtAddCallback(spin1, XmNmodifyVerifyCallback, modifySpin1, (XtPointer) 0);
/***** Call changedSpin1 AFTER displayed value has changed *****/
XtAddCallback(spin1, XmNvalueChangedCallback, changedSpin1, (XtPointer) 0);
/***** Manage SpinBox child *****/
XtManageChild(spin1_text);
/***** End of SpinBox spin1 *****/
/*****
***** Create SpinBox spin2
*****
***** Choices: 0.0000 to 0.0010 by .0002
*****
***** Initial Position: 4 (displays 0.0008)
*****
***** Callbacks: none
*****
*****/
/***** Create SpinBox parent *****/
n = 0;
XtSetArg(argList[n], XmNy, nextY); n++;
spin2 = XmCreateSpinBox( parent, "spin2", argList, n );
/***** Increment Y position for next SpinBox *****/
nextY += Y_OFFSET;
n = 0;
XtSetArg(argList[n], XmNposition, 4); n++;
XtSetArg(argList[n], XmNdecimalPoints, 4); n++;
XtSetArg(argList[n], XmNincrementValue, 2); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmNUMERIC); n++;
XtSetArg(argList[n], XmNeditable, False); n++;
spin2_text = XmCreateTextField( spin2,
"spin2_text",
argList,
n );
/***** Manage SpinBox *****/
XtManageChild(spin2);
/***** Manage SpinBox child *****/
XtManageChild(spin2_text);
/***** End of SpinBox spin2 *****/
/*****
***** Create SpinBox spin3
*****
***** Choices: 0.000 to 121.500 by 0.002
*****
***** Callbacks: none
*****
*****/
/***** Create SpinBox parent *****/
n = 0;
XtSetArg(argList[n], XmNy, nextY); n++;
XtSetArg(argList[n], XmNrepeatDelay, 250); n++;
XtSetArg(argList[n], XmNarrowLayout, XmARROWS_BEGINNING); n++;
spin3 = XmCreateSpinBox( parent,
"spin3",
argList,
n );
/***** Increment Y position for next SpinBox *****/
nextY += Y_OFFSET;
n = 0;
XtSetArg(argList[n], XmNminimumValue, 0); n++;
XtSetArg(argList[n], XmNdecimalPoints, 3); n++;
XtSetArg(argList[n], XmNincrementValue, 2); n++;
XtSetArg(argList[n], XmNmaximumValue, 121500); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmNUMERIC); n++;
spin3_text = XmCreateTextField( spin3,
"spin3_text",
argList,
n );
/***** Manage SpinBox *****/
XtManageChild(spin3);
/***** Manage SpinBox child *****/
XtManageChild(spin3_text);
/***** End of SpinBox spin3 *****/
/*****
***** Create SpinBox spin4
*****
***** Choices: 0 to 10 by 1
*****
***** Callbacks:
***** - modifySpin4 Callback inhibits spinning below 0
***** at all times. Wrapping increments the maximum value.
*****
*****/
/***** Create SpinBox parent *****/
n = 0;
XtSetArg(argList[n], XmNy, nextY); n++;
XtSetArg(argList[n], XmNarrowSize, 35); n++;
XtSetArg(argList[n], XmNrepeatDelay, 250); n++;
XtSetArg(argList[n], XmNinitialDelay, 500); n++;
XtSetArg(argList[n], XmNarrowLayout, XmARROWS_SPLIT); n++;
spin4 = XmCreateSpinBox( parent,
"spin4",
argList,
n );
/***** Increment Y position for next SpinBox *****/
nextY += Y_OFFSET;
n = 0;
XtSetArg(argList[n], XmNmaximumValue, 4); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmNUMERIC); n++;
spin4_text = XmCreateTextField( spin4,
"spin4_text",
argList,
n );
/***** Manage SpinBox *****/
XtManageChild(spin4);
/***** Call modifySpin4 BEFORE displayed value is changed *****/
XtAddCallback(spin4, XmNmodifyVerifyCallback, modifySpin4, (XtPointer) 0);
/***** Manage SpinBox child *****/
XtManageChild(spin4_text);
/***** End of SpinBox spin4 *****/
/*****
***** Create SpinBox spin5
*****
***** Choices: 0 to 10 by 1
*****
***** Delay: Repeat delay is 0 - displayed value only increments
***** or decrements ONCE each time arrow is armed
*****
***** Callbacks: none
*****
*****/
/***** Create SpinBox parent *****/
n = 0;
XtSetArg(argList[n], XmNy, nextY); n++;
XtSetArg(argList[n], XmNarrowSize, 20); n++;
XtSetArg(argList[n], XmNrepeatDelay, 0); n++;
XtSetArg(argList[n], XmNarrowLayout, XmARROWS_BEGINNING); n++;
spin5 = XmCreateSpinBox( parent,
"spin5",
argList,
n );
/***** Increment Y position for next SpinBox *****/
nextY += Y_OFFSET;
n = 0;
XtSetArg(argList[n], XmNminimumValue, 1); n++;
XtSetArg(argList[n], XmNposition, 1); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmNUMERIC); n++;
XtSetArg(argList[n], XmNeditable, False); n++;
spin5_text = XmCreateTextField( spin5,
"spin5_text",
argList,
n );
/***** Manage SpinBox *****/
XtManageChild(spin5);
/***** Manage SpinBox child *****/
XtManageChild(spin5_text);
/***** End of SpinBox spin5 *****/
/*****
***** Create SpinBox spin6
*****
***** This example has multiple children, including two
***** decoration children. In addition, this SpinBox
***** includes 'chaining', the process where a change
***** in one child causes values to change in the child
***** and on or more other children. Chaining is performed
***** by the valueChanged callback.
*****
***** Choices: spin6_text1 1 to 12 (months)
***** spin6_deco1 '/' decoration
***** spin6_text2 1 to 28-31 (max days varies by month)
***** spin6_deco2 '/' decoration
***** spin6_text3 0 to 99 (years)
*****
***** Callbacks:
***** - changedSpin6 sets maximum days in month. The month field
***** is chained to the day field, and the year field is
***** chained to the month field. (When the day child
***** wraps, the month child is also changed. When the
***** month child wraps, the year child is also changed.)
*****
*****/
/***** Create SpinBox parent *****/
n = 0;
XtSetArg(argList[n], XmNy, nextY); n++;
XtSetArg(argList[n], XmNinitialDelay, 0); n++;
XtSetArg(argList[n], XmNrepeatDelay, 150); n++;
spin6 = XmCreateSpinBox( parent,
"spin6",
argList,
n );
/***** Increment Y position for next SpinBox *****/
nextY += Y_OFFSET;
/***** Create SpinBox child *****/
n = 0;
XtSetArg(argList[n], XmNwidth, 30); n++;
XtSetArg(argList[n], XmNposition, thisMM - 1); n++;
XtSetArg(argList[n], XmNminimumValue, 1); n++;
XtSetArg(argList[n], XmNmaximumValue, 12); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmNUMERIC); n++;
spin6_text1 = XmCreateTextField( spin6,
"spin6_text1",
argList,
n );
/***** Create SpinBox decoration child *****/
n = 0;
decoString = XmStringCreateLtoR("/", XmSTRING_DEFAULT_CHARSET);
XtSetArg(argList[n], XmNlabelString, decoString); n++;
spin6_deco1 = XmCreateLabel( spin6,
"spin6_deco1",
argList,
n );
/***** Create SpinBox child *****/
n = 0;
XtSetArg(argList[n], XmNwidth, 30); n++;
XtSetArg(argList[n], XmNposition, thisDD - 1); n++;
XtSetArg(argList[n], XmNminimumValue, 1); n++;
XtSetArg(argList[n], XmNmaximumValue, 31); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmNUMERIC); n++;
spin6_text2 = XmCreateTextField( spin6,
"spin6_text2",
argList,
n );
/***** Create SpinBox decoration child *****/
n = 0;
decoString = XmStringCreateLtoR("/", XmSTRING_DEFAULT_CHARSET);
XtSetArg(argList[n], XmNlabelString, decoString); n++;
spin6_deco2 = XmCreateLabel( spin6,
"spin6_deco2",
argList,
n );
XmStringFree(decoString);
/***** Create SpinBox child *****/
n = 0;
XtSetArg(argList[n], XmNwidth, 30); n++;
XtSetArg(argList[n], XmNposition, thisYY); n++;
XtSetArg(argList[n], XmNmaximumValue, 99); n++;
XtSetArg(argList[n], XmNspinBoxChildType, XmNUMERIC); n++;
spin6_text3 = XmCreateTextField( spin6,
"spin6_text3",
argList,
n );
/***** Manage SpinBox *****/
XtManageChild(spin6);
/***** Call changedSpin6 AFTER displayed value has changed *****/
XtAddCallback(spin6, XmNvalueChangedCallback, changedSpin6, (XtPointer) 0);
/***** Manage SpinBox children *****/
XtManageChild(spin6_text1);
XtManageChild(spin6_deco1);
XtManageChild(spin6_text2);
XtManageChild(spin6_deco2);
XtManageChild(spin6_text3);
/***** End of SpinBox spin6 *****/
}
