void make_toggle(QSP_ARG_DECL Screen_Obj *sop)
{
#ifdef HAVE_MOTIF
Arg al[10];
int ac = 0;
/* set geometry and placement */
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopOffset, curr_panel->po_curry); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, curr_panel->po_currx); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
sop->so_obj = XmCreateToggleButton(curr_panel->po_panel_obj,
(char *)sop->so_name, al, ac);
/* Save object position */
sop->so_x = curr_panel->po_currx;
sop->so_y = curr_panel->po_curry;
/* add callback function */
/*XtAddCallback(sop->so_obj, XmNactivateCallback, toggle_func, NULL); */
XtAddCallback(sop->so_obj, XmNvalueChangedCallback, toggle_func, NULL);
/* manage the child */
XtManageChild(sop->so_obj);
#endif /* HAVE_MOTIF */
}
void
lesstif_insert_style_buttons (Widget menu)
{
StyleButtons *sb;
int s, i;
num_style_buttons++;
s = num_style_buttons * sizeof (StyleButtons);
style_button_list = (StyleButtons *) realloc (style_button_list, s);
sb = style_button_list + num_style_buttons - 1;
for (i = 0; i < NUM_STYLES; i++)
{
Widget btn;
n = 0;
stdarg (XmNindicatorType, XmONE_OF_MANY);
stdarg (XmNlabelString,
XmStringCreatePCB (PCB->RouteStyle[i].Name));
btn = XmCreateToggleButton (menu, "style", args, n);
XtManageChild (btn);
XtAddCallback (btn, XmNvalueChangedCallback,
(XtCallbackProc) style_selected, (XtPointer) (size_t) i);
sb->w[i] = btn;
}
update_style_buttons ();
}
int
main(int argc, char **argv)
{
XtAppContext appc;
Widget top, rc, t1, t2, t3;
top = XtAppInitialize(&appc, "test", NULL, 0, &argc, argv, NULL, NULL, 0);
argcount = 0;
XtSetArg(args[argcount], XmNradioBehavior, True); argcount++;
rc = XmCreateRowColumn(top, "rowc", args, argcount);
XtManageChild(rc);
argcount = 0;
t1 = XmCreateToggleButton(rc, "t_b_1", args, argcount);
XtManageChild(t1);
argcount = 0;
t2 = XmCreateToggleButton(rc, "Toggle_button_2", args, argcount);
XtManageChild(t2);
argcount = 0;
t3 = XmCreateToggleButton(rc, "Third_toggle_button", args, argcount);
XtManageChild(t3);
XtAddCallback(t1, XmNvalueChangedCallback, VC, NULL);
XtAddCallback(t2, XmNvalueChangedCallback, VC, NULL);
XtAddCallback(t3, XmNvalueChangedCallback, VC, NULL);
XtRealizeWidget(top);
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight, 0, 0, 145, 87, 0,0,0,
CWWidth | CWHeight | CWX | CWY, 3, 3, 139, 25, 0,0,0,
CWWidth | CWHeight | CWX | CWY, 3, 31, 139, 25, 0,0,0,
CWWidth | CWHeight | CWX | CWY, 3, 59, 139, 25, 0,0,0,
};
PrintDetails(top, Expected);
}
LessTifTestMainLoop(top);
/*
XtAppMainLoop(appc);
*/
exit(0);
}
static void loadCallback(CALLBACK_ARGS)
{
static Widget fsd = NULL;
if (!fsd) {
fsd = XmCreateFileSelectionDialog(cmd, "loadFSD", NULL, 0);
XtAddCallback(fsd, XmNokCallback, loadOkCallback, fsd);
XtManageChild(XmCreateToggleButton(fsd, "load_syms", NULL, 0));
}
XtManageChild(fsd);
}
APP_WIDGET appSetToggleMenuItem( APP_WIDGET menu,
AppToplevel * at,
AppMenuItem * ami,
void * target )
{
Widget rval;
XmString labelString;
XmString acceleratorString= (XmString)0;
Arg al[20];
int ac= 0;
labelString= XmStringCreateLocalized( ami->amiItemText );
XtSetArg( al[ac], XmNlabelString, labelString ); ac++;
XtSetArg( al[ac], XmNvisibleWhenOff, True ); ac++;
XtSetArg( al[ac], XmNuserData, target ); ac++;
if ( ami->amiItemType == ITEMtyTOGGLE_ON )
{
# if XmVersion >= 2000
XtSetArg( al[ac], XmNset, XmSET ); ac++;
# else
XtSetArg( al[ac], XmNset, True ); ac++;
# endif
}
if ( ami->amiKey )
{ XtSetArg( al[ac], XmNaccelerator, ami->amiKey ); ac++; }
if ( ami->amiKeyText )
{
acceleratorString=
XmStringCreateLocalized( ami->amiKeyText );
XtSetArg( al[ac], XmNacceleratorText, acceleratorString ); ac++;
}
XtSetArg( al[ac], XmNmarginHeight, 1 ); ac++;
rval= XmCreateToggleButton( menu, WIDGET_NAME, al, ac );
XmStringFree( labelString );
if ( acceleratorString )
{ XmStringFree( acceleratorString ); }
XtAddCallback( rval, XmNvalueChangedCallback, ami->amiCallback, target );
XtManageChild( rval );
return rval;
}
ToggleButton::ToggleButton(std::string name, PulldownMenu* pulldownMenu)
{
Arg args[2];
XtSetArg(args[0], XmNindicatorOn, false);
XtSetArg(args[1], XmNfillOnSelect, true);
widget = XmCreateToggleButton(pulldownMenu->getWidget(), (char*)name.c_str(), args, 2);
XtAddCallback(widget, XmNvalueChangedCallback, valueChangedCallback, this);
XtAddCallback(widget, XmNarmCallback, armCallback, this);
XtAddCallback(widget, XmNdisarmCallback, disarmCallback, this);
XtManageChild(widget);
}
//a radio button to specify whether
//to use a reference part or not
void InvPartEditor::createReferenceButtons(Widget parent)
{
Arg args[5];
//Now the togglebutton and textfield for the reference part
XtSetArg(args[0], XmNorientation, XmVERTICAL);
Widget referencePartSelection = XtCreateManagedWidget("parent", xmRowColumnWidgetClass, parent, args, 1);
Widget useReference = XmCreateToggleButton(referencePartSelection, (char *)"Use reference Part", NULL, 0);
XtAddCallback(useReference, XmNvalueChangedCallback, useReferenceCB, (XtPointer) this);
useReferenceButtons(this, false);
XtManageChild(useReference);
Widget referencedPartName = XmCreateTextField(referencePartSelection, (char *)"referencedPartname", NULL, 0);
XtAddCallback(referencedPartName, XmNactivateCallback, referencePartNameCB, (XtPointer) this);
XtManageChild(referencedPartName);
}
void InvPartEditor::createPartsButtons(Widget parent)
{
Arg args[5];
XtSetArg(args[0], XmNorientation, XmHORIZONTAL);
Widget cols = XtCreateManagedWidget("cols", xmRowColumnWidgetClass, parent, args, 1);
XtSetArg(args[0], XmNorientation, XmVERTICAL);
Widget buttons1 = XtCreateManagedWidget("buttons1", xmRowColumnWidgetClass, cols, args, 1);
XtSetArg(args[1], XmNradioBehavior, True);
Widget buttons2 = XtCreateManagedWidget("buttons2", xmRowColumnWidgetClass, cols, args, 2);
// create the lists of radio/togglebuttons
int i = 0;
for (i = 0; i < numberOfParts_; i++)
{
char buf[4096];
strcpy(buf, parts_[i].name_);
strcat(buf, " ");
parts_[i].visible_ = XmCreateToggleButton(buttons1, buf, NULL, 0);
parts_[i].referenced_ = XmCreateToggleButton(buttons2, (char *)" ", NULL, 0);
XtManageChild(parts_[i].visible_);
XtManageChild(parts_[i].referenced_);
XtAddCallback(parts_[i].referenced_, XmNvalueChangedCallback, toggleCB, (XtPointer) this);
XtAddCallback(parts_[i].visible_, XmNvalueChangedCallback, toggleCB, (XtPointer) this);
}
}
static Widget CreateToggle(char *label, Widget parent)
{
Widget widget;
register int n;
Arg args[MAX_ARGS];
XmString tcs;
n = 0;
tcs = XmStringLtoRCreate(label, XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, tcs); n++;
widget = XmCreateToggleButton(parent, label, args, n);
XtManageChild(widget);
XmStringFree(tcs);
return(widget);
}
static Widget
style_button (int i)
{
Widget pb, set;
n = 0;
stdarg (XmNtopAttachment, XmATTACH_WIDGET);
stdarg (XmNtopWidget, i ? style_pb[i - 1] : value_form);
stdarg (XmNleftAttachment, XmATTACH_FORM);
stdarg (XmNlabelString, XmStringCreatePCB ("Name"));
set = XmCreatePushButton (style_dialog, "style", args, n);
XtManageChild (set);
XtAddCallback (set, XmNactivateCallback,
(XtCallbackProc) style_name_cb, (XtPointer) (size_t) i);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_WIDGET);
stdarg (XmNtopWidget, i ? style_pb[i - 1] : value_form);
stdarg (XmNleftAttachment, XmATTACH_WIDGET);
stdarg (XmNleftWidget, set);
stdarg (XmNlabelString, XmStringCreatePCB ("Set"));
set = XmCreatePushButton (style_dialog, "style", args, n);
XtManageChild (set);
XtAddCallback (set, XmNactivateCallback,
(XtCallbackProc) style_set_cb, (XtPointer) (size_t) i);
n = 0;
stdarg (XmNtopAttachment, XmATTACH_WIDGET);
stdarg (XmNtopWidget, i ? style_pb[i - 1] : value_form);
stdarg (XmNrightAttachment, XmATTACH_FORM);
stdarg (XmNleftAttachment, XmATTACH_WIDGET);
stdarg (XmNleftWidget, set);
stdarg (XmNlabelString, XmStringCreatePCB (PCB->RouteStyle[i].Name));
stdarg (XmNindicatorType, XmONE_OF_MANY);
stdarg (XmNalignment, XmALIGNMENT_BEGINNING);
pb = XmCreateToggleButton (style_dialog, "style", args, n);
XtManageChild (pb);
XtAddCallback (pb, XmNvalueChangedCallback,
(XtCallbackProc) style_selected, (XtPointer) (size_t) i);
return pb;
}
void TipOfTheDayCB(Widget w, XtPointer, XtPointer)
{
static Widget tip_dialog = 0;
if (tip_dialog == 0)
{
Arg args[10];
Cardinal arg = 0;
XtSetArg(args[arg], XmNautoUnmanage, False); arg++;
tip_dialog =
verify(XmCreateInformationDialog(find_shell(w),
XMST("tip_dialog"),
args, arg));
#if XmVersion >= 1002
arg = 0;
XtSetArg(args[arg], XmNset, app_data.startup_tips); arg++;
set_startup_tips_w =
verify(XmCreateToggleButton(tip_dialog,
XMST("set_startup_tips"),
args, arg));
XtAddCallback(set_startup_tips_w, XmNvalueChangedCallback,
SetStartupTipsCB, 0);
XtManageChild(set_startup_tips_w);
#endif
XtAddCallback(tip_dialog, XmNokCallback, UnmanageThisCB,
XtPointer(tip_dialog));
XtAddCallback(tip_dialog, XmNcancelCallback, PrevTipCB, 0);
XtAddCallback(tip_dialog, XmNhelpCallback, NextTipCB, 0);
XtAddCallback(tip_dialog, XmNunmapCallback, SaveTipCountCB, 0);
}
bool ok = refresh_tip_dialog(tip_dialog);
if (!ok)
return;
manage_and_raise(tip_dialog);
}
/*************************************<->*************************************
*
* wspCreateToggleButton (mgrW, pch)
*
*
* Description:
* -----------
* Creates a toggle button as a child of mgrW with the string pch.
*
* Inputs:
* ------
* mgrW = parent widget
* pch = string to use for toggle button
*
* Outputs:
* -------
* Return = widget created
*
* Comments:
* ---------
******************************<->***********************************/
static Widget
wspCreateToggleButton(
Widget mgrW,
unsigned char *pch )
{
Arg setArgs[20];
int i;
Widget toggleW;
XmString labelString;
i = 0;
labelString = XmStringCreateLocalized ((char *)pch);
XtSetArg (setArgs[i], XmNlabelString, labelString); i++;
toggleW = XmCreateToggleButton (mgrW, (char *)pch, setArgs, i);
XmStringFree(labelString);
XtManageChild (toggleW);
return (toggleW);
} /* END OF FUNCTION wspCreateToggleButton */
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);
}
/* ARGSUSED */
void create_nonl_frame(Widget w, XtPointer client_data, XtPointer call_data)
{
int i;
Widget sw, fr, title_fr, fr1, fr3, rc, rc1, rc2, rc3, lab, fitbut[4], but1[2];
Widget menubar, menupane, submenupane, cascade;
set_wait_cursor();
if (nonl_frame == NULL) {
char *fitlabel[4];
char *blabel[2];
fitlabel[0] = "Load as is";
fitlabel[1] = "Run 5 steps";
fitlabel[2] = "Run 20 steps";
fitlabel[3] = "Run 100 steps";
blabel[0] = "Accept";
blabel[1] = "Cancel";
nonl_frame = XmCreateDialogShell(app_shell, "Non-linear curve fitting", NULL, 0);
handle_close(nonl_frame);
nonl_panel = XmCreateForm(nonl_frame, "nonl_frame_rc", NULL, 0);
menubar = CreateMenuBar(nonl_panel, "nonlMenuBar", NULL);
menupane = CreateMenu(menubar, "nonlFileMenu", "File", 'F', NULL, NULL);
CreateMenuButton(menupane, "open", "Open...", 'O',
(XtCallbackProc) create_openfit_popup, (XtPointer) NULL, NULL);
CreateMenuButton(menupane, "save", "Save...", 'S',
(XtCallbackProc) create_savefit_popup, (XtPointer) NULL, NULL);
CreateMenuSeparator(menupane, "sep1");
CreateMenuButton(menupane, "close", "Close", 'C',
(XtCallbackProc) destroy_nonl_frame, (XtPointer) NONL_ACCEPT, NULL);
menupane = CreateMenu(menubar, "nonlDataMenu", "Data", 'D', NULL, NULL);
CreateMenuButton(menupane, "reset", "Reset", 'R',
(XtCallbackProc) reset_nonl_frame, (XtPointer) NULL, 0);
CreateMenuButton(menupane, "update", "Update", 'U',
(XtCallbackProc) update_nonl_frame, (XtPointer) NULL, 0);
menupane = CreateMenu(menubar, "nonlOptionsMenu", "Options", 'O', NULL, NULL);
submenupane = CreateMenu(menupane, "nonlLoadMenu",
"Load", 'L', NULL, NULL);
nonl_load_item[0] = CreateMenuToggle(submenupane, "values", "Fitted values", 'v',
(XtCallbackProc) do_nonl_toggle, (XtPointer) 0, NULL);
nonl_load_item[1] = CreateMenuToggle(submenupane, "residuals", "Residuals", 'R',
(XtCallbackProc) do_nonl_toggle, (XtPointer) 1, NULL);
nonl_load_item[2] = CreateMenuToggle(submenupane, "function", "Function", 'F',
(XtCallbackProc) do_nonl_toggle, (XtPointer) 2, NULL);
nonl_autol_item = CreateMenuToggle(menupane, "autoload", "Autoload", 'A',
(XtCallbackProc) NULL, (XtPointer) NULL, NULL);
menupane = CreateMenu(menubar, "nonlHelpMenu", "Help", 'H', &cascade, NULL);
XtVaSetValues(menubar, XmNmenuHelpWidget, cascade, NULL);
CreateMenuButton(menupane, "onFit", "On fit", 'f',
(XtCallbackProc) HelpCB, (XtPointer) "trans.html#nlcurve", 0);
CreateMenuButton(menupane, "onContext", "On context", 'x',
(XtCallbackProc) ContextHelpCB, (XtPointer) NULL, 0);
XtManageChild(menubar);
XtVaSetValues(menubar,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
fr1 = XmCreateFrame(nonl_panel, "nonl_frame", NULL, 0);
nonl_set_item = CreateSetSelector(fr1, "Apply to set:",
SET_SELECT_ACTIVE,
FILTER_SELECT_NONE,
GRAPH_SELECT_CURRENT,
SELECTION_TYPE_SINGLE);
XtManageChild(fr1);
XtVaSetValues(fr1,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, menubar,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
fr = XmCreateFrame(nonl_panel, "nonl_frame", NULL, 0);
rc = XmCreateRowColumn(fr, "nonl_rc", NULL, 0);
title_fr = XmCreateFrame(rc, "nonl_title_frame", NULL, 0);
XtVaSetValues(title_fr, XmNshadowType, XmSHADOW_ETCHED_OUT, NULL);
nonl_title_item = XmCreateLabel(title_fr, nonl_opts.title, NULL, 0);
XtManageChild(nonl_title_item);
XtManageChild(title_fr);
nonl_formula_item = (Widget) CreateTextItem2(rc, 35, "Formula:");
rc1 = XmCreateRowColumn(rc, "nonl_rc", NULL, 0);
XtVaSetValues(rc1, XmNorientation, XmHORIZONTAL, NULL);
nonl_nparm_item = CreatePanelChoice(rc1,
"Number of parameters:",
12,
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"10",
NULL, NULL);
for (i = 0; i < MAXPARM + 1; i++) {
XtAddCallback(nonl_nparm_item[2 + i], XmNactivateCallback,
(XtCallbackProc) do_nparm_toggle, (XtPointer) i);
}
nonl_tol_item = CreateTextItem2(rc1, 10, "Tolerance:");
XtManageChild(rc1);
sw = XtVaCreateManagedWidget("sw",
xmScrolledWindowWidgetClass, rc,
XmNheight, 180,
XmNscrollingPolicy, XmAUTOMATIC,
NULL);
rc2 = XmCreateRowColumn(sw, "rc2", NULL, 0);
for (i = 0; i < MAXPARM; i++) {
nonl_parm_item[i] = XmCreateRowColumn(rc2, "rc1", NULL, 0);
XtVaSetValues(nonl_parm_item[i], XmNorientation, XmHORIZONTAL, NULL);
sprintf(buf, "A%1d: ", i);
nonl_value_item[i] = CreateTextItem2(nonl_parm_item[i], 10, buf);
nonl_constr_item[i] = XmCreateToggleButton(nonl_parm_item[i], "Bounds:", NULL, 0);
XtAddCallback(nonl_constr_item[i], XmNvalueChangedCallback,
(XtCallbackProc) do_constr_toggle, (XtPointer) i);
XtManageChild(nonl_constr_item[i]);
nonl_lowb_item[i] = CreateTextItem2(nonl_parm_item[i], 6, "");
sprintf(buf, "< A%1d < ", i);
lab = XmCreateLabel(nonl_parm_item[i], buf, NULL, 0);
XtManageChild(lab);
nonl_uppb_item[i] = CreateTextItem2(nonl_parm_item[i], 6, "");
XtManageChild(nonl_parm_item[i]);
}
XtManageChild(rc2);
XtManageChild(rc);
XtManageChild(fr);
XtVaSetValues(fr,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, fr1,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
fr3 = XmCreateFrame(nonl_panel, "nonl_frame", NULL, 0);
rc3 = XmCreateRowColumn(fr3, "rc3", NULL, 0);
CreateCommandButtons(rc3, 4, fitbut, fitlabel);
XtAddCallback(fitbut[0], XmNactivateCallback,
(XtCallbackProc) do_nonl_proc, (XtPointer) (0));
XtAddCallback(fitbut[1], XmNactivateCallback,
(XtCallbackProc) do_nonl_proc, (XtPointer) (5));
XtAddCallback(fitbut[2], XmNactivateCallback,
(XtCallbackProc) do_nonl_proc, (XtPointer) (20));
XtAddCallback(fitbut[3], XmNactivateCallback,
(XtCallbackProc) do_nonl_proc, (XtPointer) (100));
XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, rc3, NULL);
nonl_fload_rc = XmCreateRowColumn(rc3, "nonl_fload_rc", NULL, 0);
XtVaSetValues(nonl_fload_rc, XmNorientation, XmHORIZONTAL, NULL);
nonl_start_item = CreateTextItem2(nonl_fload_rc, 6, "Start load at:");
nonl_stop_item = CreateTextItem2(nonl_fload_rc, 6, "Stop load at:");
nonl_npts_item = CreateTextItem2(nonl_fload_rc, 4, "# of points:");
XtManageChild(nonl_fload_rc);
XtSetSensitive(nonl_fload_rc, False);
CreateCommandButtons(rc3, 2, but1, blabel);
XtAddCallback(but1[0], XmNactivateCallback,
(XtCallbackProc) destroy_nonl_frame, (XtPointer) NONL_ACCEPT);
XtAddCallback(but1[1], XmNactivateCallback,
(XtCallbackProc) destroy_nonl_frame, (XtPointer) NONL_CANCEL);
XtManageChild(rc3);
XtManageChild(fr3);
XtVaSetValues(fr3,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, fr,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XtManageChild(nonl_panel);
}
update_nonl_frame();
XtRaise(nonl_frame);
unset_wait_cursor();
}
XFE_ABDirGenTabView::XFE_ABDirGenTabView(XFE_Component *top,
XFE_View *view):
XFE_PropertyTabView(top, view, XFE_AB_NAME_GENERAL_TAB)
{
int ac,
numForms = ABDIR_LAST+ABDIR_SECLAST;
Arg av[20];
Widget topForm = getBaseWidget(),
label = NULL,
stripForm[ABDIR_LAST+ABDIR_SECLAST];
char *genTabLabels[ABDIR_LAST+ABDIR_SECLAST];
Dimension width,
m_labelWidth = 0;
genTabLabels[ABDIR_DESCRIPTION] = XP_GetString(XFE_ABDIR_DESCRIPT);
genTabLabels[ABDIR_LDAPSERVER] = XP_GetString(XFE_ABDIR_SERVER);
genTabLabels[ABDIR_SEARCHROOT] = XP_GetString(XFE_ABDIR_SERVER_ROOT);
genTabLabels[ABDIR_PORTNUMBER] = XP_GetString(XFE_ABDIR_PORT_NUM);
genTabLabels[ABDIR_MAXHITS] = XP_GetString(XFE_ABDIR_MAX_HITS);
genTabLabels[ABDIR_LAST + ABDIR_SECUR] = XP_GetString(XFE_ABDIR_SECURE);
genTabLabels[ABDIR_LAST + ABDIR_USEPASSWD] =
XP_GetString(XFE_ABDIR_USE_PASSWD);
genTabLabels[ABDIR_LAST + ABDIR_SAVEPASSWD] =
XP_GetString(XFE_ABDIR_SAVE_PASSWD);
int i; // for use in multiple for loops...
// without breaking newer ANSI C++ rules
Widget sep = NULL;
for (i=0; i < numForms; i++) {
sep = NULL;
if (i == ABDIR_PORTNUMBER ||
i == ABDIR_LAST) {
sep = XtVaCreateManagedWidget("sep",
xmSeparatorGadgetClass, topForm,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, stripForm[i-1],
XmNtopOffset, 3,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
0);
}/* if */
ac = 0;
stripForm[i] = XmCreateForm(topForm, "strip", av, ac);
if (i < ABDIR_LAST) {
/* label/textF
*/
/* Create labels
*/
label = XtVaCreateManagedWidget(genTabLabels[i],
xmLabelGadgetClass, stripForm[i],
XmNalignment, XmALIGNMENT_BEGINNING,
NULL);
m_labels[i] = label;
XtVaSetValues(label,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_FORM,
0);
XtVaGetValues(label,
XmNwidth, &width,
0);
if (m_labelWidth < width)
m_labelWidth = width;
/* TextF
*/
ac = 0;
m_textFs[i] = fe_CreateTextField(stripForm[i],
(char *) genTabLabels[i],
av, ac);
XtVaSetValues(m_textFs[i],
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
0);
XtManageChild(m_textFs[i]);
}/* if */
else {
/* the toggle */
XmString xmstr;
xmstr = XmStringCreate(genTabLabels[i],
XmFONTLIST_DEFAULT_TAG);
ac = 0;
XtSetArg (av[ac], XmNlabelString, xmstr); ac++;
m_toggles[i-ABDIR_LAST] =
XmCreateToggleButton(stripForm[i], genTabLabels[i],
av, ac);
XtVaSetValues(m_toggles[i-ABDIR_LAST],
XmNleftAttachment, XmATTACH_FORM,
// XmNleftOffset, m_labelWidth,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_FORM,
0);
if (i == (ABDIR_LAST+ABDIR_USEPASSWD)) {
XtAddCallback(m_toggles[i-ABDIR_LAST],
XmNvalueChangedCallback,
XFE_ABDirGenTabView::usePasswdCallback, this);
}/* if */
XtManageChild(m_toggles[i-ABDIR_LAST]);
}/* else */
if (i == 0)
XtVaSetValues(stripForm[i],
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 10,
XmNleftOffset, 3,
XmNrightOffset, 3,
0);
else if (sep)
XtVaSetValues(stripForm[i],
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, sep,
XmNtopOffset, 3,
XmNleftOffset, 3,
XmNrightOffset, 3,
0);
else
XtVaSetValues(stripForm[i],
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, stripForm[i-1],
XmNtopOffset, 3,
XmNleftOffset, i==(ABDIR_LAST+ABDIR_SAVEPASSWD)?25:3,
XmNrightOffset, 3,
0);
XtManageChild(stripForm[i]);
if (i == ABDIR_SEARCHROOT) {
for (int j=0; j <= ABDIR_SEARCHROOT;j++)
XtVaSetValues(m_labels[j],
XmNwidth, m_labelWidth,
0);
m_labelWidth = 0;
}/* if */
else if (i == ABDIR_MAXHITS)
for (int j=ABDIR_PORTNUMBER; j <= ABDIR_MAXHITS; j++)
XtVaSetValues(m_labels[j],
XmNwidth, m_labelWidth,
0);
}/* for i */
}
void create_ci_equiplist_shell (Widget parent)
{
Widget children[10]; /* Children to manage */
Arg al[64]; /* Arg List */
register int ac = 0; /* Arg Count */
Pixel fg, bg; /* colour values for pixmaps */
XmString xmstrings[16]; /* temporary storage for XmStrings */
XtSetArg(al[ac], XmNallowShellResize, TRUE); ac++;
XtSetArg(al[ac], XmNminWidth, 787); ac++;
XtSetArg(al[ac], XmNminHeight, 496); ac++;
ci_equiplist_shell = XtCreatePopupShell ( "ci_equiplist_shell", topLevelShellWidgetClass, parent, al, ac );
ac = 0;
/* begin ci_equipinfo_form pre-creation code */
XtVaSetValues(ci_equiplist_shell, XmNiconPixmap, abp_icon, NULL) ;
/* end ci_equipinfo_form pre-creation code */
XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
XtSetArg(al[ac], XmNautoUnmanage, FALSE); ac++;
ci_equiplist_form = XmCreateForm ( ci_equiplist_shell, "ci_equiplist_form", al, ac );
ac = 0;
XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
ci_equip_account_form = XmCreateForm ( ci_equiplist_form, "ci_equip_account_form", al, ac );
ac = 0;
ci_equip_account_id_lbl = XmCreateLabel ( ci_equip_account_form, "ci_equip_account_id_lbl", al, ac );
XtSetArg(al[ac], XmNmaxLength, 48); ac++;
XtSetArg(al[ac], XmNcolumns, 48); ac++;
ci_equip_accountid_txt = XmCreateText ( ci_equip_account_form, "ci_equip_accountid_txt", al, ac );
ac = 0;
ci_equip_account_name_lbl = XmCreateLabel ( ci_equip_account_form, "ci_equip_account_name_lbl", al, ac );
XtSetArg(al[ac], XmNmaxLength, 40); ac++;
XtSetArg(al[ac], XmNcolumns, 40); ac++;
ci_equip_name_txt = XmCreateText ( ci_equip_account_form, "ci_equip_name_txt", al, ac );
ac = 0;
XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
XtSetArg(al[ac], XmNshadowType, XmSHADOW_IN); ac++;
ci_equiplist_filter_form = XmCreateForm ( ci_equiplist_form, "ci_equiplist_filter_form", al, ac );
ac = 0;
XtSetArg(al[ac], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ac++;
XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(al[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
ci_equip_filter_rc = XmCreateRowColumn ( ci_equiplist_filter_form, "ci_equip_filter_rc", al, ac );
ac = 0;
XtSetArg(al[ac], XmNhighlightOnEnter, FALSE); ac++;
ci_equip_filter_btn = XmCreatePushButton ( ci_equip_filter_rc, "ci_equip_filter_btn", al, ac );
ac = 0;
xmstrings[0] = XmStringCreateLtoR("Reset", (XmStringCharSet)XmFONTLIST_DEFAULT_TAG);
XtSetArg(al[ac], XmNlabelString, xmstrings[0]); ac++;
ci_equip_reset_btn = XmCreatePushButton ( ci_equip_filter_rc, "ci_equip_reset_btn", al, ac );
ac = 0;
XmStringFree ( xmstrings [ 0 ] );
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
ci_equip_filter_equip_lbl = XmCreateLabel ( ci_equiplist_filter_form, "ci_equip_filter_equip_lbl", al, ac );
ac = 0;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
ci_equip_filter_status_lbl = XmCreateLabel ( ci_equiplist_filter_form, "ci_equip_filter_status_lbl", al, ac );
ac = 0;
XtSetArg(al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
XtSetArg(al[ac], XmNmaxLength, 16); ac++;
XtSetArg(al[ac], XmNcolumns, 16); ac++;
XtSetArg(al[ac], XmNmarginHeight, 3); ac++;
XtSetArg(al[ac], XmNmarginWidth, 3); ac++;
ci_equip_filter_equip_txt = XmCreateText ( ci_equiplist_filter_form, "ci_equip_filter_equip_txt", al, ac );
ac = 0;
XtSetArg(al[ac], XmNhighlightOnEnter, TRUE); ac++;
XtSetArg(al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
XtSetArg(al[ac], XmNmaxLength, 10); ac++;
XtSetArg(al[ac], XmNcolumns, 10); ac++;
XtSetArg(al[ac], XmNmarginHeight, 3); ac++;
XtSetArg(al[ac], XmNmarginWidth, 3); ac++;
ci_filter_status_txt = XmCreateText ( ci_equiplist_filter_form, "ci_filter_status_txt", al, ac );
ac = 0;
XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
XtSetArg(al[ac], XmNmarginHeight, 0); ac++;
XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
ci_equip_status_btn = XmCreatePushButton ( ci_equiplist_filter_form, "ci_equip_status_btn", al, ac );
ac = 0;
XtSetArg(al[ac], XmNforeground, &fg ); ac++;
XtSetArg(al[ac], XmNbackground, &bg ); ac++;
XtGetValues(ci_equip_status_btn, al, ac );
ac = 0;
XtSetArg(al[ac], XmNlabelPixmap, XmGetPixmap ( XtScreen ( ci_equip_status_btn ), "down_arrow.xbm", fg, bg )); ac++;
XtSetArg(al[ac], XmNlabelInsensitivePixmap, XmGetPixmap ( XtScreen ( ci_equip_status_btn ), "down_arrow.xbm", fg, bg )); ac++;
XtSetValues ( ci_equip_status_btn,al, ac );
ac = 0;
ci_filter_ckt_lbl = XmCreateLabel ( ci_equiplist_filter_form, "ci_filter_ckt_lbl", al, ac );
XtSetArg(al[ac], XmNmaxLength, 16); ac++;
XtSetArg(al[ac], XmNcolumns, 16); ac++;
ci_filter_ckt_txt = XmCreateText ( ci_equiplist_filter_form, "ci_filter_ckt_txt", al, ac );
ac = 0;
XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(al[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
ci_filter_radio = XmCreateRadioBox ( ci_equiplist_filter_form, "ci_filter_radio", al, ac );
ac = 0;
ci_filter_owned_tgl = XmCreateToggleButtonGadget ( ci_filter_radio, "ci_filter_owned_tgl", al, ac );
ci_filter_billed_tgl = XmCreateToggleButtonGadget ( ci_filter_radio, "ci_filter_billed_tgl", al, ac );
XtSetArg(al[ac], XmNseparatorType, XmNO_LINE); ac++;
ci_filter_sep1 = XmCreateSeparator ( ci_equiplist_filter_form, "ci_filter_sep1", al, ac );
ac = 0;
XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
XtSetArg(al[ac], XmNshadowType, XmSHADOW_IN); ac++;
XtSetArg(al[ac], XmNautoUnmanage, FALSE); ac++;
XtSetArg(al[ac], XmNhorizontalSpacing, 5); ac++;
XtSetArg(al[ac], XmNverticalSpacing, 3); ac++;
ci_equip_sort_form = XmCreateForm ( ci_equiplist_form, "ci_equip_sort_form", al, ac );
ac = 0;
XtSetArg(al[ac], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ac++;
XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(al[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
ci_equip_sort_rc_btn = XmCreateRowColumn ( ci_equip_sort_form, "ci_equip_sort_rc_btn", al, ac );
ac = 0;
ci_equip_sort_btn = XmCreatePushButton ( ci_equip_sort_rc_btn, "ci_equip_sort_btn", al, ac );
ci_equip_sort_reset_btn = XmCreatePushButton ( ci_equip_sort_rc_btn, "ci_equip_sort_reset_btn", al, ac );
XtSetArg(al[ac], XmNheight, 78); ac++;
XtSetArg(al[ac], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ac++;
XtSetArg(al[ac], XmNspacing, 0); ac++;
XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
XtSetArg(al[ac], XmNmarginHeight, 0); ac++;
ci_equip_sort_tgls = XmCreateRowColumn ( ci_equip_sort_form, "ci_equip_sort_tgls", al, ac );
ac = 0;
ci_equip_sort_status_tgl = XmCreateToggleButton ( ci_equip_sort_tgls, "ci_equip_sort_status_tgl", al, ac );
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
ci_equip_sort_equip_tgl = XmCreateToggleButton ( ci_equip_sort_tgls, "ci_equip_sort_equip_tgl", al, ac );
ac = 0;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
ci_equip_sort_date_tgl = XmCreateToggleButton ( ci_equip_sort_tgls, "ci_equip_sort_date_tgl", al, ac );
ac = 0;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
ci_equip_sort_rev_lbl = XmCreateLabel ( ci_equip_sort_form, "ci_equip_sort_rev_lbl", al, ac );
ac = 0;
XtSetArg(al[ac], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ac++;
XtSetArg(al[ac], XmNspacing, 0); ac++;
XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
XtSetArg(al[ac], XmNmarginHeight, 0); ac++;
ci_equip_sort_rev_tgls = XmCreateRowColumn ( ci_equip_sort_form, "ci_equip_sort_rev_tgls", al, ac );
ac = 0;
ci_equip_sort_status_rev_tgl = XmCreateToggleButton ( ci_equip_sort_rev_tgls, "ci_equip_sort_status_rev_tgl", al, ac );
ci_equip_sort_equip_rev_tgl = XmCreateToggleButton ( ci_equip_sort_rev_tgls, "ci_equip_sort_equip_rev_tgl", al, ac );
ci_equip_sort_date_rev_tgl = XmCreateToggleButton ( ci_equip_sort_rev_tgls, "ci_equip_sort_date_rev_tgl", al, ac );
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
ci_equip_sort_order_lbl = XmCreateLabel ( ci_equip_sort_form, "ci_equip_sort_order_lbl", al, ac );
ac = 0;
XtSetArg(al[ac], XmNmaxLength, 300); ac++;
XtSetArg(al[ac], XmNcolumns, 31); ac++;
XtSetArg(al[ac], XmNmarginHeight, 1); ac++;
XtSetArg(al[ac], XmNmarginWidth, 1); ac++;
XtSetArg(al[ac], XmNeditable, FALSE); ac++;
XtSetArg(al[ac], XmNcursorPositionVisible, FALSE); ac++;
XtSetArg(al[ac], XmNautoShowCursorPosition, FALSE); ac++;
ci_equip_sort_orderby_txt = XmCreateText ( ci_equip_sort_form, "ci_equip_sort_orderby_txt", al, ac );
ac = 0;
ci_equip_sort_by_lbl = XmCreateLabel ( ci_equip_sort_form, "ci_equip_sort_by_lbl", al, ac );
XtSetArg(al[ac], XmNresizePolicy, XmRESIZE_NONE); ac++;
XtSetArg(al[ac], XmNshadowType, XmSHADOW_IN); ac++;
XtSetArg(al[ac], XmNverticalSpacing, 0); ac++;
ci_subscrlist_form = XmCreateForm ( ci_equiplist_form, "ci_subscrlist_form", al, ac );
ac = 0;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
equip_emf_lbl = XmCreateLabel ( ci_subscrlist_form, "equip_emf_lbl", al, ac );
ac = 0;
XtSetArg(al[ac], XmNheight, 151); ac++;
XtSetArg(al[ac], XmNhighlightOnEnter, TRUE); ac++;
XtSetArg(al[ac], XmNvisibleItemCount, 9); ac++;
XtSetArg(al[ac], XmNselectionPolicy, XmSINGLE_SELECT); ac++;
XtSetArg(al[ac], XmNscrollBarDisplayPolicy, XmSTATIC); ac++;
XtSetArg(al[ac], XmNlistSizePolicy, XmCONSTANT); ac++;
ci_equiplist = XmCreateScrolledList ( ci_subscrlist_form, "ci_equiplist", al, ac );
ac = 0;
ci_equipslist = XtParent ( ci_equiplist );
XtSetArg(al[ac], XmNhorizontalScrollBar, &ci_equipHscrollbar ); ac++;
XtSetArg(al[ac], XmNverticalScrollBar, &ci_equipVscrollbar ); ac++;
XtGetValues(ci_equipslist, al, ac );
ac = 0;
ci_equiplist_btn_form = XmCreateForm ( ci_equiplist_form, "ci_equiplist_btn_form", al, ac );
XtSetArg(al[ac], XmNspacing, 20); ac++;
XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(al[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
ci_equiplist_rowcol = XmCreateRowColumn ( ci_equiplist_btn_form, "ci_equiplist_rowcol", al, ac );
ac = 0;
ci_equiplist_prov_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_prov_btn", al, ac );
ci_equiplist_modify_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_modify_btn", al, ac );
ci_equiplist_disc_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_disc_btn", al, ac );
ci_equiplist_contract_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_contract_btn", al, ac );
ci_equiplist_close_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_close_btn", al, ac );
ci_equiplist_help_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_help_btn", al, ac );
ci_equip_status_txt = XmCreateText ( ci_equiplist_btn_form, "ci_equip_status_txt", al, ac );
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 0); ac++;
XtSetValues ( ci_equip_account_form,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 10); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_account_form); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg(al[ac], XmNrightPosition, 45); ac++;
XtSetValues ( ci_equiplist_filter_form,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 10); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_account_form); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_equiplist_filter_form); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNleftWidget, ci_equiplist_filter_form); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 10); ac++;
XtSetValues ( ci_equip_sort_form,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 10); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equiplist_filter_form); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_equiplist_btn_form); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 10); ac++;
XtSetValues ( ci_subscrlist_form,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 1); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 1); ac++;
XtSetValues ( ci_equiplist_btn_form,al, ac );
ac = 0;
XtAddCallback (ci_equiplist_form,XmNhelpCallback, XDhelp_link, (XtPointer) &_xd_help_pairs[0] );
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_accountid_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_equip_accountid_txt); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightOffset, 5); ac++;
XtSetArg(al[ac], XmNrightWidget, ci_equip_accountid_txt); ac++;
XtSetValues ( ci_equip_account_id_lbl,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopOffset, 5); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 100); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_accountid_txt,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_name_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_equip_name_txt); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightOffset, 5); ac++;
XtSetArg(al[ac], XmNrightWidget, ci_equip_name_txt); ac++;
XtSetValues ( ci_equip_account_name_lbl,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopOffset, 5); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomOffset, 5); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 500); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_name_txt,al, ac );
ac = 0;
children[ac++] = ci_equip_account_id_lbl;
children[ac++] = ci_equip_accountid_txt;
children[ac++] = ci_equip_account_name_lbl;
children[ac++] = ci_equip_name_txt;
XtManageChildren(children, ac);
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopOffset, 5); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 5); ac++;
XtSetValues ( ci_equip_filter_rc,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_filter_equip_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_equip_filter_equip_txt); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightOffset, 0); ac++;
XtSetArg(al[ac], XmNrightWidget, ci_equip_filter_equip_txt); ac++;
XtSetValues ( ci_equip_filter_equip_lbl,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_filter_status_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_filter_status_txt); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightOffset, 0); ac++;
XtSetArg(al[ac], XmNrightWidget, ci_filter_status_txt); ac++;
XtSetValues ( ci_equip_filter_status_lbl,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_filter_status_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNleftWidget, ci_filter_status_txt); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_filter_equip_txt,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_filter_radio); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 136); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_filter_status_txt,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_filter_status_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_filter_status_txt); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNleftOffset, -1); ac++;
XtSetArg(al[ac], XmNleftWidget, ci_filter_status_txt); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_status_btn,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_filter_ckt_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_filter_ckt_txt); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightOffset, 0); ac++;
XtSetArg(al[ac], XmNrightWidget, ci_filter_ckt_txt); ac++;
XtSetValues ( ci_filter_ckt_lbl,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_filter_equip_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNleftWidget, ci_equip_filter_equip_txt); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_filter_ckt_txt,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_filter_rc); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 96); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_filter_radio,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 10); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_filter_ckt_txt); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNleftWidget, ci_filter_ckt_txt); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_filter_sep1,al, ac );
ac = 0;
XtAddCallback (ci_equip_filter_btn, XmNactivateCallback, filter_equipment,NULL);
XtAddCallback (ci_equip_reset_btn, XmNactivateCallback, reset_filter_equipment,NULL);
children[ac++] = ci_equip_filter_btn;
children[ac++] = ci_equip_reset_btn;
XtManageChildren(children, ac);
ac = 0;
XtAddCallback (ci_equip_filter_equip_txt, XmNactivateCallback, filter_equipment,NULL);
XtAddCallback (ci_equip_status_btn, XmNactivateCallback, emf_display_status_values,NULL);
children[ac++] = ci_filter_owned_tgl;
children[ac++] = ci_filter_billed_tgl;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = ci_equip_filter_rc;
children[ac++] = ci_equip_filter_equip_lbl;
children[ac++] = ci_equip_filter_status_lbl;
children[ac++] = ci_equip_filter_equip_txt;
children[ac++] = ci_filter_status_txt;
children[ac++] = ci_equip_status_btn;
children[ac++] = ci_filter_ckt_lbl;
children[ac++] = ci_filter_ckt_txt;
children[ac++] = ci_filter_radio;
children[ac++] = ci_filter_sep1;
XtManageChildren(children, ac);
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopOffset, 5); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 5); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_sort_rc_btn,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_by_lbl); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomOffset, 5); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNleftWidget, ci_equip_sort_by_lbl); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_sort_tgls,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_by_lbl); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 111); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_sort_rev_lbl,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_rev_lbl); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNleftWidget, ci_equip_sort_rev_lbl); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_sort_rev_tgls,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_rev_lbl); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetArg(al[ac], XmNleftPosition, 44); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_sort_order_lbl,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_order_lbl); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomWidget, ci_equip_sort_rev_tgls); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNleftWidget, ci_equip_sort_order_lbl); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg(al[ac], XmNrightPosition, 95); ac++;
XtSetValues ( ci_equip_sort_orderby_txt,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 5); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_rc_btn); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 5); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equip_sort_by_lbl,al, ac );
ac = 0;
XtAddCallback (ci_equip_sort_btn, XmNactivateCallback, filter_equipment,NULL);
XtAddCallback (ci_equip_sort_reset_btn, XmNactivateCallback, reset_sort_equipment,NULL);
children[ac++] = ci_equip_sort_btn;
children[ac++] = ci_equip_sort_reset_btn;
XtManageChildren(children, ac);
ac = 0;
XtAddCallback (ci_equip_sort_status_tgl, XmNvalueChangedCallback, update_equip_sort_fields,&equip_status_data);
XtAddCallback (ci_equip_sort_equip_tgl, XmNvalueChangedCallback, update_equip_sort_fields,&equip_subscr_no_data);
XtAddCallback (ci_equip_sort_date_tgl, XmNvalueChangedCallback, update_equip_sort_fields,&equip_start_date_data);
children[ac++] = ci_equip_sort_status_tgl;
children[ac++] = ci_equip_sort_equip_tgl;
children[ac++] = ci_equip_sort_date_tgl;
XtManageChildren(children, ac);
ac = 0;
XtAddCallback (ci_equip_sort_status_rev_tgl, XmNvalueChangedCallback, update_equip_asc_desc_list,EQUIPMENT_STATUS);
XtAddCallback (ci_equip_sort_equip_rev_tgl, XmNvalueChangedCallback, update_equip_asc_desc_list,EQUIPMENT_EQUIP_NUM);
XtAddCallback (ci_equip_sort_date_rev_tgl, XmNvalueChangedCallback, update_equip_asc_desc_list,EQUIPMENT_START_DATE);
children[ac++] = ci_equip_sort_status_rev_tgl;
children[ac++] = ci_equip_sort_equip_rev_tgl;
children[ac++] = ci_equip_sort_date_rev_tgl;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = ci_equip_sort_rc_btn;
children[ac++] = ci_equip_sort_tgls;
children[ac++] = ci_equip_sort_rev_lbl;
children[ac++] = ci_equip_sort_rev_tgls;
children[ac++] = ci_equip_sort_order_lbl;
children[ac++] = ci_equip_sort_orderby_txt;
children[ac++] = ci_equip_sort_by_lbl;
XtManageChildren(children, ac);
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( equip_emf_lbl,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, equip_emf_lbl); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 0); ac++;
XtSetValues ( ci_equipslist,al, ac );
ac = 0;
XtAddCallback (ci_equiplist, XmNdefaultActionCallback, modify_emf_cb,NULL);
XtManageChild(ci_equiplist);
children[ac++] = equip_emf_lbl;
XtManageChildren(children, ac);
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 40); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
XtSetValues ( ci_equiplist_rowcol,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNtopWidget, ci_equiplist_rowcol); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 0); ac++;
XtSetValues ( ci_equip_status_txt,al, ac );
ac = 0;
XtAddCallback (ci_equiplist_prov_btn, XmNactivateCallback, add_emf_cb,NULL);
XtAddCallback (ci_equiplist_modify_btn, XmNactivateCallback, modify_emf_cb,NULL);
XtAddCallback (ci_equiplist_disc_btn, XmNactivateCallback, disconnect_emf_cb,NULL);
XtAddCallback (ci_equiplist_contract_btn, XmNactivateCallback, display_equip_contract_cb,NULL);
XtAddCallback (ci_equiplist_close_btn, XmNactivateCallback, close_equipment_window,NULL);
XtAddCallback (ci_equiplist_help_btn,XmNactivateCallback, XDhelp_link, (XtPointer) &_xd_help_pairs[0] );
children[ac++] = ci_equiplist_prov_btn;
children[ac++] = ci_equiplist_modify_btn;
children[ac++] = ci_equiplist_disc_btn;
children[ac++] = ci_equiplist_contract_btn;
children[ac++] = ci_equiplist_close_btn;
children[ac++] = ci_equiplist_help_btn;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = ci_equiplist_rowcol;
children[ac++] = ci_equip_status_txt;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = ci_equip_account_form;
children[ac++] = ci_equiplist_filter_form;
children[ac++] = ci_equip_sort_form;
children[ac++] = ci_subscrlist_form;
children[ac++] = ci_equiplist_btn_form;
XtManageChildren(children, ac);
ac = 0;
XtManageChild ( ci_equiplist_form);
}
int
main(int argc, char *argv[])
{
#define MAIN_CHILDREN 3
#define FORM_CHILDREN 3
#define PLANE_CHILDREN 6
#define TRAFFIC_CHILDREN 3
#define SetMenuEntry(k,l,p,d) labels[k]=l;procs[k]=p;private[k]=d;
Pixmap flying;
Pixmap parked;
Pixmap mask;
Widget theWidgetRoot;
Widget main_tab[MAIN_CHILDREN];
Widget from_tab[PLANE_CHILDREN];
Widget to_tab[TRAFFIC_CHILDREN];
Widget form_tab[FORM_CHILDREN];
Widget framed[2];
Widget entry;
static char myClass[] = "XmdAirport";
Arg args[10];
int n ;
String labels[4];
XtCallbackProc procs[4];
XtPointer private[4];
XGCValues gcv;
Airport this;
/*
* Initialize
*/
this = (Airport) XtCalloc(sizeof(AirportRec), 1);
XtSetLanguageProc(NULL, (XtLanguageProc) NULL, NULL);
theWidgetRoot = XtVaOpenApplication( &this->context,
myClass,
NULL,
0,
&argc,
argv,
NULL,
sessionShellWidgetClass,
XmNallowShellResize, True,
NULL);
this->display = XtDisplay(theWidgetRoot);
FlightAtom = XmInternAtom(this->display, "FLIGHT", False);
DeleteAtom = XmInternAtom(this->display, "DELETE", False);
XtGetApplicationResources(theWidgetRoot, &AirportResources,
AirportResourcesSpecs,
XtNumber(AirportResourcesSpecs),
(ArgList) NULL, 0);
/*
* Create the Main Window, the menubar and the pulldown menus
*/
n = 0;
this->main = XmCreateMainWindow(theWidgetRoot, "main", args, n);
n = 0;
main_tab[0] = XmCreateMenuBar(this->main, "menubar", args, n);
n = 0;
SetMenuEntry(n, "Exit",
(XtCallbackProc) ExitCallback, (XtPointer) this ); n++;
entry = MenuBarEntry(main_tab[0], "File", labels, procs, private, n);
n = 0;
SetMenuEntry(0, "Tutorial",
(XtCallbackProc) HelpCallback, (XtPointer) this); n++;
entry = MenuBarEntry(main_tab[0], "Help", labels, procs, private, n);
n = 0;
XtSetArg(args[n], XmNmenuHelpWidget, entry); n++;
XtSetValues(main_tab[0], args, n);
/*
* Create the Airport widget structure.
* Two framed radio boxes show state.
* A drawing area in the middle show track and planes
*/
n = 0;
this->screen_width = WidthOfScreen(XtScreenOfObject(this->main));
this->screen_height = HeightOfScreen(XtScreenOfObject(this->main));
XtSetArg(args[n], XmNwidth, this->screen_width*3/7); n++;
XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++;
main_tab[1] = XmCreateForm(this->main, "airport", args, n);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM) ; n++;
form_tab[0] = XmCreateFrame(main_tab[1], "flight", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
framed[0] = XmCreateLabel(form_tab[0], "title", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++;
XtSetArg(args[n], XmNresizePolicy, XmRESIZE_GROW); n++;
XtSetArg(args[n], XmNradioBehavior, True); n++;
framed[1] = XmCreateRadioBox(form_tab[0], "panel", args, n);
n = 0;
XtSetArg(args[n], XmNset, True); n++;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.departure =
from_tab[0] = XmCreateToggleButton(framed[1],
"departure", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.over_ocean =
from_tab[1] = XmCreateToggleButton(framed[1],
"over_ocean", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.over_land =
from_tab[2] = XmCreateToggleButton(framed[1],
"over_land", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.over_site =
from_tab[3] = XmCreateToggleButton(framed[1],
"radar", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.landing =
from_tab[4] = XmCreateToggleButton(framed[1], "landing", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->from.landed =
from_tab[5] = XmCreateToggleButton(framed[1], "landed", args, n);
XtManageChildren(from_tab, PLANE_CHILDREN);
XtManageChildren(framed, 2);
/*
* Create the Airport Traffic control state
*/
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM) ; n++;
form_tab[1] = XmCreateFrame(main_tab[1], "traffic", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
framed[0] = XmCreateLabel(form_tab[1], "title", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++;
XtSetArg(args[n], XmNradioBehavior, True); n++;
framed[1] = XmCreateRadioBox(form_tab[1], "traffic_box", args, n);
n = 0;
XtSetArg(args[n], XmNset, True); n++;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->to.leave =
to_tab[1] = XmCreateToggleButton(framed[1],
"no_traffic", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->to.enter =
to_tab[0] = XmCreateToggleButton(framed[1],
"radar_echo", args, n);
n = 0;
XtSetArg(args[n], XmNvisibleWhenOff, False); n++;
this->to.landing =
to_tab[2] = XmCreateToggleButton(framed[1],
"landing", args, n);
XtManageChildren(to_tab, TRAFFIC_CHILDREN);
XtManageChildren(framed, 2);
/*
* Create the Airport picture
*/
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET) ; n++;
XtSetArg(args[n], XmNleftWidget, form_tab[0]) ; n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET) ; n++;
XtSetArg(args[n], XmNrightWidget, form_tab[1]) ; n++;
this->airport =
form_tab[2] = XmCreateDrawingArea(main_tab[1], "da", args, n);
XtAddCallback(this->airport, XmNexposeCallback,
(XtCallbackProc) ShowAirport, (XtPointer) this);
XtAddCallback(this->airport, XmNresizeCallback,
(XtCallbackProc) ResizeAirport, (XtPointer) this);
XtAddCallback(this->airport, XmNinputCallback,
(XtCallbackProc) AirportInput, (XtPointer) this);
/*
* Create the Airport Message area
*/
n = 0;
main_tab[2] = XmCreateFrame(this->main, "message", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
framed[0] = XmCreateLabel(main_tab[2], "title", args, n);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++;
XtSetArg(args[n], XmNvisibleItemCount, 4); n++;
this->msg_area = XmCreateScrolledList(main_tab[2], "msg_list", args, n);
XtManageChild(this->msg_area);
framed[1] = XtParent(this->msg_area);
XtManageChildren(framed, 2);
n = 0;
XtSetArg(args[n], XmNmenuBar, main_tab[0]); n++;
XtSetArg(args[n], XmNworkWindow, main_tab[1]); n++;
XtSetArg(args[n], XmNmessageWindow, main_tab[2]); n++;
XtSetValues(this->main, args, n);
XtManageChildren(form_tab, FORM_CHILDREN);
XtManageChildren(main_tab, MAIN_CHILDREN);
XtManageChild(this->main);
XtRealizeWidget(theWidgetRoot);
/*
* Create the drag icon
*/
parked = XCreateBitmapFromData(this->display,
XtWindow(this->main), (char*)plane_bits,
plane_width, plane_height);
flying = XCreateBitmapFromData(this->display,
XtWindow(this->main), (char*)flying_bits,
flying_icon_width, flying_icon_height);
mask = XCreateBitmapFromData(this->display,
XtWindow(this->main), (char*)flying_mask_bits,
flying_mask_width, flying_mask_height);
n = 0;
XtSetArg(args[n], XmNpixmap, flying); n++;
XtSetArg(args[n], XmNdepth, 1); n++;
XtSetArg(args[n], XmNmask, mask); n++;
XtSetArg(args[n], XmNwidth, flying_icon_width); n++;
XtSetArg(args[n], XmNheight, flying_icon_height) ; n++;
this->dragIcon = XmCreateDragIcon(form_tab[2], "drag", args, n);
if (this->dragIcon == NULL) {
printf("cannot create drag icon\n");
exit(0);
}
/* Create GC for drawing planes */
gcv.function = GXcopy;
gcv.fill_style = FillOpaqueStippled;
gcv.stipple = parked;
gcv.foreground = AirportResources.spot_foreground;
gcv.background = AirportResources.spot_background;
this->park.gc = XCreateGC(this->display, XtWindow(this->main),
GCFunction|GCStipple|GCFillStyle
|GCForeground|GCBackground,
&gcv);
gcv.line_style = LineDoubleDash;
gcv.line_width = AirportResources.track_border_width;
gcv.fill_style = FillSolid;
gcv.foreground = AirportResources.track_foreground;
gcv.background = AirportResources.track_background;
this->track.gc = XCreateGC(this->display, XtWindow(this->main),
GCFunction|GCLineWidth|GCLineStyle
|GCFillStyle|GCForeground|GCBackground,
&gcv);
XtAppMainLoop(this->context);
return 0; /* make compiler happy */
}
void create_file_popup(Widget, XtPointer, XtPointer)
{
long i;
Widget lab, rc, rc2, fr, rb, w[3];
set_wait_cursor();
if (rdata_dialog == NULL)
{
rdata_dialog = XmCreateFileSelectionDialog(app_shell, (char *)"rdata_dialog", NULL, 0);
XtVaSetValues(XtParent(rdata_dialog), XmNtitle, "Read sets", NULL);
XtAddCallback(rdata_dialog, XmNcancelCallback, (XtCallbackProc)destroy_dialog, rdata_dialog);
XtAddCallback(rdata_dialog, XmNokCallback, rdata_proc, 0);
curtype = XY;
rc = XmCreateRowColumn(rdata_dialog, (char *)"Read data main RC", NULL, 0);
fr = XmCreateFrame(rc, (char *)"frame_1", NULL, 0);
rc2 = XmCreateRowColumn(fr, (char *)"Read data main RC", NULL, 0);
XtVaSetValues(rc2, XmNorientation, XmHORIZONTAL, NULL);
read_ftype_item = CreatePanelChoice(rc2, "File format: ", 16,
"X Y",
"X Y1 Y2 ... ",
"IHL",
"Binary",
"X Y DX",
"X Y DY",
"X Y DX1 DX2",
"X Y DY1 DY2",
"X Y DX DY",
"X Y Z",
"X HI LO OPEN CLOSE",
"X Y RADIUS",
"X Y BOX",
"Rawspice",
"X Y BOXPLOT",
NULL, NULL);
XtManageChild(rc2);
XtManageChild(fr);
fr = XmCreateFrame(rc, (char *)"frame_2", NULL, 0);
rc2 = XmCreateRowColumn(fr, (char *)"Read data main RC", NULL, 0);
XtVaSetValues(rc2, XmNorientation, XmHORIZONTAL, NULL);
lab = XmCreateLabel(rc2, (char *)"File Source:", NULL, 0);
rb = XmCreateRadioBox(rc2, (char *)"radio_box_2", NULL, 0);
XtVaSetValues(rb, XmNorientation, XmHORIZONTAL, NULL);
w[0] = XmCreateToggleButton(rb, (char *)"Disk", NULL, 0);
w[1] = XmCreateToggleButton(rb, (char *)"Pipe", NULL, 0);
for (i = 0; i < 2; i++)
{
XtAddCallback(w[i], XmNvalueChangedCallback, set_src_proc, (XtPointer)i);
}
XtManageChild(lab);
XtManageChild(rb);
XtManageChildren(w, 2);
XtManageChild(rc2);
XtManageChild(fr);
XmToggleButtonSetState(w[0], True, False);
fr = XmCreateFrame(rc, (char *)"frame_3", NULL, 0);
rc2 = XmCreateRowColumn(fr, (char *)"Read data main RC", NULL, 0);
read_graph_item = CreateGraphChoice(rc2, "Read to graph: ", maxgraph, 1);
read_auto_item = XmCreateToggleButton(rc2, (char *)"Autoscale on read", NULL, 0);
XtManageChild(read_auto_item);
XtManageChild(rc2);
XtManageChild(fr);
XtManageChild(rc);
XtManageChild(rc);
}
XtRaise(rdata_dialog);
unset_wait_cursor();
}
Widget XmCreateToggleButton_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateToggleButton(parent, name, arglist, argcount);}
XFE_ABNameGenTabView::XFE_ABNameGenTabView(XFE_Component *top,
XFE_View *view):
XFE_PropertyTabView(top, view, XFE_AB_NAME_GENERAL_TAB)
{
int ac, numForms = AB_LAST+2;
Arg av[20];
Widget topForm = getBaseWidget(),
label = NULL,
stripForm[AB_LAST+2];
char *genTabLabels[AB_LAST+1];
Dimension width;
genTabLabels[AB_FIRST_NAME] = XP_GetString(XFE_AB_FIRSTNAME);
genTabLabels[AB_LAST_NAME] = XP_GetString(XFE_AB_LASTNAME);
genTabLabels[AB_DISPLAY_NAME] = XP_GetString(XFE_AB_DISPLAYNAME);
genTabLabels[AB_EMAIL] = XP_GetString(XFE_AB_EMAIL);
genTabLabels[AB_NICKNAME] = XP_GetString(XFE_AB_NICKNAME);
genTabLabels[AB_TITLE] = XP_GetString(XFE_AB_TITLE);
genTabLabels[AB_COMPANY_NAME] = XP_GetString(XFE_AB_COMPANY);
genTabLabels[AB_LAST] = XP_GetString(XFE_AB_NOTES);
int i; // for use in multiple for loops...
// without breaking newer ANSI C++ rules
for (i=0; i < numForms; i++) {
ac = 0;
stripForm[i] = XmCreateForm(topForm, "strip", av, ac);
if (i < (AB_LAST+1)) {
/* Create labels
*/
label = XtVaCreateManagedWidget (genTabLabels[i],
xmLabelGadgetClass, stripForm[i],
XmNalignment, XmALIGNMENT_END,
NULL);
m_labels[i] = label;
XtVaSetValues(label,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_FORM,
0);
XtVaGetValues(label,
XmNwidth, &width,
0);
m_labelWidth = (m_labelWidth < width)?width:m_labelWidth;
/* TextF / Text
*/
if (i < AB_LAST) {
/* TextF
*/
ac = 0;
m_textFs[i] = fe_CreateTextField(stripForm[i],
(char *) genTabLabels[i],
av, ac);
XtVaSetValues(m_textFs[i],
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
0);
XtManageChild(m_textFs[i]);
}/* if */
else {
/* Text
*/
ac = 0;
XtSetArg (av[ac], XmNheight, 100); ac++;
XtSetArg (av[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
m_notesTxt = fe_CreateText(stripForm[i], "notesText", av, ac);
XtVaSetValues(m_notesTxt,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
0);
XtManageChild(m_notesTxt);
}/* else */
}/* if */
else {
/* the toggle */
XmString xmstr;
xmstr = XmStringCreate(XP_GetString(XFE_AB_PREFHTML),
XmFONTLIST_DEFAULT_TAG);
ac = 0;
XtSetArg (av[ac], XmNlabelString, xmstr); ac++;
m_prefHTMLTog = XmCreateToggleButton(stripForm[i], "prefHTMLTog",
av, ac);
XtVaSetValues(m_prefHTMLTog,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, m_labelWidth,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_FORM,
0);
XtManageChild(m_prefHTMLTog);
}/* else */
if (i == 0)
XtVaSetValues(stripForm[i],
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 10,
0);
else
XtVaSetValues(stripForm[i],
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, stripForm[i-1],
XmNtopOffset, (i == AB_TITLE ||
i == AB_EMAIL ||
i == AB_LAST)?10:3,
0);
XtManageChild(stripForm[i]);
}/* for i */
for (i=0; i < (AB_LAST+1); i++) {
XtVaSetValues(m_labels[i],
XmNwidth, m_labelWidth,
0);
}/* for i */
}
Widget CreatePcpTools (Widget FM)
/************************************************************************
*
*_Title CreatePcpTools - Create PCP tools at bottom of display window.
*
*_Args Type Variable I/O Description
*_Parm Widget FM I Main Form id
*_Parm Widget CreatePcpTools O Output PCP tool widget id
*_Hist Nov 10 2001 Janet Barrett, USGS Flagstaff, Original Version
*
*_End
***********************************************************************/
{
Widget liteClue;
Widget FM2;
Widget RC,RC1,RC2,RC3,RC4,RC5,RC6,RC7;
Widget PB;
Widget RB;
Widget LB;
Widget FR1,FR2,FR,FRL,FRR;
static Widget pcplist[15];
Pixmap pmap;
unsigned long fg,bg;
unsigned long fg2,bg2;
XmString xstring;
char *sptr;
XFontStruct *font1;
XmFontList fontlist;
XColor closest;
XColor exact;
font1 = XLoadQueryFont (xinfo.display,
"-adobe-courier-medium-r-normal--12-100-100-100-m-90-iso8859-1");
fontlist = XmFontListCreate (font1,"charset1");
sptr = (char *) GBLwork.work[0];
bg2 = WhitePixelOfScreen (xinfo.screen);
fg2 = BlackPixelOfScreen (xinfo.screen);
liteClue = XtCreatePopupShell("popup_shell",xcgLiteClueWidgetClass,
xinfo.topShell,NULL,0);
XAllocNamedColor(xinfo.display,xinfo.cmap,"lightyellow",
&closest,&exact);
XtVaSetValues (liteClue,XmNbackground,closest.pixel,NULL);
XtVaSetValues (liteClue,XmNforeground,fg2,NULL);
/**************************************************************************
* Get the background and foreground colors used by the parent widget and
* then create the row/column for the tool bar
**************************************************************************/
XtVaGetValues (FM,XmNbackground,&bg,
XmNforeground,&fg,
NULL);
FM2 = XmCreateForm (FM,"PcpTools",NULL,0);
FRL = XmCreateFrame (FM2,"FRL",NULL,0);
XtVaSetValues (FRL,XmNshadowType,XmSHADOW_ETCHED_IN,
XmNtopAttachment,XmATTACH_FORM,
XmNbottomAttachment,XmATTACH_FORM,
XmNleftAttachment,XmATTACH_FORM,
/* XmNmarginHeight,5,
XmNmarginWidth,5,*/
NULL);
XtManageChild (FRL);
FRR = XmCreateFrame (FM2,"FRR",NULL,0);
XtVaSetValues (FRR,XmNshadowType,XmSHADOW_ETCHED_IN,
XmNtopAttachment,XmATTACH_FORM,
XmNbottomAttachment,XmATTACH_FORM,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,FRL,
XmNrightAttachment,XmATTACH_FORM,
/* XmNmarginHeight,5,
XmNmarginWidth,5,*/
NULL);
XtManageChild (FRR);
RC = XmCreateRowColumn (FRL,"RC",NULL,0);
XtVaSetValues (RC,XmNorientation,XmHORIZONTAL,
NULL);
XtManageChild (RC);
RC1 = XmCreateRowColumn (RC,"RC1",NULL,0);
XtVaSetValues (RC1,XmNorientation,XmVERTICAL,
/* XmNspacing,5,*/
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,RC,
XmNbottomAttachment,XmATTACH_WIDGET,
XmNbottomWidget,RC,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC,
/* XmNmarginHeight,5,
XmNmarginWidth,25,*/
NULL);
XtManageChild (RC1);
RC2 = XmCreateRowColumn (RC1,"RC2",NULL,0);
XtVaSetValues (RC2,XmNorientation,XmHORIZONTAL,
XmNspacing,6,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,RC1,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC1,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC1,
NULL);
XtManageChild (RC2);
RC3 = XmCreateRowColumn (RC1,"RC3",NULL,0);
XtVaSetValues (RC3,XmNorientation,XmHORIZONTAL,
/* XmNspacing,120,*/
XmNspacing,13,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,RC2,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC1,
XmNbottomAttachment,XmATTACH_WIDGET,
XmNbottomWidget,RC1,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC1,
NULL);
XtManageChild (RC3);
FR = XmCreateFrame (RC1,"FR",NULL,0);
XtVaSetValues (FR,XmNshadowType,XmSHADOW_ETCHED_IN,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,RC3,
XmNbottomAttachment,XmATTACH_WIDGET,
XmNbottomWidget,RC1,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC1,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC1,
/* XmNmarginHeight,5,
XmNmarginWidth,5,*/
NULL);
XtManageChild (FR);
RC4 = XmCreateRowColumn (FR,"RC4",NULL,0);
XtVaSetValues (RC4,XmNorientation,XmHORIZONTAL,
XmNradioBehavior,True,
XmNradioAlwaysOne,True,
NULL);
XtManageChild (RC4);
RC5 = XmCreateRowColumn (FRR,"RC5",NULL,0);
XtVaSetValues (RC5,XmNorientation,XmVERTICAL,
/* XmNspacing,10,*/
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,FRR,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,FRR,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,FRR,
XmNbottomAttachment,XmATTACH_WIDGET,
XmNbottomWidget,FRR,
/* XmNmarginHeight,5,
XmNmarginWidth,35,*/
NULL);
XtManageChild (RC5);
RC7 = XmCreateRowColumn (RC5,"RC7",NULL,0);
XtVaSetValues (RC7,XmNorientation,XmHORIZONTAL,
NULL);
XtManageChild (RC7);
/* FR1 = XmCreateFrame (RC7,"FR1",NULL,0);
XtVaSetValues (FR1,XmNshadowType,XmSHADOW_ETCHED_IN,
XmNbottomAttachment,XmATTACH_WIDGET,
XmNbottomWidget,RC7,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC7,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,RC7,
NULL);
XtManageChild (FR1);*/
FR2 = XmCreateFrame (RC7,"FR2",NULL,0);
XtVaSetValues (FR2,XmNshadowType,XmSHADOW_ETCHED_IN,
XmNbottomAttachment,XmATTACH_WIDGET,
XmNbottomWidget,RC7,
/* XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,FR1,*/
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,RC7,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC7,
NULL);
XtManageChild (FR2);
/* RC6 = XmCreateRowColumn (FR1,"RC6",NULL,0);
XtVaSetValues (RC6,XmNorientation,XmHORIZONTAL,
XmNradioBehavior,True,
XmNradioAlwaysOne,True,
NULL);
XtManageChild (RC6);*/
RC7 = XmCreateRowColumn (FR2,"RC7",NULL,0);
XtVaSetValues (RC7,XmNorientation,XmHORIZONTAL,
XmNradioBehavior,True,
XmNradioAlwaysOne,True,
NULL);
XtManageChild (RC7);
/**************************************************************************
* Create the go pushbutton
**************************************************************************/
XAllocNamedColor(xinfo.display,xinfo.cmap,"green",
&closest,&exact);
pmap = XCreatePixmapFromBitmapData (xinfo.display,xinfo.root,
(char *)go_bits,go_width,go_height,
closest.pixel,bg,xinfo.depth);
/* fg,bg,xinfo.depth);*/
PB = XmCreateDrawnButton (RC2,"goPB",NULL,0);
XtVaSetValues (PB,XmNlabelPixmap,pmap,
XmNlabelType,XmPIXMAP,
XmNpushButtonEnabled,True,
XmNuserData,((int) V_GO_BTN),
XmNalignment,XmALIGNMENT_CENTER,
XmNwidth,31,
XmNheight,31,
NULL);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
XcgLiteClueAddWidget(liteClue,PB,"Start NR Iteration",0,0);
pcplist[1] = PB;
/**************************************************************************
* Create the go 1 step pushbutton
**************************************************************************/
XAllocNamedColor(xinfo.display,xinfo.cmap,"green",
&closest,&exact);
pmap = XCreatePixmapFromBitmapData (xinfo.display,xinfo.root,
(char *)go1_bits,go1_width,go1_height,
closest.pixel,bg,xinfo.depth);
/* fg,bg,xinfo.depth);*/
PB = XmCreateDrawnButton (RC2,"go1PB",NULL,0);
XtVaSetValues (PB,XmNlabelPixmap,pmap,
XmNlabelType,XmPIXMAP,
XmNpushButtonEnabled,True,
XmNuserData,((int) V_GO1_BTN),
XmNalignment,XmALIGNMENT_CENTER,
XmNwidth,31,
XmNheight,31,
NULL);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
XcgLiteClueAddWidget(liteClue,PB,"Do 1 NR Step",0,0);
pcplist[2] = PB;
/**************************************************************************
* Create the pause pushbutton
**************************************************************************/
pmap = XCreatePixmapFromBitmapData (xinfo.display,xinfo.root,
(char *)pause_bits,pause_width,pause_height,
fg,bg,xinfo.depth);
PB = XmCreateDrawnButton (RC2,"pausePB",NULL,0);
XtVaSetValues (PB,XmNlabelPixmap,pmap,
XmNlabelType,XmPIXMAP,
XmNpushButtonEnabled,True,
XmNuserData,((int) V_PAUSE_BTN),
XmNalignment,XmALIGNMENT_CENTER,
XmNwidth,31,
XmNheight,31,
NULL);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
XcgLiteClueAddWidget(liteClue,PB,"Stop NR Iteration",0,0);
pcplist[3] = PB;
/**************************************************************************
* Create the resolution down pushbutton
**************************************************************************/
XAllocNamedColor(xinfo.display,xinfo.cmap,"lightgoldenrod1",
&closest,&exact);
pmap = XCreatePixmapFromBitmapData (xinfo.display,xinfo.root,
(char *)resdn_bits,resdn_width,resdn_height,
closest.pixel,bg,xinfo.depth);
/* fg,bg,xinfo.depth);*/
PB = XmCreateDrawnButton (RC2,"resdnPB",NULL,0);
XtVaSetValues (PB,XmNlabelPixmap,pmap,
XmNlabelType,XmPIXMAP,
XmNpushButtonEnabled,True,
XmNuserData,((int) V_RESDN_BTN),
XmNalignment,XmALIGNMENT_CENTER,
XmNwidth,31,
XmNheight,31,
NULL);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
XcgLiteClueAddWidget(liteClue,PB,"Decrease Res",0,0);
pcplist[4] = PB;
/**************************************************************************
* Create the resolution up pushbutton
**************************************************************************/
XAllocNamedColor(xinfo.display,xinfo.cmap,"lightskyblue",
&closest,&exact);
pmap = XCreatePixmapFromBitmapData (xinfo.display,xinfo.root,
(char *)resup_bits,resup_width,resup_height,
closest.pixel,bg,xinfo.depth);
/* fg,bg,xinfo.depth);*/
PB = XmCreateDrawnButton (RC2,"resupPB",NULL,0);
XtVaSetValues (PB,XmNlabelPixmap,pmap,
XmNlabelType,XmPIXMAP,
XmNpushButtonEnabled,True,
XmNuserData,((int) V_RESUP_BTN),
XmNalignment,XmALIGNMENT_CENTER,
XmNwidth,31,
XmNheight,31,
NULL);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
XcgLiteClueAddWidget(liteClue,PB,"Increase Res",0,0);
XtSetSensitive(PB,False);
pcplist[5] = PB;
/**************************************************************************
* Create the Done pushbutton
**************************************************************************/
XAllocNamedColor(xinfo.display,xinfo.cmap,"red",&closest,&exact);
pmap = XCreatePixmapFromBitmapData (xinfo.display,xinfo.root,
(char *)stop_bits,stop_width,stop_height,
closest.pixel,bg,xinfo.depth);
/* fg,bg,xinfo.depth);*/
PB = XmCreateDrawnButton (RC2,"stopPB",NULL,0);
XtVaSetValues (PB,XmNlabelPixmap,pmap,
XmNlabelType,XmPIXMAP,
XmNpushButtonEnabled,True,
XmNuserData,((int) V_DONE_BTN),
XmNalignment,XmALIGNMENT_CENTER,
XmNwidth,31,
XmNheight,31,
NULL);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
XcgLiteClueAddWidget(liteClue,PB,"Exit Program",0,0);
pcplist[6] = PB;
/**************************************************************************
* Create the Back (undo) pushbutton
**************************************************************************/
pmap = XCreatePixmapFromBitmapData (xinfo.display,xinfo.root,
(char *)back_bits,back_width,back_height,
fg,bg,xinfo.depth);
PB = XmCreateDrawnButton (RC2,"backPB",NULL,0);
XtVaSetValues (PB,XmNlabelPixmap,pmap,
XmNlabelType,XmPIXMAP,
XmNpushButtonEnabled,True,
XmNuserData,((int) V_BACK_BTN),
XmNalignment,XmALIGNMENT_CENTER,
XmNwidth,31,
XmNheight,31,
NULL);
XtSetSensitive(PB,False);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
XcgLiteClueAddWidget(liteClue,PB,"Undo 1 NR Step",0,0);
pcplist[7] = PB;
/**************************************************************************
* Create the Azimuth of Characteristics text field
**************************************************************************/
charazLB = XmCreateLabel (RC5,"Az of Characteristics=",NULL,0);
sprintf(sptr,"Az of Characteristics=%f",charazgrid);
xstring = XmStringCreateSimple(sptr);
XtVaSetValues (charazLB,XmNfontList,fontlist,
XmNlabelString,xstring,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,RC5,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC5,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC5,
XmNmarginHeight,0,
XmNmarginWidth,0,
NULL);
XtManageChild (charazLB);
XmStringFree(xstring);
/**************************************************************************
* Create the Resolution factor text field
**************************************************************************/
fmagLB = XmCreateLabel (RC5,"Resolution factor=1",NULL,0);
sprintf(sptr,"Resolution factor=1");
xstring = XmStringCreateSimple(sptr);
XtVaSetValues (fmagLB,XmNfontList,fontlist,
XmNlabelString,xstring,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,charazLB,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC5,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC5,
XmNmarginHeight,0,
XmNmarginWidth,0,
NULL);
XtManageChild (fmagLB);
XmStringFree(xstring);
/**************************************************************************
* Create the RMS right hand side and B error text field
**************************************************************************/
rmsrhsberLB = XmCreateLabel (RC5,"RMS righthand side,B error=",NULL,0);
sprintf(sptr,"RMS righthand side,B error=");
xstring = XmStringCreateSimple(sptr);
XtVaSetValues (rmsrhsberLB,XmNfontList,fontlist,
XmNlabelString,xstring,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,fmagLB,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC5,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC5,
XmNmarginHeight,0,
XmNmarginWidth,0,
NULL);
XtManageChild (rmsrhsberLB);
XmStringFree(xstring);
/**************************************************************************
* Create the Dip,Az of dip (degrees) text field
**************************************************************************/
dipLB = XmCreateLabel (RC5,"Dip,Az of dip (degrees)=",NULL,0);
sprintf(sptr,"Dip,Az of dip (degrees)=");
xstring = XmStringCreateSimple(sptr);
XtVaSetValues (dipLB,XmNfontList,fontlist,
XmNlabelString,xstring,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,rmsrhsberLB,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC5,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC5,
XmNmarginHeight,0,
XmNmarginWidth,0,
NULL);
XtManageChild (dipLB);
XmStringFree(xstring);
/**************************************************************************
* Create the Slope of plane toward Sun in degrees text field
**************************************************************************/
plnslpLB = XmCreateLabel (RC5,"Slope of plane toward Sun (degrees)=",NULL,0);
sprintf(sptr,"Slope of plane toward Sun (degrees)=");
xstring = XmStringCreateSimple(sptr);
XtVaSetValues (plnslpLB,XmNfontList,fontlist,
XmNlabelString,xstring,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,dipLB,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC5,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC5,
XmNmarginHeight,0,
XmNmarginWidth,0,
NULL);
XtManageChild (plnslpLB);
XmStringFree(xstring);
/**************************************************************************
* Create the RMS residual to fit in meters,pixels text field
**************************************************************************/
rmsresLB = XmCreateLabel (RC5,"RMS residual to fit (m,pixels)=",NULL,0);
sprintf(sptr,"RMS residual to fit (m,pixels)=");
xstring = XmStringCreateSimple(sptr);
XtVaSetValues (rmsresLB,XmNfontList,fontlist,
XmNlabelString,xstring,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,plnslpLB,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC5,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC5,
XmNmarginHeight,0,
XmNmarginWidth,0,
NULL);
XtManageChild (rmsresLB);
XmStringFree(xstring);
/**************************************************************************
* Create the Hints text field
**************************************************************************/
hintsLB = XmCreateLabel (RC5,"Hints/Errors:",NULL,0);
sprintf(sptr,"Hints/Errors:");
xstring = XmStringCreateSimple(sptr);
XtVaSetValues (hintsLB,XmNfontList,fontlist,
XmNlabelString,xstring,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,rmsresLB,
XmNbottomAttachment,XmATTACH_WIDGET,
XmNbottomWidget,RC5,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC5,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC5,
XmNmarginHeight,0,
XmNmarginWidth,0,
NULL);
XtManageChild (hintsLB);
XmStringFree(xstring);
/**************************************************************************
* Create the Errors text field
**************************************************************************/
/* errorsLB = XmCreateLabel (RC5,"Errors:",NULL,0);
sprintf(sptr,"Errors:");
xstring = XmStringCreateSimple(sptr);
XtVaSetValues (errorsLB,XmNfontList,fontlist,
XmNlabelString,xstring,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget,hintsLB,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget,RC5,
XmNrightAttachment,XmATTACH_WIDGET,
XmNrightWidget,RC5,
XmNmarginHeight,0,
XmNmarginWidth,0,
NULL);
XtManageChild (errorsLB);
XmStringFree(xstring);
*/
/**************************************************************************
* Create the Smooth (Boxcar) pushbutton
**************************************************************************/
/* PB = XmCreatePushButton (RC5,"Smooth",NULL,0);
XtVaSetValues (PB,XmNuserData,((int) V_SMOOTH_BTN),
XmNfontList,fontlist,
NULL);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
pcplist[7] = PB;*/
/**************************************************************************
* Create the Parameters pushbutton
**************************************************************************/
/* PB = XmCreatePushButton (RC5,"Parameters",NULL,0);
XtVaSetValues (PB,XmNuserData,((int) V_PARAM_BTN),
XmNfontList,fontlist,
NULL);
XtManageChild (PB);
XtAddCallback (PB,XmNactivateCallback,CBtoolPcpPB,(XtPointer) pcplist);
pcplist[8] = PB;*/
/**************************************************************************
* Create the Relaxation slider bar
**************************************************************************/
WMAXslider = XmCreateScale (RC3,"relaxSB",NULL,0);
XtVaSetValues (WMAXslider,XmNminimum,0,
XmNmaximum,20,
XmNdecimalPoints,1,
XmNvalue,10,
XmNshowValue,True,
XmNorientation,XmHORIZONTAL,
XtVaTypedArg,XmNtitleString,XmRString,
"Relaxation",11,
XmNfontList,fontlist,
NULL);
XtManageChild (WMAXslider);
/**************************************************************************
* Create the Maximum SOR step slider bar
**************************************************************************/
ITMAXslider = XmCreateScale (RC3,"maxsorSB",NULL,0);
XtVaSetValues (ITMAXslider,XmNminimum,1,
XmNmaximum,30,
XmNvalue,15,
XmNshowValue,True,
XmNorientation,XmHORIZONTAL,
XtVaTypedArg,XmNtitleString,XmRString,
"Max SOR Steps",14,
XmNfontList,fontlist,
NULL);
XtManageChild (ITMAXslider);
/**************************************************************************
* Create the Solution Type label
**************************************************************************/
LB = XmCreateLabel (RC4,"Solution Type:",NULL,0);
XtVaSetValues (LB,XmNalignment,XmALIGNMENT_BEGINNING,
XmNfontList,fontlist,
NULL);
XtManageChild (LB);
/**************************************************************************
* Create the SOR toggle button
**************************************************************************/
SORbtn = XmCreateToggleButton (RC4,"SOR",NULL,0);
XtVaSetValues (SORbtn,XmNuserData,((int) V_SOR_BTN),
XmNfontList,fontlist,
NULL);
XmToggleButtonSetState(SORbtn,True,False);
XtManageChild (SORbtn);
pcplist[8] = SORbtn;
/**************************************************************************
* Create the DIR toggle button
**************************************************************************/
DIRbtn = XmCreateToggleButton (RC4,"Direct",NULL,0);
XtVaSetValues (DIRbtn,XmNuserData,((int) V_DIRECT_BTN),
XmNfontList,fontlist,
NULL);
XtSetSensitive(DIRbtn,True);
XtManageChild (DIRbtn);
pcplist[9] = DIRbtn;
/**************************************************************************
* Create the CGM toggle button
**************************************************************************/
CGMbtn = XmCreateToggleButton (RC4,"CGM",NULL,0);
XtVaSetValues (CGMbtn,XmNuserData,((int) V_CGM_BTN),
XmNfontList,fontlist,
NULL);
XtSetSensitive(CGMbtn,False);
XtManageChild (CGMbtn);
pcplist[10] = CGMbtn;
/**************************************************************************
* Create the Display label
**************************************************************************/
/* LB = XmCreateLabel (RC6,"Display:",NULL,0);
XtVaSetValues (LB,XmNalignment,XmALIGNMENT_BEGINNING,
XmNfontList,fontlist,
NULL);
XtManageChild (LB);*/
/**************************************************************************
* Create the Display On toggle button
**************************************************************************/
/* DSPONbtn = XmCreateToggleButton (RC6,"On",NULL,0);
XtVaSetValues (DSPONbtn,XmNuserData,((int) V_DSPON_BTN),
XmNfontList,fontlist,
NULL);
XmToggleButtonSetState(DSPONbtn,True,False);
XtManageChild (DSPONbtn);
pcplist[11] = DSPONbtn;*/
/**************************************************************************
* Create the Display Off toggle button
**************************************************************************/
/* DSPOFFbtn = XmCreateToggleButton (RC6,"Off",NULL,0);
XtVaSetValues (DSPOFFbtn,XmNuserData,((int) V_DSPOFF_BTN),
XmNfontList,fontlist,
NULL);
XtSetSensitive(DSPOFFbtn,False);
XtManageChild (DSPOFFbtn);
pcplist[12] = DSPOFFbtn;*/
/**************************************************************************
* Create the Inject label
**************************************************************************/
LB = XmCreateLabel (RC7,"Inject:",NULL,0);
XtVaSetValues (LB,XmNalignment,XmALIGNMENT_BEGINNING,
XmNfontList,fontlist,
NULL);
XtManageChild (LB);
/**************************************************************************
* Create the Inject Exact toggle button
**************************************************************************/
EXACTbtn = XmCreateToggleButton (RC7,"Exact",NULL,0);
XtVaSetValues (EXACTbtn,XmNuserData,((int) V_EXACT_BTN),
XmNfontList,fontlist,
NULL);
XmToggleButtonSetState(EXACTbtn,True,False);
XtManageChild (EXACTbtn);
pcplist[13] = EXACTbtn;
/**************************************************************************
* Create the Inject Fast toggle button
**************************************************************************/
FASTbtn = XmCreateToggleButton (RC7,"Fast",NULL,0);
XtVaSetValues (FASTbtn,XmNuserData,((int) V_FAST_BTN),
XmNfontList,fontlist,
NULL);
XtSetSensitive(FASTbtn,True);
XtManageChild (FASTbtn);
pcplist[14] = FASTbtn;
return FM2;
}
/* -------------------------------------------------------------------- */
static void CreateSpectrumWindow()
{
Widget optRC, frame, plRC, rc, RC[8], b[8], pb;
Cardinal n;
Arg args[8];
if (SpectrumWindow)
return;
n = 0;
SpecShell = XtCreatePopupShell("specShell", topLevelShellWidgetClass,
AppShell, args, n);
n = 0;
SpectrumWindow = XmCreateForm(SpecShell, "specForm", args, n);
/* RC for Options.
*/
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
optRC = XmCreateRowColumn(SpectrumWindow, "specOptForm", args, n);
XtManageChild(optRC);
/* Command buttons.
*/
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, optRC); n++;
frame = XmCreateFrame(SpectrumWindow, "buttonFrame", args, n);
XtManageChild(frame);
n = 0;
rc = XmCreateRowColumn(frame, "buttonRC", args, n);
XtManageChild(rc);
n = 0;
b[0] = XmCreatePushButton(rc, "dismissButton", args, n);
b[1] = XmCreatePushButton(rc, "printButton", args, n);
b[2] = XmCreatePushButton(rc, "parmsButton", args, n);
b[3] = XmCreatePushButton(rc, "savepngButton", args, n);
XtManageChildren(b, 4);
XtAddCallback(b[0], XmNactivateCallback, SpecWinDown, NULL);
XtAddCallback(b[1], XmNactivateCallback, specPostScript, NULL);
XtAddCallback(b[2], XmNactivateCallback, EditSpecParms, NULL);
#ifdef PNG
XtAddCallback(b[3], XmNactivateCallback, SavePNGspec, NULL);
#endif
/* Create Graphics Canvas
*/
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, frame); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, optRC); n++;
specPlot.canvas = XmCreateDrawingArea(SpectrumWindow, "specCanvas", args,n);
XtManageChild(specPlot.canvas);
n = 0;
frame = XmCreateFrame(optRC, "specDefsFrame", args, 0);
XtManageChild(frame);
n = 0;
RC[0] = XmCreateRadioBox(frame, "specTypeRB", args, n);
n = 0;
typeButts[0] = XmCreateToggleButton(RC[0], "Spectrum", args, n);
typeButts[1] = XmCreateToggleButton(RC[0], "Co-Spectrum", args, n);
typeButts[2] = XmCreateToggleButton(RC[0], "Quadrature", args, n);
typeButts[3] = XmCreateToggleButton(RC[0], "Coherence", args, n);
typeButts[4] = XmCreateToggleButton(RC[0], "Phase", args, n);
typeButts[5] = XmCreateToggleButton(RC[0], "Spectral ratio", args, n);
XtManageChildren(typeButts, 6);
XtAddCallback(typeButts[0],XmNvalueChangedCallback,SpecWinUp,(XtPointer)SPECTRA);
XtAddCallback(typeButts[1],XmNvalueChangedCallback,SpecWinUp,(XtPointer)COSPECTRA);
XtAddCallback(typeButts[2],XmNvalueChangedCallback,SpecWinUp,(XtPointer)QUADRATURE);
XtAddCallback(typeButts[3],XmNvalueChangedCallback,SpecWinUp,(XtPointer)COHERENCE);
XtAddCallback(typeButts[4],XmNvalueChangedCallback,SpecWinUp,(XtPointer)PHASE);
XtAddCallback(typeButts[5],XmNvalueChangedCallback,SpecWinUp,(XtPointer)RATIO);
/* Optional stuff. PreFilter, SegLen, Window, Detrend menus.
*/
n = 0;
frame = XmCreateFrame(optRC, "specDefsFrame", args, 0);
XtManageChild(frame);
n = 0;
RC[1] = XmCreateRowColumn(frame, "specDefsRC", args, n);
dtOpMenu = CreateDropDownMenu(RC[1], "dtOpMenu", detrendInfo);
slOpMenu = CreateDropDownMenu(RC[1], "slOpMenu", segLenInfo);
winOpMenu = CreateDropDownMenu(RC[1], "winOpMenu", windowInfo);
n = 0;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_CENTER); n++;
pb = XmCreatePushButton(RC[1], "Recompute", args, n);
XtManageChild(pb);
XtAddCallback(pb, XmNactivateCallback, SpecWinUp, NULL);
/* Variance widgets.
*/
n = 0;
frame = XmCreateFrame(optRC, "specDefsFrame", args, 0);
XtManageChild(frame);
XtManageChild(XmCreateLabel(frame, "fluxLabel", args, n));
n = 0;
RC[2] = XmCreateRowColumn(frame, "plRCv", args, n);
plRC = XmCreateRowColumn(RC[2], "plRC", args, n);
XtManageChild(XmCreateLabel(plRC, "Start freq", args, n));
sFreq = XmCreateTextField(plRC, "fluxFreq", args, n);
XtManageChild(XmCreateLabel(plRC, "Hz", args, n));
XtManageChild(plRC);
XtManageChild(sFreq);
XtAddCallback(sFreq, XmNlosingFocusCallback, ValidateFloat, (XtPointer)"%g");
XtAddCallback(sFreq, XmNlosingFocusCallback, ComputeBandLimitedVariance,NULL);
XtAddCallback(sFreq, XmNlosingFocusCallback, (XtCallbackProc)PlotSpectrum, NULL);
plRC = XmCreateRowColumn(RC[2], "plRC", args, n);
XtManageChild(XmCreateLabel(plRC, "End freq", args, n));
eFreq = XmCreateTextField(plRC, "fluxFreq", args, n);
XtManageChild(XmCreateLabel(plRC, "Hz", args, n));
XtManageChild(plRC);
XtManageChild(eFreq);
XtAddCallback(eFreq, XmNlosingFocusCallback, ValidateFloat, (XtPointer)"%g");
XtAddCallback(eFreq, XmNlosingFocusCallback, ComputeBandLimitedVariance,NULL);
XtAddCallback(eFreq, XmNlosingFocusCallback, (XtCallbackProc)PlotSpectrum, NULL);
XmTextFieldSetString(sFreq, "0.0");
XmTextFieldSetString(eFreq, "5000.0");
/* Plot Methods.
*/
n = 0;
frame = XmCreateFrame(optRC, "specDefsFrame", args, 0);
XtManageChild(frame);
XtManageChild(XmCreateLabel(frame, "plotMethodLabel", args, n));
n = 0;
RC[3] = XmCreateRowColumn(frame, "plRCv", args, n);
n = 0;
pmOptButt[0] = XmCreateToggleButton(RC[3], "Grid", args,n);
pmOptButt[1] = XmCreateToggleButton(RC[3], "-5/3 (-2/3 x f) slope line", args,n);
pmOptButt[2] = XmCreateToggleButton(RC[3], "Multiply output by frequency", args,n);
pmOptButt[3] = XmCreateToggleButton(RC[3], "Multiply output by freq^(5/3)", args,n);
pmOptButt[4] = XmCreateToggleButton(RC[3], "Wave number scale", args,n);
pmOptButt[5] = XmCreateToggleButton(RC[3], "Wave length scale", args,n);
XtManageChildren(pmOptButt, 6);
XtAddCallback(pmOptButt[0], XmNvalueChangedCallback, ToggleSpecGrid, NULL);
XtAddCallback(pmOptButt[0], XmNvalueChangedCallback, (XtCallbackProc)PlotSpectrum, NULL);
XtAddCallback(pmOptButt[1], XmNvalueChangedCallback, (XtCallbackProc)PlotSpectrum, NULL);
XtAddCallback(pmOptButt[2], XmNvalueChangedCallback, ToggleMultByFreq, NULL);
XtAddCallback(pmOptButt[2], XmNvalueChangedCallback, (XtCallbackProc)PlotSpectrum, NULL);
XtAddCallback(pmOptButt[3], XmNvalueChangedCallback, ToggleMultByFreq, NULL);
XtAddCallback(pmOptButt[3], XmNvalueChangedCallback, (XtCallbackProc)PlotSpectrum, NULL);
XtAddCallback(pmOptButt[4], XmNvalueChangedCallback, ToggleWaveNumberScale, NULL);
XtAddCallback(pmOptButt[4], XmNvalueChangedCallback, (XtCallbackProc)PlotSpectrum, NULL);
XtAddCallback(pmOptButt[5], XmNvalueChangedCallback, ToggleWaveLengthScale, NULL);
XtAddCallback(pmOptButt[5], XmNvalueChangedCallback, (XtCallbackProc)PlotSpectrum, NULL);
XmToggleButtonSetState(pmOptButt[1], true, false);
/* Equal-log interval averaging
*/
n = 0;
frame = XmCreateFrame(optRC, "eliaFrame", args, 0);
XtManageChild(frame);
n = 0;
RC[4] = XmCreateRowColumn(frame, "plRCv", args, n);
n = 0;
pmOptButt[6] = XmCreateToggleButton(RC[4], "Equal-log interval averaging", args,n);
XtManageChild(pmOptButt[6]);
XtAddCallback(pmOptButt[6], XmNvalueChangedCallback, (XtCallbackProc)PlotSpectrum, NULL);
n = 0;
plRC = XmCreateRowColumn(RC[4], "plRC", args, n);
XtManageChild(plRC);
XtManageChild(XmCreateLabel(plRC, "Total number points", args, n));
eliaText = XmCreateTextField(plRC, "eliaText", args, n);
XtManageChild(eliaText);
XmTextFieldSetString(eliaText, "30");
XtAddCallback(eliaText, XmNlosingFocusCallback, ValidateInteger, NULL);
XtAddCallback(eliaText, XmNlosingFocusCallback, (XtCallbackProc)PlotSpectrum, NULL);
/* Time shift.
*/
n = 0;
frame = XmCreateFrame(optRC, "specDefsFrame", args, 0);
XtManageChild(frame);
n = 0;
RC[5] = XmCreateRowColumn(frame, "plRC", args, n);
XtManageChild(XmCreateLabel(RC[5], "Time shift", args, n));
tShift = XmCreateTextField(RC[5], "timeShift", args, n);
XtManageChild(tShift);
XtAddCallback(tShift, XmNlosingFocusCallback, ValidateInteger, NULL);
XtAddCallback(tShift, XmNlosingFocusCallback, SpecWinUp, NULL);
XtManageChild(XmCreateLabel(RC[5], "milliseconds", args, n));
XtManageChild(RC[0]); XtManageChild(RC[1]);
XtManageChild(RC[2]); XtManageChild(RC[3]);
XtManageChild(RC[4]); XtManageChild(RC[5]);
} /* END CREATESPECTRUMWINDOW */
static void
insert_layerview_buttons (Widget menu)
{
int i, s;
LayerButtons *lb;
num_layer_buttons++;
s = num_layer_buttons * sizeof (LayerButtons);
if (layer_button_list)
layer_button_list = (LayerButtons *) realloc (layer_button_list, s);
else
layer_button_list = (LayerButtons *) malloc (s);
lb = layer_button_list + num_layer_buttons - 1;
for (i = 0; i < LB_NUM; i++)
{
static char namestr[] = "Label ";
char *name = namestr;
Widget btn;
name[5] = 'A' + i;
switch (i)
{
case LB_SILK:
name = "Silk";
break;
case LB_RATS:
name = "Rat Lines";
break;
case LB_PINS:
name = "Pins/Pads";
break;
case LB_VIAS:
name = "Vias";
break;
case LB_BACK:
name = "Far Side";
break;
case LB_MASK:
name = "Solder Mask";
break;
}
n = 0;
if (i < MAX_LAYER && i < 9)
{
char buf[20], av[30];
Resource *ar;
XmString as;
sprintf (buf, "Ctrl-%d", i + 1);
as = XmStringCreateLocalized (buf);
stdarg (XmNacceleratorText, as);
ar = resource_create (0);
sprintf (av, "ToggleView(%d)", i + 1);
resource_add_val (ar, 0, strdup (av), 0);
resource_add_val (ar, 0, strdup (av), 0);
ar->flags |= FLAG_V;
sprintf (av, "Ctrl<Key>%d", i + 1);
note_accelerator (av, ar);
stdarg (XmNmnemonic, i + '1');
}
btn = XmCreateToggleButton (menu, name, args, n);
XtManageChild (btn);
XtAddCallback (btn, XmNvalueChangedCallback,
(XtCallbackProc) layer_button_callback, (XtPointer) (size_t) i);
lb->w[i] = btn;
if (i == LB_MASK)
note_widget_flag (btn, XmNset, "showmask");
}
lb->is_pick = 0;
LayersChanged (0, 0, 0, 0);
}
static void
add_resource_to_menu (Widget menu, Resource * node, XtCallbackProc callback)
{
int i, j;
char *v;
Widget sub, btn;
Resource *r;
for (i = 0; i < node->c; i++)
switch (resource_type (node->v[i]))
{
case 101: /* named subnode */
n = 0;
stdarg (XmNtearOffModel, XmTEAR_OFF_ENABLED);
sub = XmCreatePulldownMenu (menu, node->v[i].name, args, n);
XtSetValues (sub, args, n);
n = 0;
stdarg (XmNsubMenuId, sub);
btn = XmCreateCascadeButton (menu, node->v[i].name, args, n);
XtManageChild (btn);
add_resource_to_menu (sub, node->v[i].subres, callback);
break;
case 1: /* unnamed subres */
n = 0;
#if 0
if ((v = resource_value (node->v[i].subres, "fg")))
{
do_color (v, XmNforeground);
}
if ((v = resource_value (node->v[i].subres, "bg")))
{
do_color (v, XmNbackground);
}
if ((v = resource_value (node->v[i].subres, "font")))
{
XFontStruct *fs = XLoadQueryFont (display, v);
if (fs)
{
XmFontList fl =
XmFontListCreate (fs, XmSTRING_DEFAULT_CHARSET);
stdarg (XmNfontList, fl);
}
}
#endif
if ((v = resource_value (node->v[i].subres, "m")))
{
stdarg (XmNmnemonic, v);
}
if ((r = resource_subres (node->v[i].subres, "a")))
{
XmString as = XmStringCreateLocalized (r->v[0].value);
stdarg (XmNacceleratorText, as);
//stdarg(XmNaccelerator, r->v[1].value);
note_accelerator (r->v[1].value, node->v[i].subres);
}
v = "button";
for (j = 0; j < node->v[i].subres->c; j++)
if (resource_type (node->v[i].subres->v[j]) == 10)
{
v = node->v[i].subres->v[j].value;
break;
}
stdarg (XmNlabelString, XmStringCreateLocalized (v));
if (node->v[i].subres->flags & FLAG_S)
{
int nn = n;
stdarg (XmNtearOffModel, XmTEAR_OFF_ENABLED);
sub = XmCreatePulldownMenu (menu, v, args + nn, n - nn);
n = nn;
stdarg (XmNsubMenuId, sub);
btn = XmCreateCascadeButton (menu, "menubutton", args, n);
XtManageChild (btn);
add_resource_to_menu (sub, node->v[i].subres, callback);
}
else
{
Resource *radio = resource_subres (node->v[i].subres, "radio");
char *checked = resource_value (node->v[i].subres, "checked");
char *label = resource_value (node->v[i].subres, "sensitive");
if (radio)
{
ToggleItem *ti = (ToggleItem *) malloc (sizeof (ToggleItem));
ti->next = toggle_items;
ti->group = radio->v[0].value;
ti->item = radio->v[1].value;
ti->callback = callback;
ti->node = node->v[i].subres;
toggle_items = ti;
if (resource_value (node->v[i].subres, "set"))
{
stdarg (XmNset, True);
}
stdarg (XmNindicatorType, XmONE_OF_MANY);
btn = XmCreateToggleButton (menu, "menubutton", args, n);
ti->w = btn;
XtAddCallback (btn, XmNvalueChangedCallback,
(XtCallbackProc) radio_callback,
(XtPointer) ti);
}
else if (checked)
{
if (strchr (checked, ','))
stdarg (XmNindicatorType, XmONE_OF_MANY);
else
stdarg (XmNindicatorType, XmN_OF_MANY);
btn = XmCreateToggleButton (menu, "menubutton", args, n);
XtAddCallback (btn, XmNvalueChangedCallback,
callback, (XtPointer) node->v[i].subres);
}
else if (label && strcmp (label, "false") == 0)
{
stdarg (XmNalignment, XmALIGNMENT_BEGINNING);
btn = XmCreateLabel (menu, "menulabel", args, n);
}
else
{
btn = XmCreatePushButton (menu, "menubutton", args, n);
XtAddCallback (btn, XmNactivateCallback,
callback, (XtPointer) node->v[i].subres);
}
for (j = 0; j < node->v[i].subres->c; j++)
switch (resource_type (node->v[i].subres->v[j]))
{
case 110: /* named value = X resource */
{
char *n = node->v[i].subres->v[j].name;
if (strcmp (n, "fg") == 0)
n = "foreground";
if (strcmp (n, "bg") == 0)
n = "background";
if (strcmp (n, "m") == 0
|| strcmp (n, "a") == 0
|| strcmp (n, "sensitive") == 0)
break;
if (strcmp (n, "checked") == 0)
{
note_widget_flag (btn, XmNset,
node->v[i].subres->v[j].value);
break;
}
if (strcmp (n, "active") == 0)
{
note_widget_flag (btn, XmNsensitive,
node->v[i].subres->v[j].value);
break;
}
XtVaSetValues (btn, XtVaTypedArg,
n,
XtRString,
node->v[i].subres->v[j].value,
strlen (node->v[i].subres->v[j].value) + 1,
NULL);
}
break;
}
XtManageChild (btn);
}
break;
case 10: /* unnamed value */
n = 0;
if (node->v[i].value[0] == '@')
{
if (strcmp (node->v[i].value, "@layerview") == 0)
insert_layerview_buttons (menu);
if (strcmp (node->v[i].value, "@layerpick") == 0)
insert_layerpick_buttons (menu);
if (strcmp (node->v[i].value, "@routestyles") == 0)
lesstif_insert_style_buttons (menu);
}
else if (strcmp (node->v[i].value, "-") == 0)
{
btn = XmCreateSeparator (menu, "sep", args, n);
XtManageChild (btn);
}
else if (i > 0)
{
btn = XmCreatePushButton (menu, node->v[i].value, args, n);
XtManageChild (btn);
}
break;
}
}
void ControlPanelAccessDialog::makeToggles()
{
int i, inst;
Boolean set;
Widget widget, lastwidget = NULL; // NULL stops scary cc warnings
ControlPanel *cp;
Network *network = this->panelManager->getNetwork();
PanelGroupManager * pgm = network->getPanelGroupManager();
char *gname, *pname;
XtUnmanageChild(this->sform);
ListIterator li(this->toggleList[0]);
int size = network->getPanelCount();
if(this->toggleList[0].getSize() > 0)
{
while( (widget = (Widget)li.getNext()) )
XtDestroyWidget(widget);
li.setList(this->toggleList[1]);
while( (widget = (Widget)li.getNext()) )
XtDestroyWidget(widget);
this->toggleList[0].clear();
this->toggleList[1].clear();
}
if(this->separator)
{
XtDestroyWidget(this->separator);
this->separator = NULL;
}
if(this->toggleList[2].getSize() > 0)
{
li.setList(this->toggleList[2]);
while( (widget = (Widget)li.getNext()) )
XtDestroyWidget(widget);
this->toggleList[2].clear();
}
if(size == 0)
return;
for(i = 0; i < size; i++)
{
cp = network->getPanelByIndex(i+1);
inst = cp->getInstanceNumber();
set = this->panelManager->isAccessiblePanel(inst);
pname = (char*)cp->getPanelNameString();
if(IsBlankString(pname))
pname = "Control Panel";
widget = XmCreateToggleButton(this->sform,
pname,
NULL,
0);
XtVaSetValues(widget,
XmNset, set,
XmNindicatorType, XmN_OF_MANY,
XmNalignment, XmALIGNMENT_BEGINNING,
XmNshadowThickness,0,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment,XmATTACH_POSITION,
XmNrightPosition, 80,
XmNtopOffset, 2,
XmNleftOffset, 2,
NULL);
if(i == 0)
XtVaSetValues(widget, XmNtopAttachment,XmATTACH_FORM,NULL);
else
XtVaSetValues(widget,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget, lastwidget,
NULL);
if(this->panelManager->getControlPanel() == cp)
XtVaSetValues(widget,
XmNsensitive, False,
XmNset, False,
NULL);
this->toggleList[0].appendElement((void*)widget);
XtManageChild(widget);
set = cp->isManaged();
widget = XmCreateToggleButton(this->sform,
"...",
NULL,
0);
XtVaSetValues(widget,
XmNuserData, cp,
XmNset, set,
XmNindicatorOn, False,
XmNfillOnSelect, False,
XmNrightAttachment,XmATTACH_FORM,
XmNleftAttachment,XmATTACH_POSITION,
XmNleftPosition, 80,
XmNtopOffset, 2,
XmNleftOffset, 5,
XmNindicatorSize, 1,
XmNspacing, 0,
NULL);
if(i == 0)
XtVaSetValues(widget, XmNtopAttachment,XmATTACH_FORM,NULL);
else
XtVaSetValues(widget,
XmNtopAttachment,XmATTACH_WIDGET,
XmNtopWidget, lastwidget,
NULL);
if(this->panelManager->getControlPanel() == cp)
XtVaSetValues(widget, XmNsensitive, False, NULL);
XtAddCallback(widget,
XmNvalueChangedCallback,
(XtCallbackProc)ControlPanelAccessDialog_OpenPanelCB,
(XtPointer)this);
this->toggleList[1].appendElement((void*)widget);
XtManageChild(widget);
lastwidget = widget;
}
size = pgm->getGroupCount();
if(size == 0)
{
XtManageChild(this->sform);
return;
}
this->separator = XtVaCreateManagedWidget("separator",
xmSeparatorGadgetClass, this->sform,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 2,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 2,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, lastwidget,
XmNtopOffset, 5,
NULL);
for(i = 1; i <= size; i++)
{
gname = (char*)pgm->getPanelGroup(i, NULL);
set = this->panelManager->isAccessibleGroup(gname);
widget = XmCreateToggleButton(this->sform, gname, NULL, 0);
XtVaSetValues(widget,
XmNset, set,
XmNindicatorType, XmN_OF_MANY,
XmNalignment, XmALIGNMENT_BEGINNING,
XmNshadowThickness,0,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopOffset, 2,
XmNleftOffset, 2,
NULL);
if(i == 1)
XtVaSetValues(widget,
XmNtopWidget, this->separator,
XmNtopOffset, 5,
NULL);
else
XtVaSetValues(widget,
XmNtopWidget, lastwidget,
NULL);
this->toggleList[2].appendElement((void*)widget);
XtManageChild(widget);
lastwidget = widget;
}
XtManageChild(this->sform);
}
Widget *XbrMenu(Widget parent, char *title, int menu_type,
XbrMenuData menu_data[], int n)
{
XtAppContext app_context = XtWidgetToApplicationContext(parent);
Widget *widgets;
Boolean radio_behaviour = False;
int i, extras;
Arg args[10];
Cardinal num;
XmString string;
char name[256];
/* Number of extra widgets to create - for a popup this is just the popup
menu but for pulldowns there is the menu and the cascade button.
*/
if(menu_type == XbrMENU_POPUP)
extras = 1;
else
extras = 2;
/* Allocate memory for widgets */
if((widgets = (Widget *) malloc(sizeof(Widget) * (n+extras))) == NULL) {
XtAppError(app_context, "Error - out of memory!\n");
return(NULL);
}
/* Create menu */
switch(menu_type) {
case XbrMENU_POPUP:
sprintf(name, "%sPopup", title);
widgets[MENU] = XmCreatePopupMenu(parent, name, NULL, 0);
break;
case XbrMENU_OPTION:
sprintf(name, "%sPane", title);
widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
num = 0;
string = XmStringCreateLocalized(title);
XtSetArg(args[num], XmNsubMenuId, widgets[MENU]); num++;
XtSetArg(args[num], XmNlabelString, string); num++;
sprintf(name, "%sOption", title);
widgets[CASCADE] = XmCreateOptionMenu(parent, name, args, num);
XmStringFree(string);
XtManageChild(widgets[CASCADE]);
break;
case XbrMENU_PULLDOWN_RADIO:
radio_behaviour = True;
case XbrMENU_PULLDOWN:
sprintf(name, "%sPulldown", title);
widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
XtVaSetValues(widgets[MENU], XmNradioBehavior, radio_behaviour,
NULL);
/* Create menu title */
sprintf(name, "%sCascade", title);
widgets[CASCADE] = XtVaCreateManagedWidget(name,
xmCascadeButtonWidgetClass, parent,
XmNsubMenuId, widgets[MENU],
XtVaTypedArg, XmNlabelString, XmRString,
title, sizeof(char *),
NULL);
break;
default:
XtAppError(app_context, "Unknown menu type!\n");
}
/* Add desired widgets */
for(i = 0; i < n; i++) {
sprintf(name, "%s%d", title, i);
switch(menu_data[i].type) {
/* Label widget - easy */
case XbrLABEL:
string = XmStringCreateLocalized(menu_data[i].label);
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmLabelWidgetClass, widgets[MENU],
XmNlabelString, string,
NULL);
XmStringFree(string);
break;
/* Push button gadget - include activate callback & data */
case XbrPB:
string = XmStringCreateLocalized(menu_data[i].label);
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmPushButtonWidgetClass, widgets[MENU],
XmNlabelString, string,
NULL);
XmStringFree(string);
if(menu_data[i].callback)
XtAddCallback(widgets[i+extras], XmNactivateCallback,
menu_data[i].callback, menu_data[i].data);
if(menu_data[i].set && menu_type == XbrMENU_OPTION)
XtVaSetValues(widgets[CASCADE], XmNmenuHistory,
widgets[i+extras], NULL);
break;
/* Toggle button - include value changed callback & data */
case XbrTOGGLE:
num = 0;
string = XmStringCreateLocalized(menu_data[i].label);
XtSetArg(args[num], XmNlabelString, string); num++;
XtSetArg(args[num], XmNindicatorType, XmONE_OF_MANY); num++;
if(menu_data[i].set != XbrNOSET) {
XtSetArg(args[num], XmNset, menu_data[i].set); num++;
}
widgets[i+extras] = XmCreateToggleButton(widgets[MENU], name,
args, num);
XtManageChild(widgets[i+extras]);
XmStringFree(string);
if(menu_data[i].callback)
XtAddCallback(widgets[i+extras], XmNvalueChangedCallback,
menu_data[i].callback, menu_data[i].data);
break;
/* Separator to make menu look pretty! */
case XbrSEPARATOR:
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmSeparatorWidgetClass, widgets[MENU],
NULL);
break;
/* A sub menu */
case XbrSUBMENU:
widgets[i+extras] = (Widget)XbrMenu(widgets[MENU], menu_data[i].title, menu_data[i].stype,
menu_data[i].submenu, menu_data[i].n);
break;
default:
XtAppError(app_context, "Unknown menu item!\n");
break;
}
}
return(widgets);
}
static void
insert_layerpick_buttons (Widget menu)
{
int i, s;
LayerButtons *lb;
num_layer_buttons++;
s = num_layer_buttons * sizeof (LayerButtons);
if (layer_button_list)
layer_button_list = (LayerButtons *) realloc (layer_button_list, s);
else
layer_button_list = (LayerButtons *) malloc (s);
lb = layer_button_list + num_layer_buttons - 1;
for (i = 0; i < LB_NUMPICK; i++)
{
static char namestr[] = "Label ";
char *name = namestr;
Widget btn;
name[5] = 'A' + i;
switch (i)
{
case LB_SILK:
name = "Silk";
break;
case LB_RATS:
name = "Rat Lines";
break;
}
n = 0;
if (i < MAX_LAYER && i < 9)
{
char buf[20], av[30];
Resource *ar;
XmString as;
sprintf (buf, "%d", i + 1);
as = XmStringCreateLocalized (buf);
stdarg (XmNacceleratorText, as);
ar = resource_create (0);
switch (i)
{
case LB_SILK:
strcpy (av, "SelectLayer(Silk)");
break;
case LB_RATS:
strcpy (av, "SelectLayer(Rats)");
break;
default:
sprintf (av, "SelectLayer(%d)", i + 1);
break;
}
resource_add_val (ar, 0, strdup (av), 0);
resource_add_val (ar, 0, strdup (av), 0);
ar->flags |= FLAG_V;
sprintf (av, "<Key>%d", i + 1);
note_accelerator (av, ar);
stdarg (XmNmnemonic, i + '1');
}
stdarg (XmNindicatorType, XmONE_OF_MANY);
btn = XmCreateToggleButton (menu, name, args, n);
XtManageChild (btn);
XtAddCallback (btn, XmNvalueChangedCallback,
(XtCallbackProc) layerpick_button_callback,
(XtPointer) (size_t) i);
lb->w[i] = btn;
}
lb->is_pick = 1;
LayersChanged (0, 0, 0, 0);
}
void create_netcdfs_popup(Widget, XtPointer, XtPointer)
{
int x, y;
static Widget top, dialog;
Widget wbut, lab, rc, rcl, rc1, rc2, form;
Arg args[3];
set_wait_cursor();
if (top == NULL)
{
char *label1[5];
Widget but1[5];
label1[0] = (char *)"Accept";
label1[1] = (char *)"Files...";
label1[2] = (char *)"Update";
label1[3] = (char *)"Query";
label1[4] = (char *)"Close";
XmGetPos(app_shell, 0, &x, &y);
#ifdef HAVE_MFHDF
top = XmCreateDialogShell(app_shell, (char *)"netCDF/HDF", NULL, 0);
#else
#ifdef HAVE_NETCDF
top = XmCreateDialogShell(app_shell, (char *)"netCDF", NULL, 0);
#endif
#endif
handle_close(top);
XtVaSetValues(top, XmNx, x, XmNy, y, NULL);
dialog = XmCreateRowColumn(top, (char *)"dialog_rc", NULL, 0);
/*
form = XmCreateForm(dialog, "form", NULL, 0);
*/
form = XmCreateRowColumn(dialog, (char *)"form", NULL, 0);
XtVaSetValues(form,
XmNpacking, XmPACK_COLUMN,
XmNnumColumns, 1,
XmNorientation, XmHORIZONTAL,
XmNisAligned, True,
XmNadjustLast, False,
XmNentryAlignment, XmALIGNMENT_END,
NULL);
XtSetArg(args[0], XmNlistSizePolicy, XmRESIZE_IF_POSSIBLE);
XtSetArg(args[1], XmNvisibleItemCount, 5);
rc1 = XmCreateRowColumn(form, (char *)"rc1", NULL, 0);
lab = XmCreateLabel(rc1, (char *)"Select set X:", NULL, 0);
XtManageChild(lab);
netcdf_listx_item = XmCreateScrolledList(rc1, (char *)"list", args, 2);
XtManageChild(netcdf_listx_item);
XtManageChild(rc1);
rc2 = XmCreateRowColumn(form, (char *)"rc2", NULL, 0);
lab = XmCreateLabel(rc2, (char *)"Select set Y:", NULL, 0);
XtManageChild(lab);
netcdf_listy_item = XmCreateScrolledList(rc2, (char *)"list", args, 2);
XtManageChild(netcdf_listy_item);
XtManageChild(rc2);
XtManageChild(form);
netcdf_file_item = CreateTextItem2(dialog, 30, "netCDF file:");
netcdf_set_item = CreateSetChoice(dialog, "Read to set:", maxplot, 4);
netcdf_auto_item = XmCreateToggleButton(dialog, "Autoscale on read", NULL, 0);
XtManageChild(netcdf_auto_item);
XtVaCreateManagedWidget("sep", xmSeparatorWidgetClass, dialog, NULL);
CreateCommandButtons(dialog, 5, but1, label1);
XtAddCallback(but1[0], XmNactivateCallback, (XtCallbackProc)do_netcdf_proc,
(XtPointer)NULL);
XtAddCallback(but1[1], XmNactivateCallback, (XtCallbackProc)create_netcdffiles_popup,
(XtPointer)NULL);
XtAddCallback(but1[2], XmNactivateCallback, (XtCallbackProc)do_netcdfupdate_proc,
(XtPointer)NULL);
XtAddCallback(but1[3], XmNactivateCallback, (XtCallbackProc)do_netcdfquery_proc,
(XtPointer)NULL);
XtAddCallback(but1[4], XmNactivateCallback, (XtCallbackProc)destroy_dialog,
(XtPointer)top);
XtManageChild(dialog);
netcdf_frame = top;
if (strlen(netcdf_name))
{
xv_setstr(netcdf_file_item, netcdf_name);
}
}
update_netcdfs();
XtRaise(top);
unset_wait_cursor();
}
void
main(int argc, char *argv[])
{
int i;
#ifdef IRIX_5_1_MOTIF_BUG_WORKAROUND
/*
* XXX Unfortunately a bug in the IRIX 5.1 Motif shared library
* causes a BadMatch X protocol error if the SGI look&feel
* is enabled for this program. If we detect we are on an
* IRIX 5.1 system, skip the first two fallback resources which
* specify using the SGI look&feel.
*/
struct utsname versionInfo;
if(uname(&versionInfo) >= 0) {
if(!strcmp(versionInfo.sysname, "IRIX") &&
!strncmp(versionInfo.release, "5.1", 3)) {
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
&fallbackResources[2], NULL, 0);
}
}
if(toplevel == NULL) {
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
}
#else
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
#endif
dpy = XtDisplay(toplevel);
/* find an OpenGL-capable RGB visual with depth buffer */
vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
if (vi == NULL) {
vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
if (vi == NULL)
XtAppError(app, "no RGB visual with depth buffer");
doubleBuffer = GL_FALSE;
}
for (i = 0; i < NUM_FONT_ENTRIES; i++) {
fontEntry[i].xfont = XLoadQueryFont(dpy, fontEntry[i].xlfd);
if (i == 0 && !fontEntry[i].xfont)
XtAppError(app, "could not get basic font");
}
fontEntry[0].fontinfo = SuckGlyphsFromServer(dpy, fontEntry[0].xfont->fid);
if (!fontEntry[0].fontinfo)
XtAppError(app, "could not get font glyphs");
/* create an OpenGL rendering context */
cx = glXCreateContext(dpy, vi, /* no display list sharing */ None,
/* favor direct */ GL_TRUE);
if (cx == NULL)
XtAppError(app, "could not create rendering context");
/* create an X colormap since probably not using default visual */
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
vi->visual, AllocNone);
XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth,
XtNcolormap, cmap, NULL);
XtAddEventHandler(toplevel, StructureNotifyMask, False,
map_state_changed, NULL);
mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0);
XtManageChild(mainw);
/* create menu bar */
menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0);
XtManageChild(menubar);
/* hack around Xt's ignorance of visuals */
XtSetArg(menuPaneArgs[0], XmNdepth, DefaultDepthOfScreen(XtScreen(mainw)));
XtSetArg(menuPaneArgs[1],
XmNcolormap, DefaultColormapOfScreen(XtScreen(mainw)));
/* create File pulldown menu: Quit */
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 2);
btn = XmCreatePushButton(menupane, "Quit", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, quit, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "File", args, 1);
XtManageChild(cascade);
/* create Options pulldown menu: Motion, Dolly, Rotate, Wobble */
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 2);
btn = XmCreateToggleButton(menupane, "Motion", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) toggle, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Dolly", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) dolly, NULL);
XtVaSetValues(btn, XmNset, True, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Rotate", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) rotate, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Wobble", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) wobble, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Options", args, 1);
XtManageChild(cascade);
XtSetArg(menuPaneArgs[2], XmNradioBehavior, True);
XtSetArg(menuPaneArgs[3], XmNradioAlwaysOne, True);
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 4);
XtAddCallback(menupane, XmNentryCallback, (XtCallbackProc) fontSelect, NULL);
for (i = 0; i < NUM_FONT_ENTRIES; i++) {
btn = XmCreateToggleButton(menupane, fontEntry[i].name, NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) neverCalled, &fontEntry[i]);
if (i == 0)
XtVaSetValues(btn, XmNset, True, NULL);
if (!fontEntry[i].xfont)
XtSetSensitive(btn, False);
XtManageChild(btn);
}
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Font", args, 1);
XtManageChild(cascade);
/* create framed drawing area for OpenGL rendering */
frame = XmCreateFrame(mainw, "frame", NULL, 0);
XtManageChild(frame);
glxarea = XtCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass,
frame, NULL, 0);
XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc) draw, NULL);
XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
XtAddCallback(glxarea, XmNinputCallback, input, NULL);
/* set up application's window layout */
XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame);
XtRealizeWidget(toplevel);
/*
* Once widget is realized (ie, associated with a created X window), we
* can bind the OpenGL rendering context to the window.
*/
glXMakeCurrent(dpy, XtWindow(glxarea), cx);
made_current = GL_TRUE;
/* setup OpenGL state */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearDepth(1.0);
glMatrixMode(GL_PROJECTION);
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 80);
glMatrixMode(GL_MODELVIEW);
MakeCube();
if (argv[1] != NULL) {
numMessages = argc - 1;
messages = &argv[1];
} else {
numMessages = NUM_DEFAULT_MESSAGES;
messages = defaultMessage;
}
base = glGenLists(numMessages + 1);
SetupMessageDisplayList(&fontEntry[0], numMessages, messages);
tick();
/* start event processing */
XtAppMainLoop(app);
}
main(int argc, char *argv[])
{
toplevel = XtAppInitialize(&app, "Paperplane", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
dpy = XtDisplay(toplevel);
/* find an OpenGL-capable RGB visual with depth buffer */
vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
if (vi == NULL) {
vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
if (vi == NULL)
XtAppError(app, "no RGB visual with depth buffer");
doubleBuffer = GL_FALSE;
}
/* create an OpenGL rendering context */
cx = glXCreateContext(dpy, vi, /* no display list sharing */ None,
/* favor direct */ GL_TRUE);
if (cx == NULL)
XtAppError(app, "could not create rendering context");
/* create an X colormap since probably not using default visual */
#ifdef noGLwidget
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
vi->visual, AllocNone);
/*
* Establish the visual, depth, and colormap of the toplevel
* widget _before_ the widget is realized.
*/
XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth,
XtNcolormap, cmap, NULL);
#endif
XtAddEventHandler(toplevel, StructureNotifyMask, False,
map_state_changed, NULL);
mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0);
XtManageChild(mainw);
/* create menu bar */
menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0);
XtManageChild(menubar);
#ifdef noGLwidget
/* Hack around Xt's unfortunate default visual inheritance. */
XtSetArg(menuPaneArgs[0], XmNvisual, vi->visual);
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
btn = XmCreatePushButton(menupane, "Quit", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, quit, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "File", args, 1);
XtManageChild(cascade);
#ifdef noGLwidget
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
btn = XmCreateToggleButton(menupane, "Motion", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc)toggle, NULL);
XtManageChild(btn);
btn = XmCreatePushButton(menupane, "Add plane", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)add_plane, NULL);
XtManageChild(btn);
btn = XmCreatePushButton(menupane, "Remove plane", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)remove_plane, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Planes", args, 1);
XtManageChild(cascade);
/* create framed drawing area for OpenGL rendering */
frame = XmCreateFrame(mainw, "frame", NULL, 0);
XtManageChild(frame);
#ifdef noGLwidget
glxarea = XtVaCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass,
frame, NULL);
#else
#ifdef noMotifGLwidget
/* notice glwDrawingAreaWidgetClass lacks an 'M' */
glxarea = XtVaCreateManagedWidget("glxarea", glwDrawingAreaWidgetClass,
#else
glxarea = XtVaCreateManagedWidget("glxarea", glwMDrawingAreaWidgetClass,
#endif
frame, GLwNvisualInfo, vi, NULL);
#endif
XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc)draw, NULL);
XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
XtAddCallback(glxarea, XmNinputCallback, input, NULL);
/* set up application's window layout */
XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame);
XtRealizeWidget(toplevel);
/*
* Once widget is realized (ie, associated with a created X window), we
* can bind the OpenGL rendering context to the window.
*/
glXMakeCurrent(dpy, XtWindow(glxarea), cx);
made_current = GL_TRUE;
/* setup OpenGL state */
glClearDepth(1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 20);
glMatrixMode(GL_MODELVIEW);
/* add three initial random planes */
srandom(getpid());
add_plane(); add_plane(); add_plane(); add_plane(); add_plane();
/* start event processing */
toggle();
XtAppMainLoop(app);
}
