/* $XConsortium: sampler2_0.c /main/13 1995/07/15 20:46:01 drk $ */
/*
* Motif
*
* Copyright (c) 1987-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these librararies and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*
*/
/*
* HISTORY
*/
#include <stdlib.h>
#include <Xm/XmAll.h>
#include <Xmd/RegEdit.h>
#include <Xmd/AdjView.h>
#include <Xmd/Help.h>
/* need these semi public header during the construction of the
ContainerOutline class widget tree, as data, not as real widgets */
#include <Xm/SashP.h>
#include <Xm/TearOffBP.h>
#include <Xm/GrabShell.h>
#include <Xm/IconH.h>
#ifdef SAMPLER_DEBUG_SSPINB
#include <Xm/SpinBP.h>
#include <Xm/SSpinBP.h>
#endif
/* The notebook maintains its own data thru XmNuserData, which
points to a notebook data struct */
typedef struct
{
String page_name;
WidgetClass page_class ;
XtCallbackProc page_init_proc ;
} PageDataStruct;
typedef struct
{
Widget status;
Cardinal num_pages ;
PageDataStruct * pages ;
} NotebookDataStruct;
/**********************************************************************
the following is used in the ContainerOutline page, which displays
a tree of all the wigdet classes in Xt/Motif */
typedef struct _ClassInfoRec {
Boolean documented ; /* whether or not the class is documented */
WidgetClass w_class ;
} ClassInfoRec;
typedef struct _IconGInfoRec {
Cardinal parent_index ; /* entryParent resource */
ClassInfoRec class_info ;
} IconGInfoRec, * IconGInfo;
/*********** Following used to build the icong_array[] with the
widget class tree information *****************/
/* this one is not exported by Xt, mimic it static here */
static RectObjClassRec unNamedObjClassRec = {
{
/* superclass */ (WidgetClass)&rectObjClassRec,
/* class_name */ "UnNamedObj",
/* widget_size */ 0
}
};
static WidgetClass unNamedObjClass = (WidgetClass) &unNamedObjClassRec;
#define ClassName(wclass) ((WidgetClass)wclass)->core_class.class_name
#define MAX_CLASSES 100
static IconGInfo icong_array[MAX_CLASSES] ;
/*** my own little stack manager: push and pop */
#define MAX_DEPTH 10
static Cardinal stack_index[MAX_DEPTH] ;
static Cardinal stack_heap = 0 ;
#define PushIndex(i) (stack_index[stack_heap++] = i)
#define PopIndex() (stack_index[--stack_heap])
#define SSB_NUMERIC 0
#define SSB_STRING 1
#define NUM_SSB_WIDGETS 2
static Widget ssb_widgets[NUM_SSB_WIDGETS];
/** each page has an Init routine which is called the first
time a page is raised. It delays the real page creation somehow */
static PageDataStruct * NewPageSet (Cardinal *num_page_return);
static void NbCB (Widget w, XtPointer client_data, XtPointer call_data);
static void DestroyCB (Widget w, XtPointer client_data, XtPointer call_data);
static void QuitCB (Widget w, XtPointer client_data, XtPointer call_data);
static void HelpCB (Widget w, XtPointer client_data, XtPointer call_data);
static Widget CreateMainWindowWithMenuBar (Widget toplevel);
static void ContainerExpose (Widget wid, XtPointer closure,
XEvent *event, Boolean *cont);
static void InitContainerSpatial(Widget w, XtPointer client_data,
XtPointer call_data);
static void TravCB (Widget w, XtPointer client_data, XtPointer call_data);
static void InitContainerOutline(Widget w, XtPointer client_data,
XtPointer call_data);
static void OKCB (Widget w, XtPointer client_data, XtPointer call_data);
static void InitPanedWindow(Widget w, XtPointer client_data,
XtPointer call_data);
static void InitFileSelectionBox(Widget w, XtPointer client_data,
XtPointer call_data);
static void InitTogglesWindow(Widget w, XtPointer client_data,
XtPointer call_data);
static void InitScaleCombo(Widget w, XtPointer client_data,
XtPointer call_data);
static void SetDyn(WidgetClass wclass, Cardinal index, Boolean documented);
static Cardinal InitClassArray (void);
static void sb_ModifyVerifyCB(Widget w, XtPointer client_data,
XtPointer call_data);
static void sb_ValueChangedCB(Widget w, XtPointer client_data,
XtPointer call_data);
static void tf_ActivateCB(Widget w, XtPointer client_data,
XtPointer call_data);
static void sb_ApplyCB(Widget w, XtPointer client_data,
XtPointer call_data);
static void sb_CancelCB(Widget w, XtPointer client_data,
XtPointer call_data);
static void sb_OkCB(Widget w, XtPointer client_data,
XtPointer call_data);
static Widget ssb_GetTextField(Widget w);
#define APP_CLASS "XmdSampler2_0"
static Widget toplevel ; /* used in OKCB for set its size */
/*
* Fallbacks: keep it minimum
*/
static String fallbacks[] = {
"*help_manager.helpFile: sampler2_0",
"*XmIconGadget.outlineState: XmEXPANDED",
"*SWContainerOutline.scrollingPolicy:XmAUTOMATIC",
"*ContainerOutline.layoutType:outline",
NULL
};
/***********************************************/
/***********************************************/
int main(int argc, char *argv[])
{
XtAppContext app_context;
int i ;
Widget mainw, nb ;
NotebookDataStruct nb_data ;
XmNotebookCallbackStruct nb_call_data ;
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app_context, APP_CLASS, NULL, 0,
&argc, argv, fallbacks, NULL);
/** Plug in Editres protocol */
XmdRegisterEditres(toplevel);
/*** create utility widgets */
mainw = CreateMainWindowWithMenuBar(toplevel);
XtManageChild(mainw);
/* allocate new pages struct */
nb_data.pages = NewPageSet (&nb_data.num_pages) ;
nb = XtVaCreateManagedWidget("nb", xmNotebookWidgetClass, mainw,
XmNuserData, &nb_data, NULL);
XtAddCallback (nb, XmNpageChangedCallback, NbCB, NULL);
XtAddCallback (nb, XmNdestroyCallback, DestroyCB, NULL);
/*** create page and tab buttons, one per page */
for (i=0; i< nb_data.num_pages; i++) {
char tab_name[100] ;
sprintf(tab_name, "TabTo%s", nb_data.pages[i].page_name);
(void) XtVaCreateManagedWidget(nb_data.pages[i].page_name,
nb_data.pages[i].page_class,
nb,
NULL);
(void) XtVaCreateManagedWidget(tab_name, xmPushButtonWidgetClass,
nb, NULL);
}
/*** create only one status area */
nb_data.status = XtVaCreateManagedWidget("Status", xmLabelWidgetClass, nb,
XmNpageNumber, 1, NULL);
XtRealizeWidget(toplevel);
XtAppMainLoop(app_context);
return (0);
}
/* I wish C could initialized that statically, but it can't */
static
PageDataStruct * NewPageSet (Cardinal *num_page_return)
{
Cardinal n;
PageDataStruct * pages;
#define NUM_PAGES 7
pages = (PageDataStruct *) XtMalloc(NUM_PAGES * sizeof(PageDataStruct));
n = 0;
pages[n].page_name = "ContainerSpatial";
pages[n].page_init_proc = InitContainerSpatial;
pages[n].page_class = xmContainerWidgetClass; n++;
pages[n].page_name = "SWContainerOutline";
pages[n].page_init_proc = InitContainerOutline;
pages[n].page_class = xmScrolledWindowWidgetClass; n++;
pages[n].page_name = "PanedWindow";
pages[n].page_init_proc = InitPanedWindow;
pages[n].page_class = xmPanedWindowWidgetClass; n++;
pages[n].page_name = "FileSelectionBox";
pages[n].page_init_proc = InitFileSelectionBox;
pages[n].page_class = xmFrameWidgetClass; n++;
pages[n].page_name = "TogglesWindow";
pages[n].page_init_proc = InitTogglesWindow;
pages[n].page_class = xmScrolledWindowWidgetClass; n++;
pages[n].page_name = "ScaleCombo";
pages[n].page_init_proc = InitScaleCombo;
pages[n].page_class = xmFormWidgetClass; n++;
*num_page_return = n ;
return pages ;
}
/**********************************************
* NbCB - callback for Notebook
* Update the status label. and init the page if not yet done
*/
static void
NbCB (Widget w, XtPointer client_data, XtPointer call_data)
{
XmNotebookCallbackStruct * nbcs =
(XmNotebookCallbackStruct *) call_data ;
NotebookDataStruct * nb_data ;
/* get the data for this notebook from the notebook */
XtVaGetValues(w, XmNuserData, &nb_data, NULL);
/* set the status label to the widget I'm showing now, plus
its page number */
XtVaSetValues(nb_data->status,
XtVaTypedArg, XmNlabelString, XtRString,
nb_data->pages[nbcs->page_number - 1].page_name,
strlen(nb_data->pages[nbcs->page_number - 1].page_name)+1,
XmNpageNumber, nbcs->page_number, NULL);
/* here I use page_class as a flag to check if the page
has been initialized. page_class is the field that stores the
class of the widget in the page, it is not NULL the first time
thru and I set it NULL here cause I won't be using it again */
if (nb_data->pages[nbcs->page_number - 1].page_class) {
(* nb_data->pages[nbcs->page_number - 1].page_init_proc)
(nbcs->page_widget, NULL, NULL) ;
nb_data->pages[nbcs->page_number - 1].page_class = NULL ;
}
}
/**********************************************
* DestroyCB - callback when Notebook dies
* Free the data associated with this Notebook.
*/
static void
DestroyCB (Widget w, XtPointer client_data, XtPointer call_data)
{
NotebookDataStruct * nb_data ;
/* get the data for this notebook from the notebook */
XtVaGetValues(w, XmNuserData, &nb_data, NULL);
XtFree((char*) nb_data->pages);
/* nbdata itself comes from the stack in this program */
}
static void
QuitCB (Widget w, XtPointer client_data, XtPointer call_data)
{
exit (0);
}
static void
HelpCB (Widget w, XtPointer client_data, XtPointer call_data)
{
static Widget help_widget = NULL ;
if (!help_widget)
help_widget = XmdCreateHelpDialog(toplevel, "help_manager", NULL, 0);
XtManageChild(help_widget);
}
static Widget
CreateMainWindowWithMenuBar(Widget toplevel)
{
Widget main_window, menu_bar, menu_pane, cascade, button ;
Arg args[20];
Cardinal n;
/* Create MainWindow.
*/
n = 0;
main_window = XmCreateMainWindow (toplevel, "main_window", args, n);
XtManageChild (main_window);
/* Create MenuBar in MainWindow.
*/
n = 0;
menu_bar = XmCreateMenuBar (main_window, "menu_bar", args, n);
XtManageChild (menu_bar);
/* Create "File" PulldownMenu.
*/
n = 0;
menu_pane = XmCreatePulldownMenu (menu_bar, "menu_pane", args, n);
n = 0;
button = XmCreatePushButton (menu_pane, "Exit", args, n);
XtManageChild (button);
XtAddCallback (button, XmNactivateCallback, QuitCB, NULL);
n = 0;
XtSetArg (args[n], XmNsubMenuId, menu_pane); n++;
cascade = XmCreateCascadeButton (menu_bar, "File", args, n);
XtManageChild (cascade);
/* Create "Help" PulldownMenu.
*/
n = 0;
menu_pane = XmCreatePulldownMenu (menu_bar, "menu_pane3", args, n);
n = 0;
button = XmCreatePushButton (menu_pane, "Overview", args, n);
XtManageChild (button);
XtAddCallback (button, XmNactivateCallback, HelpCB, NULL);
n = 0;
XtSetArg (args[n], XmNsubMenuId, menu_pane); n++;
cascade = XmCreateCascadeButton (menu_bar, "Help", args, n);
XtManageChild (cascade);
n = 0;
XtSetArg (args[n], XmNmenuHelpWidget, cascade); n++;
XtSetValues (menu_bar, args, n);
return main_window ;
}
static void
ContainerExpose(
Widget wid,
XtPointer closure, /* unused */
XEvent *event,
Boolean *cont ) /* unused */
{
/* Turn the spatial container to NONE after it is realized */
XtVaSetValues (wid, XmNspatialStyle, XmNONE, NULL);
}
static void
InitContainerSpatial (Widget w, XtPointer client_data, XtPointer call_data)
{
Cardinal i ;
#define NUM_ICONS 10
Widget icons[NUM_ICONS ] ;
for (i=0; i<NUM_ICONS ; i++) {
char icon_name[20] ;
sprintf(icon_name, "IconGadget%d", i);
icons[i] = XtVaCreateWidget(icon_name, xmIconGadgetClass,
w, NULL);
}
XtManageChildren(icons, i);
/* add a handler to turn teh Container to NONE once it is all set */
XtAddEventHandler (w, ExposureMask, False, ContainerExpose, NULL);
}
static void
TravCB (Widget w, XtPointer client_data, XtPointer call_data)
{
XmTraverseObscuredCallbackStruct * tocs =
(XmTraverseObscuredCallbackStruct *) call_data ;
XmScrollVisible(w, tocs->traversal_destination, 20, 20) ;
}
static void
InitContainerOutline (Widget w, XtPointer client_data, XtPointer call_data)
{
Widget container, *icongs;
Cardinal i ;
/* get the number of classes in Xt/Motif */
i = InitClassArray() ;
/* allocate space for the array of icongadgets to be managed
at once */
icongs = (Widget*) XtMalloc(i * sizeof(Widget));
XtAddCallback (w, XmNtraverseObscuredCallback, TravCB, NULL);
/* create the container */
container = XtVaCreateManagedWidget("ContainerOutline",
xmContainerWidgetClass, w,
NULL);
/* setup our clipwindow/workwindow constraint stuff */
XmdSWAdjustView (w) ;
/* create the root */
icongs[0] = XtVaCreateWidget(
ClassName(icong_array[0]->class_info.w_class),
xmIconGadgetClass, container,
XmNentryParent, NULL,
XmNsensitive,
icong_array[0]->class_info.documented,
XmNuserData,
&(icong_array[0]->class_info),
NULL);
i = 1 ;
while (icong_array[i]) {
/* parent_index has been set during InitClassArray */
icongs[i] = XtVaCreateWidget(
ClassName(icong_array[i]->class_info.w_class),
xmIconGadgetClass, container,
XmNentryParent,
icongs[icong_array[i]->parent_index],
XmNsensitive,
icong_array[i]->class_info.documented,
XmNuserData,
&(icong_array[i]->class_info),
NULL);
i++ ;
}
XtManageChildren(icongs, i);
}
static void
OKCB (Widget w, XtPointer client_data, XtPointer call_data)
{
String input_string ;
int size_in_pixel ;
String colon_location ;
String resource_name ;
XtEnum orientation ;
/* get back something ala "width: 20cm" */
input_string = XmTextFieldGetString((Widget)client_data);
/* find the ':' */
colon_location = strchr(input_string, ':');
/* cut the input_string in two by ending it at color_location,
the other piece being at colon_location+1 */
if (colon_location) *colon_location = '\0';
else {
XtFree(input_string);
return ;
}
/* now try to figure out the dimension being set */
if (strstr(input_string, "width")) {
orientation = XmHORIZONTAL ;
resource_name = XmNwidth ;
} else
if (strstr(input_string, "height")) {
orientation = XmVERTICAL ;
resource_name = XmNheight ;
} else {
XtFree(input_string);
return ;
}
size_in_pixel = XmConvertStringToUnits(XtScreen(w), colon_location+1,
orientation, XmPIXELS, NULL) ;
if (size_in_pixel)
XtVaSetValues(toplevel, resource_name, size_in_pixel, NULL);
XtFree(input_string);
}
static void
InitPanedWindow (Widget w, XtPointer client_data, XtPointer call_data)
{
Widget child_w[2], sub_pane, temp, form, frame;
child_w[0] = XtVaCreateWidget("Arrow1", xmArrowButtonWidgetClass,
w, NULL);
sub_pane = child_w[1] = XtVaCreateWidget("SubPane",
xmPanedWindowWidgetClass,
w, NULL);
XtManageChildren(child_w, 2);
child_w[0] = XtVaCreateWidget("Arrow2", xmArrowButtonWidgetClass,
sub_pane, NULL);
temp = child_w[1] = XtVaCreateWidget("Temp", xmMessageBoxWidgetClass,
sub_pane, NULL);
XtRealizeWidget(temp);
XtManageChildren(child_w, 2);
form = XtVaCreateManagedWidget("Form", xmFormWidgetClass,
temp, NULL);
frame = child_w[0] = XtVaCreateWidget("Frame", xmFrameWidgetClass,
form, NULL);
child_w[1] = XtVaCreateWidget("TextF", xmTextFieldWidgetClass,
form, NULL);
XtManageChildren(child_w, 2);
XtAddCallback (temp, XmNokCallback, OKCB, (XtPointer)child_w[1]);
child_w[0] = XtVaCreateWidget("Title", xmLabelGadgetClass,
frame, NULL);
child_w[1] = XtVaCreateWidget("Label", xmLabelWidgetClass,
frame, NULL);
XtManageChildren(child_w, 2);
}
static void
InitFileSelectionBox (Widget w, XtPointer client_data, XtPointer call_data)
{
XtVaCreateManagedWidget("FileSelectionBox",
xmFileSelectionBoxWidgetClass,
w, NULL);
}
static void
InitTogglesWindow (Widget w, XtPointer client_data, XtPointer call_data)
{
Cardinal i ;
#define NUM_TOG 50
Widget work_area, toggles[NUM_TOG] ;
work_area = XtVaCreateManagedWidget("RowColumn", xmRowColumnWidgetClass,
w, NULL);
for (i=0; i<NUM_TOG; i++) {
char child_name[20] ;
sprintf(child_name, "RCChild%d", i);
toggles[i] = XtVaCreateWidget(child_name, xmToggleButtonWidgetClass,
work_area, NULL);
}
XtManageChildren(toggles, i);
}
static void
InitScaleCombo (Widget w, XtPointer client_data, XtPointer call_data)
{
Arg args[1];
Widget applyb, cbb, scale, selectb;
Widget spinb, sspinb_s, sspinb_n, textual;
XtCallbackRec sbModifyVerifyList[] = {
{sb_ModifyVerifyCB, (caddr_t) NULL},
{(XtCallbackProc) NULL, (caddr_t) NULL}
};
XtCallbackRec sbValueChangedList[] = {
{sb_ValueChangedCB, (caddr_t) NULL},
{(XtCallbackProc) NULL, (caddr_t) NULL}
};
XtCallbackRec tfActivateList[] = {
{tf_ActivateCB, (caddr_t) NULL},
{(XtCallbackProc) NULL, (caddr_t) NULL}
};
XtCallbackRec sbApplyList[] = {
{sb_ApplyCB, (caddr_t) NULL},
{(XtCallbackProc) NULL, (caddr_t) NULL}
};
XtCallbackRec sbCancelList[] = {
{sb_CancelCB, (caddr_t) NULL},
{(XtCallbackProc) NULL, (caddr_t) NULL}
};
XtCallbackRec sbOkList[] = {
{sb_OkCB, (caddr_t) NULL},
{(XtCallbackProc) NULL, (caddr_t) NULL}
};
cbb = XtVaCreateWidget("ComboBox", xmComboBoxWidgetClass, w, NULL);
XtRealizeWidget(cbb);
XtManageChild(cbb);
spinb = XtVaCreateWidget("SpinBox", xmSpinBoxWidgetClass, w,
XmNmodifyVerifyCallback, sbModifyVerifyList,
XmNvalueChangedCallback, sbValueChangedList,
NULL);
XtRealizeWidget(spinb);
XtManageChild(spinb);
XtVaCreateManagedWidget("Date", xmTextFieldWidgetClass, spinb,
XmNactivateCallback, tfActivateList,
NULL);
XtVaCreateManagedWidget("Month", xmTextFieldWidgetClass, spinb,
XmNactivateCallback, tfActivateList,
NULL);
XtVaCreateManagedWidget("Year", xmTextFieldWidgetClass, spinb,
XmNactivateCallback, tfActivateList,
NULL);
sspinb_n = XtVaCreateWidget(
"SimpleSpinBoxNumeric", xmSimpleSpinBoxWidgetClass, w,
XmNmodifyVerifyCallback, sbModifyVerifyList,
XmNvalueChangedCallback, sbValueChangedList,
NULL);
textual = ssb_GetTextField(sspinb_n);
XtSetArg(args[0], XmNactivateCallback, tfActivateList);
XtSetValues(textual, args, 1);
XtRealizeWidget(sspinb_n);
XtManageChild(sspinb_n);
sspinb_s = XtVaCreateWidget(
"SimpleSpinBoxString", xmSimpleSpinBoxWidgetClass, w,
XmNmodifyVerifyCallback, sbModifyVerifyList,
XmNvalueChangedCallback, sbValueChangedList,
NULL);
textual = ssb_GetTextField(sspinb_s);
XtSetArg(args[0], XmNactivateCallback, tfActivateList);
XtSetValues(textual, args, 1);
XtRealizeWidget(sspinb_s);
XtManageChild(sspinb_s);
#ifdef SAMPLER_TEST_SSPINB
XtVaSetValues(sspinb_n, XmNtextField, sspinb_s, NULL);
XtVaSetValues(sspinb_n, XmNpositionType, XmPOSITION_INDEX, NULL);
XtVaSetValues(spinb, XmNpositionType, XmPOSITION_INDEX, NULL);
#endif
#ifdef SAMPLER_TEST_SSPINB
ssb_widgets[SSB_NUMERIC] = sspinb_n;
ssb_widgets[SSB_STRING] = sspinb_s;
sbApplyList[0].closure = (caddr_t) ssb_widgets;
sbCancelList[0].closure = (caddr_t) ssb_widgets;
sbOkList[0].closure = (caddr_t) ssb_widgets;
selectb = XtVaCreateWidget(
"SelectionBoxDebug", xmSelectionBoxWidgetClass, w,
XmNapplyCallback, sbApplyList,
XmNcancelCallback, sbCancelList,
XmNokCallback, sbOkList,
XmNdialogType, XmDIALOG_PROMPT,
XmNmustMatch, False,
NULL);
XtRealizeWidget(selectb);
XtManageChild(selectb);
applyb = XmSelectionBoxGetChild(selectb, XmDIALOG_APPLY_BUTTON);
XtManageChild(applyb);
#endif
scale = XtVaCreateWidget("Scale", xmScaleWidgetClass, w, NULL);
XtRealizeWidget(scale);
XtManageChild(scale);
XmScaleSetTicks(scale,
10, 1, 4,
20, 10, 5);
}
/* Now comes the stuff that describe the Xt/Xm class hierarchy */
static void
SetDyn(WidgetClass wclass, Cardinal index, Boolean documented)
{
static Cardinal i = 0 ;
icong_array[i] = (IconGInfo) XtMalloc(sizeof(IconGInfoRec));
icong_array[i]->parent_index = index ;
icong_array[i]->class_info.w_class = wclass ;
icong_array[i]->class_info.documented = documented ;
i++ ;
}
static Cardinal
InitClassArray (void)
{
/* This code builds the Xt/Motif widget class tree using
a breadth first search algorithm */
Cardinal n = 0;
int index = -1;
SetDyn(objectClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmDragIconObjectClass, index, True); n++;
SetDyn(xmDropTransferObjectClass, index, True); n++;
SetDyn(xmDropSiteManagerObjectClass, index, False); n++;
SetDyn(rectObjClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(unNamedObjClass, index, False); PushIndex(n); n++;
SetDyn(xmGadgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmArrowButtonGadgetClass, index, True); n++;
SetDyn(xmSeparatorGadgetClass, index, True); n++;
SetDyn(xmLabelGadgetClass, index, True); PushIndex(n); n++;
SetDyn(xmIconGadgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmIconHeaderClass, index, False); n++;
index = PopIndex () ;
SetDyn(xmPushButtonGadgetClass, index, True); n++;
SetDyn(xmToggleButtonGadgetClass, index, True); n++;
SetDyn(xmCascadeButtonGadgetClass, index, True); n++;
index = PopIndex () ;
SetDyn(coreWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(compositeWidgetClass, index, True); PushIndex(n); n++;
SetDyn(xmScreenClass, index, True); n++;
SetDyn(xmDragContextClass, index, True); n++;
SetDyn(xmPrimitiveWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmScrollBarWidgetClass, index, True); n++;
SetDyn(xmArrowButtonWidgetClass, index, True); n++;
SetDyn(xmListWidgetClass, index, True); n++;
SetDyn(xmSeparatorWidgetClass, index, True); n++;
SetDyn(xmTextFieldWidgetClass, index, True); n++;
SetDyn(xmDrawnButtonWidgetClass, index, True); n++;
SetDyn(xmTextWidgetClass, index, True); n++;
SetDyn(xmSashWidgetClass, index, False); n++;
SetDyn(xmLabelWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmToggleButtonWidgetClass, index, True); n++;
SetDyn(xmCascadeButtonWidgetClass, index, True); n++;
SetDyn(xmPushButtonWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmTearOffButtonWidgetClass, index, False); n++;
index = PopIndex () ;
SetDyn(constraintWidgetClass, index, True); PushIndex(n); n++;
SetDyn(shellWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(wmShellWidgetClass, index, True); PushIndex(n); n++;
SetDyn(overrideShellWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmMenuShellWidgetClass, index, True); n++;
index = PopIndex () ;
SetDyn(vendorShellWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmGrabShellWidgetClass, index, False); n++;
SetDyn(xmDragOverShellWidgetClass, index, False); n++;
SetDyn(transientShellWidgetClass, index, True); PushIndex(n); n++;
SetDyn(topLevelShellWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(applicationShellWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmDisplayClass, index, True); n++;
index = PopIndex () ;
SetDyn(xmDialogShellWidgetClass, index, True); n++;
index = PopIndex () ;
SetDyn(xmManagerWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmDrawingAreaWidgetClass, index, True); n++;
SetDyn(xmFrameWidgetClass, index, True); n++;
SetDyn(xmRowColumnWidgetClass, index, True); n++;
SetDyn(xmPanedWindowWidgetClass, index, True); n++;
SetDyn(xmScaleWidgetClass, index, True); n++;
SetDyn(xmComboBoxWidgetClass, index, True); n++;
SetDyn(xmContainerWidgetClass, index, True); n++;
SetDyn(xmNotebookWidgetClass, index, True); n++;
SetDyn(xmSpinBoxWidgetClass, index, True); n++;
SetDyn(xmScrolledWindowWidgetClass, index, True); PushIndex(n); n++;
SetDyn(xmBulletinBoardWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmFormWidgetClass, index, True); n++;
SetDyn(xmMessageBoxWidgetClass, index, True); n++;
SetDyn(xmSelectionBoxWidgetClass, index, True); PushIndex(n); n++;
index = PopIndex () ;
SetDyn(xmFileSelectionBoxWidgetClass, index, True); n++;
SetDyn(xmCommandWidgetClass, index, True); n++;
index = PopIndex () ;
SetDyn(xmMainWindowWidgetClass, index, True); n++;
return n ;
}
/* ARGSUSED */
static void
sb_ModifyVerifyCB(Widget w, XtPointer client_data, XtPointer call_data)
{
char *buffer;
XmSpinBoxCallbackStruct *cbs = (XmSpinBoxCallbackStruct *) call_data;
int position = cbs->position;
Widget textual = (Widget) NULL;
if (XtIsSubclass(w, xmSimpleSpinBoxWidgetClass))
textual = ssb_GetTextField(w);
else if (XtIsSubclass(w, xmSpinBoxWidgetClass))
textual = cbs->widget;
else
textual = (Widget) NULL;
if (! textual)
{
printf("Null textual widget for %s\n", XtName(w));
return;
}
#ifdef SAMPLER_TEST_SSPINB
if (XmStringGetLtoR(cbs->value, XmFONTLIST_DEFAULT_TAG, &buffer))
printf("ModifyVerify value for %s.%s is %s\n",
XtName(w), XtName(textual), buffer);
#endif
}
/* ARGSUSED */
static void
sb_ValueChangedCB(Widget w, XtPointer client_data, XtPointer call_data)
{
char *buffer;
XmSpinBoxCallbackStruct *cbs = (XmSpinBoxCallbackStruct *) call_data;
int position = cbs->position;
Widget textual = (Widget) NULL;
if (XtIsSubclass(w, xmSimpleSpinBoxWidgetClass))
textual = ssb_GetTextField(w);
else if (XtIsSubclass(w, xmSpinBoxWidgetClass))
textual = cbs->widget;
else
textual = (Widget) NULL;
if (! textual) {
printf("Null textual widget for %s\n", XtName(w));
return;
}
#ifdef SAMPLER_TEST_SSPINB
if (XmStringGetLtoR(cbs->value, XmFONTLIST_DEFAULT_TAG, &buffer))
printf("ValueChanged value for %s.%s is %s\n",
XtName(w), XtName(textual), buffer);
#endif
}
/* ARGSUSED */
static void
tf_ActivateCB(Widget w, XtPointer client_data, XtPointer call_data)
{
Arg args[1];
int position, minimum;
Widget textual = (Widget) w;
if (XmSpinBoxValidatePosition (textual, &position) == XmCURRENT_VALUE)
XBell(XtDisplay(w), 0);
/*
* Force the widget to redraw itself.
*/
XtSetArg(args[0], XmNposition, position);
XtSetValues(textual, args, 1);
}
/* ARGSUSED */
/* ARGSUSED */
static void
sb_ApplyCB(Widget w, XtPointer client_data, XtPointer call_data)
{
/*
Widget *ssb_widgets = (Widget *) client_data;
*/
XmString xmstring;
int pos;
Arg args[1];
/* Apply adds a new string to the sspinb_s widget */
XtSetArg(args[0], XmNtextString, &xmstring);
XtGetValues(w, args, 1);
XtSetArg(args[0], XmNposition, &pos);
XtGetValues(ssb_widgets[SSB_NUMERIC], args, 1);
XmSimpleSpinBoxAddItem(ssb_widgets[SSB_STRING], xmstring, pos);
}
static void
sb_CancelCB(Widget w, XtPointer client_data, XtPointer call_data)
{
/*
Widget *ssb_widgets = (Widget *) client_data;
*/
int pos;
Arg args[1];
/* Cancel deletes a string from the sspinb_s widget */
XtSetArg(args[0], XmNposition, &pos);
XtGetValues(ssb_widgets[SSB_NUMERIC], args, 1);
XmSimpleSpinBoxDeletePos(ssb_widgets[SSB_STRING], pos);
}
/* ARGSUSED */
static void
sb_OkCB(Widget w, XtPointer client_data, XtPointer call_data)
{
/*
Widget *ssb_widgets = (Widget *) client_data;
*/
XmString xmstring;
Arg args[1];
/* OK sets position of sspinb_s to the specified string. */
XtSetArg(args[0], XmNtextString, &xmstring);
XtGetValues(w, args, 1);
XmSimpleSpinBoxSetItem(ssb_widgets[SSB_STRING], xmstring);
}
/* ARGSUSED */
static Widget
ssb_GetTextField(Widget w)
{
Arg args[1];
Widget textual = (Widget) NULL;
XtSetArg(args[0], XmNtextField, &textual);
XtGetValues(w, args, 1);
return(textual);
}