Widget create_labeled_textfield(Widget *parent, char *label_string) {
Widget form_widget;
Widget label_widget;
Widget text_widget;
Arg args[8];
int n = 0;
XtSetArg(args[n], XmNfractionBase, 10); n++;
XtSetArg(args[n], XmNnavigationType, XmNONE); n++;
form_widget = XmCreateForm(*parent, "form", 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++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg(args[n], XmNrightPosition, 3); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_END); n++;
XtSetArg(args[n], XmNnavigationType, XmNONE); n++;
label_widget = XmCreateLabelGadget(form_widget, label_string, args, n);
XtManageChild(label_widget);
n = 0;
XtSetArg(args[n], XmNtraversalOn, True); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg(args[n], XmNleftPosition, 4); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
text_widget = XmCreateTextField(form_widget, "text", args, n);
XtManageChild(text_widget);
XtManageChild(form_widget);
return text_widget;
}
main (int argc, char *argv[])
{
Widget toplevel, text_w, form, rowcol, label_w;
XtAppContext app;
int i;
void print_result(Widget, XtPointer, XtPointer);
Arg args[8];
int n;
XtSetLanguageProc (NULL, NULL, NULL);
toplevel = XtVaAppInitialize (&app, "Demos", NULL, 0, &argc, argv, NULL,
sessionShellWidgetClass, NULL);
rowcol = XmCreateRowColumn (toplevel, "rowcol", NULL, 0);
for (i = 0; i < XtNumber (labels); i++) {
n = 0;
XtSetArg (args[n], XmNfractionBase, 10); n++;
XtSetArg (args[n], XmNnavigationType, XmNONE); n++;
form = XmCreateForm (rowcol, "form", 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++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNrightPosition, 3); n++;
XtSetArg (args[n], XmNalignment, XmALIGNMENT_END); n++;
XtSetArg (args[n], XmNnavigationType, XmNONE); n++;
label_w = XmCreateLabelGadget (form, labels[i], args, n);
XtManageChild (label_w);
n = 0;
XtSetArg (args[n], XmNtraversalOn, True); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
XtSetArg (args[n], XmNleftPosition, 4); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNnavigationType, XmTAB_GROUP); n++;
text_w = XmCreateTextField (form, "text_w", args, n);
XtManageChild (text_w);
/* When user hits return, print the label+value of text_w */
XtAddCallback (text_w, XmNactivateCallback, print_result,
(XtPointer) labels[i]);
XtManageChild (form);
}
XtManageChild (rowcol);
XtRealizeWidget (toplevel);
XtAppMainLoop (app);
}
// Override
void
XFE_LdapSearchView::buildHeaderOption()
{
Cardinal ac;
Arg av[20];
Widget popupW;
Dimension width, height;
ac = 0;
m_rules.searchLabel = XmCreateLabelGadget(m_header,
"ldapSearchFolderLabel", av, ac);
m_rules.scopeOptW = fe_make_option_menu(getToplevel()->getBaseWidget(),
m_header, "ldapSearchScopeOpt", &popupW);
// Add folders...
addDefaultFolders();
fe_get_option_size ( m_rules.scopeOptW, &width, &height);
ac = 0;
m_rules.whereLabel = XmCreateLabelGadget(m_header, "where", av, ac);
XtVaSetValues(m_rules.searchLabel, XmNheight, height, 0 );
XtVaSetValues(m_rules.whereLabel, XmNheight, height, 0 );
}
static Widget CreateLabelGadget(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 = XmCreateLabelGadget(parent, label, args, n);
XtManageChild(widget);
XmStringFree(tcs);
return(widget);
}
Widget wid_seper(Widget iw_parent, Widget iw_seper,
char * label, int ix, int iy)
{
int n;
XmString str_label; /* String label */
Arg args[MAX_ARGS]; /* Arg list */
n = 0;
// Note: XmStringCreateLtoR handles newline char oK) if this
// changed to XmStringCreate you will have to solve newline problem
str_label = XmStringCreateLtoR(label,XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, str_label); n++;
XtSetArg(args[n], XmNbackground, 0); n++;
if (iw_seper <= (Widget) 0)
{ // Create seper widget first
if (ix > 0 && iy > 0)
{ // Set label position
XtSetArg(args[n], XmNx, (Position) ix); n++;
XtSetArg(args[n], XmNy, (Position) iy); n++;
}
else
{ // Use default alignment
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
}
iw_seper = XmCreateLabelGadget(iw_parent,"iw_seper",args,n);
}
else
{
XtSetValues(iw_seper,args,n);
}
// Free the String (not doing this may result in a memory leak)
XmStringFree(str_label);
XtManageChild(iw_seper);
return iw_seper;
}
/*************************************<->*************************************
*
* wspCreateLabel (mgrW, pchName, pchString)
*
*
* Description:
* -----------
* Creates a label widget as a child of the passed in manager
*
* Inputs:
* ------
* mgrW = manager widget (parent of this label)
* pchName = name of the widget
* pchString = string that is to be in label
*
* Outputs:
* -------
* Return = Widget created.
*
* Comments:
* ---------
******************************<->***********************************/
static Widget
wspCreateLabel(
Widget mgrW,
unsigned char *pchName,
unsigned char *pchString )
{
Arg setArgs[20];
int i;
Widget labelW;
XmString tmpXmString = (XmString)NULL;
i = 0;
if (!strcmp((char *)pchName, "window"))
{
if (windowLabelString != (XmString)NULL)
XmStringFree(windowLabelString);
if (iconLabelString != (XmString)NULL)
XmStringFree(iconLabelString);
windowLabelString =
XmStringCreateLocalized ((char *)GETMESSAGE(52, 2, "Window: "));
/*
* If we do this, USE the message catalog for iconLabelString
* just as we do for windowLabelString !!!
*/
iconLabelString =
XmStringCreateLocalized ((char *)GETMESSAGE(52, 6, "Icon: "));
XtSetArg (setArgs[i], XmNlabelString, windowLabelString ); i++;
}
else
{
tmpXmString = XmStringCreateLocalized ((char *)pchString);
XtSetArg (setArgs[i], XmNlabelString, tmpXmString); i++;
}
labelW = XmCreateLabelGadget (mgrW, (char *)pchName, setArgs, i);
XtManageChild (labelW);
if (tmpXmString != (XmString)NULL)
XmStringFree(tmpXmString);
return (labelW);
} /* END OF FUNCTION */
void MainWindow::showMotifDialog()
{
QtMotifDialog dialog(this);
dialog.setWindowTitle(tr("Custom Motif Dialog"));
Widget form = XmCreateForm( dialog.shell(), const_cast<char*>("custom motif dialog"), NULL, 0 );
XmString str;
Arg args[9];
str = XmStringCreateLocalized( const_cast<char*>("Close") );
XtSetArg( args[0], XmNlabelString, str );
XtSetArg( args[1], XmNshowAsDefault, True );
XtSetArg( args[2], XmNleftAttachment, XmATTACH_POSITION );
XtSetArg( args[3], XmNleftPosition, 40 );
XtSetArg( args[4], XmNrightAttachment, XmATTACH_POSITION );
XtSetArg( args[5], XmNrightPosition, 60 );
XtSetArg( args[7], XmNbottomAttachment, XmATTACH_FORM );
XtSetArg( args[6], XmNtopOffset, 10 );
XtSetArg( args[8], XmNbottomOffset, 10 );
Widget button = XmCreatePushButton( form, const_cast<char*>("Close"), args, 9 );
XmStringFree( str );
str = XmStringCreateLocalized( const_cast<char*>("This is a custom Motif-based dialog using\nQtMotifDialog with a QWidget-based parent.") );
XtSetArg( args[0], XmNlabelString, str );
XtSetArg( args[1], XmNleftAttachment, XmATTACH_FORM );
XtSetArg( args[2], XmNrightAttachment, XmATTACH_FORM );
XtSetArg( args[3], XmNtopAttachment, XmATTACH_FORM );
XtSetArg( args[4], XmNbottomAttachment, XmATTACH_WIDGET );
XtSetArg( args[5], XmNbottomWidget, button );
XtSetArg( args[6], XmNtopOffset, 10 );
XtSetArg( args[7], XmNbottomOffset, 10 );
Widget label = XmCreateLabelGadget( form, const_cast<char*>("label"), args, 8 );
XmStringFree( str );
XtManageChild( button );
XtManageChild( label );
XtManageChild( form );
XtAddCallback( button, XmNactivateCallback,
(XtCallbackProc) QtMotifDialog::acceptCallback, &dialog );
dialog.exec();
}
Widget
_XmBB_CreateLabelG(
Widget bb,
XmString l_string,
char *name,
XmLabelStringLoc l_loc )
{
Arg al[10] ;
register int ac = 0 ;
Widget label ;
XmString default_label_string_loc = NULL;
/****************/
if( l_string )
{
XtSetArg( al[ac], XmNlabelString, l_string) ; ac++ ;
}
else
{
default_label_string_loc = XmStringCreate(GetLabelString(l_loc),
XmFONTLIST_DEFAULT_TAG);
XtSetArg( al[ac], XmNlabelString, default_label_string_loc); ac++;
}
XtSetArg( al[ac], XmNstringDirection, BB_StringDirection( bb)) ; ac++ ;
XtSetArg( al[ac], XmNhighlightThickness, 0) ; ac++ ;
XtSetArg( al[ac], XmNtraversalOn, False) ; ac++ ;
XtSetArg( al[ac], XmNalignment, XmALIGNMENT_BEGINNING) ; ac++ ;
label = XmCreateLabelGadget( bb, name, al, ac);
if (default_label_string_loc)
XmStringFree(default_label_string_loc);
return( label ) ;
}
static Widget
h_create_fonts_frame(Widget top, struct topic_info *info)
{
Widget darkness_form, darkness_label;
UNUSED(info);
darkness_form = XmCreateForm(top, "darkness_form", NULL, 0);
XtVaSetValues(darkness_form,
XmNverticalSpacing, 10,
XmNhorizontalSpacing, 10,
NULL);
darkness_label = XmCreateLabelGadget(darkness_form, "Font Darkness: ", NULL, 0);
XtVaSetValues(darkness_label,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XtManageChild(darkness_label);
{
Widget darkness_text;
#if USE_SPINBOX
Widget darkness_spinbox = XmCreateSpinBox(darkness_form, Xdvi_DARKNESS_SPINBOX, NULL, 0);
darkness_text = XmCreateTextField(darkness_spinbox, Xdvi_DARKNESS_TEXT, NULL, 0);
XtVaSetValues(darkness_spinbox,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, darkness_label,
XmNinitialDelay, 200,
XmNrepeatDelay, 50,
NULL);
XtVaSetValues(darkness_text,
XmNspinBoxChildType, XmNUMERIC,
XmNminimumValue, 0,
XmNmaximumValue, 1000,
XmNeditable, True,
XmNcolumns, 4,
XmNincrementValue, 1,
XmNwrap, False, /* too confusing */
XmNposition, (int)(resource.gamma * 100.0 + 0.5),
NULL);
XtAddCallback(darkness_text, XmNactivateCallback, darkness_text_cb, (XtPointer)info);
XtAddCallback(darkness_text, XmNvalueChangedCallback, darkness_text_cb, (XtPointer)info);
adjust_heights(darkness_spinbox, darkness_text, darkness_label, NULL);
XtManageChild(darkness_text);
XtManageChild(darkness_spinbox);
#else
char buf[LENGTH_OF_INT];
Widget darkness_button;
darkness_text = XmCreateTextField(darkness_form, Xdvi_DARKNESS_TEXT, NULL, 0);
SNPRINTF(buf, LENGTH_OF_INT, "%d", (int)(resource.gamma * 100.0 + 0.5));
XtVaSetValues(darkness_text,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, darkness_label,
XmNcolumns, 4,
XmNvalue, buf,
XmNuserData, darkness_text,
NULL);
XtOverrideTranslations(darkness_text, XtParseTranslationTable("<Key>Return:activate()"));
XtAddCallback(darkness_text, XmNactivateCallback, darkness_text_cb, (XtPointer)info);
darkness_button = XmCreatePushButton(darkness_form, Xdvi_APPLY_STR, NULL, 0);
XtVaSetValues(darkness_button,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, darkness_text,
XmNuserData, darkness_text,
NULL);
XtAddCallback(darkness_button, XmNactivateCallback, darkness_text_cb, (XtPointer)info);
adjust_heights(darkness_label, darkness_text, darkness_button, NULL);
XtManageChild(darkness_text);
XtManageChild(darkness_button);
#endif
}
/* XtManageChild(darkness_form); */
return darkness_form;
}
static Widget createContents(Widget parent, SpaceWindow *window,
int hasEventBar, char *eventBarText)
{
Arg args[50];
int ac;
XmString s1, s2;
char ctmp[10];
Widget form, displayMode, stability, particleType, rotation, stats;
Widget formt1, allSliders;
Widget controls, trackInfoFrame, trackInfo;
Widget scaleFrame, scaleRC, scaleLabel, scaleArea;
Widget stabilityLabel, particleTypeLabel;
Widget eventCtrlFrame, eventCtrlForm, eventNumLabel, upArrow;
Widget eventNumText, downArrow, eventCtrlText;
Widget widget, spin;
Pixel foreground, background;
Pixmap pm;
/* Create the form onto which everything goes */
ac = 0;
XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
form = XmCreateForm(parent, "form", args, ac);
XtManageChild(form);
if (hasEventBar) {
ac = 0;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
eventCtrlFrame = XmCreateFrame(form, "eventCtrlFrame", args, ac);
XtManageChild(eventCtrlFrame);
ac = 0;
eventCtrlForm = XmCreateForm(eventCtrlFrame, "eventCtrlForm", args, ac);
XtManageChild(eventCtrlForm);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING("Event #"))); ac++;
eventNumLabel = (Widget) XmCreateLabelGadget(
eventCtrlForm, "eventNumLabel",
args, ac);
XmStringFree(s1);
XtManageChild(eventNumLabel);
ac = 0;
XtSetArg(args[ac], XmNarrowDirection, XmARROW_UP); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftWidget, eventNumLabel); ac++;
upArrow = XmCreateArrowButton(eventCtrlForm, "upArrow", args, ac);
XtAddCallback(upArrow, XmNactivateCallback,
(XtCallbackProc) nextEvtCB, window);
XtManageChild(upArrow);
ac = 0;
sprintf(ctmp," %d ", ac);
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING(ctmp))); ac++;
XtSetArg(args[ac], XmNcolumns, 7); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget, upArrow); ac++;
eventNumText = (Widget) XmCreateLabelGadget(
eventCtrlForm, "eventNumText",
args, ac);
/* eventNumText = XmCreateText(eventCtrlForm, "eventNumText", args, ac); */
XtManageChild(eventNumText);
ac = 0;
XtSetArg(args[ac], XmNarrowDirection, XmARROW_DOWN); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftWidget, eventNumText); ac++;
downArrow = XmCreateArrowButton(eventCtrlForm, "downArrow", args, ac);
XtAddCallback(downArrow, XmNactivateCallback,
(XtCallbackProc) previousEvtCB, window);
XtManageChild(downArrow);
ac = 0;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING(eventBarText))); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
eventCtrlText = (Widget) XmCreateLabelGadget(
eventCtrlForm, "eventCtrlText",
args, ac);
XmStringFree(s1);
XtManageChild(eventCtrlText);
}
/* Create a Form for the controls along the left edge of window */
ac = 0;
if (hasEventBar) {
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, eventCtrlFrame); ac++;
} else {
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
}
controls = XmCreateForm(form, "controls", args, ac);
XtManageChild(controls);
ac = 0;
XtSetArg(args[ac], XmNborderWidth, (Dimension)0); ac++;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNnumColumns, (short)2); ac++;
stability = XmCreateRowColumn(controls, "stability", args, ac);
XtManageChild(stability);
ac = 0;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING("Particle Types"))); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, stability); ac++;
particleTypeLabel = (Widget) XmCreateLabelGadget(
controls, "particleTypeLabel",
args, ac);
XmStringFree(s1);
XtManageChild(particleTypeLabel);
ac = 0;
XtSetArg(args[ac], XmNborderWidth, (Dimension)0); ac++;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNnumColumns, (short)2); ac++;
XtSetArg(args[ac], XmNtopWidget, particleTypeLabel); ac++;
particleType = XmCreateRowColumn(controls, "particleType", args, ac);
XtManageChild(particleType);
ac = 0;
XtSetArg(args[ac], XmNhighlightThickness, 0); ac++;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNorientation, XmHORIZONTAL); ac++;
if (hasEventBar) {
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, eventCtrlFrame); ac++;
} else {
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
}
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget, controls); ac++;
XtSetArg(args[ac], XmNtopOffset, (int)2); ac++;
XtSetArg(args[ac], XmNleftOffset, (int)0); ac++;
stats = XmCreateRowColumn(form, "stats", args, ac);
XtManageChild(stats);
#define TOGGLE_BTN(parent, label, name, cb, set) \
ac = 0; \
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING(label))); ac++; \
XtSetArg(args[ac], XmNset, set); ac++; \
XtSetArg(args[ac], XmNmarginHeight, 0); ac++; \
widget = XmCreateToggleButtonGadget(parent, name, args, ac); \
XmStringFree(s1); \
XtAddCallback(widget, XmNvalueChangedCallback, \
(XtCallbackProc) cb, window); \
XtManageChild(widget); \
TOGGLE_BTN(stability, "Stable", "stable", stableCB, True);
TOGGLE_BTN(stability, "Unstable", "unstable", unstableCB, True);
TOGGLE_BTN(particleType, "Charged", "charged", chargedCB, True);
TOGGLE_BTN(particleType, "Neutral", "neutral", neutralCB, True);
TOGGLE_BTN(particleType, "Electrons", "electrons", electronsCB, True);
TOGGLE_BTN(particleType, "Muons", "muons", muonsCB, True);
TOGGLE_BTN(particleType, "Neutrinos", "neutrinos", neutrinosCB, True);
TOGGLE_BTN(particleType, "Gammas", "gammas", gammasCB, True);
TOGGLE_BTN(particleType, "Quarks/Gluons", "quarks", quarksCB, True);
TOGGLE_BTN(particleType,"Hadrons", "hadrons", hadronsCB, True);
TOGGLE_BTN(particleType,"W/Z", "wz", wzCB, True);
/* Do now the slider.. X, Y ,Z translation first. */
ac = 0;
XtSetArg(args[ac], XmNborderWidth, (Dimension)0); ac++;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
/* XtSetArg(args[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++; */
XtSetArg(args[ac], XmNnumColumns, (short)1); ac++;
XtSetArg(args[ac], XmNtopWidget, particleType); ac++;
/* XtSetArg(args[ac], XmNrightWidget, particleType); ac++; */
allSliders = XmCreateRowColumn(controls, "allSliders", args, ac);
XtManageChild(allSliders);
ac = 0;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNadjustLast, False); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNnumColumns, (short)5); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, allSliders); ac++;
rotation = XmCreateRowColumn(controls, "rotation", args, ac);
XtManageChild(rotation);
/* Get foreground an background colors for pixmap buttons */
ac = 0;
XtSetArg(args[ac], XmNforeground, &foreground); ac++;
XtSetArg(args[ac], XmNbackground, &background); ac++;
XtGetValues(controls, args, ac);
#define ROTATE_BTN(pmName, widgetName, cb) \
pm = XmGetPixmap(XtScreen(parent), pmName, foreground, background); \
ac = 0; \
XtSetArg(args[ac], XmNlabelType, XmPIXMAP); ac++; \
XtSetArg(args[ac], XmNlabelPixmap, pm); ac++; \
widget = XmCreatePushButtonGadget(rotation, widgetName, args, ac); \
XtAddCallback(widget, XmNactivateCallback, \
(XtCallbackProc) cb, window); \
XtManageChild(widget);
ROTATE_BTN("viewRotXPos", "viewRotXPos", viewRotXPosCB)
ROTATE_BTN("viewRotYPos", "viewRotYPos", viewRotYPosCB)
ROTATE_BTN("viewRotZPos", "viewRotZPos", viewRotZPosCB)
ROTATE_BTN("viewRotXNeg", "viewRotXNeg", viewRotXNegCB)
ROTATE_BTN("viewRotYNeg", "viewRotYNeg", viewRotYNegCB)
ROTATE_BTN("viewRotZNeg", "viewRotZNeg", viewRotZNegCB)
ROTATE_BTN("coordRotXPos", "coordRotXPos", coordRotXPosCB)
ROTATE_BTN("coordRotYPos", "coordRotYPos", coordRotYPosCB)
ROTATE_BTN("coordRotZPos", "coordRotZPos", coordRotZPosCB)
ROTATE_BTN("coordRotXNeg", "coordRotXNeg", coordRotXNegCB)
ROTATE_BTN("coordRotYNeg", "coordRotYNeg", coordRotYNegCB)
ROTATE_BTN("coordRotZNeg", "coordRotZNeg", coordRotZNegCB)
ROTATE_BTN("scaleUp", "scaleUp", scaleUpCB)
ROTATE_BTN("scaleDown", "scaleDown", scaleDownCB)
ROTATE_BTN("resetRotation", "resetRotation", resetRotationCB)
ac = 0;
XtSetArg(args[ac], XmNshadowType, XmSHADOW_IN); ac++;
XtSetArg(args[ac], XmNshadowThickness, 1); ac++;
scaleFrame = XmCreateFrame(stats, "scaleFrame", args, ac);
XtManageChild(scaleFrame);
trackInfoFrame = XmCreateFrame(stats, "trackInfoFrame", args, ac);
XtManageChild(trackInfoFrame);
ac = 0;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
scaleRC = XmCreateRowColumn(scaleFrame, "scaleRC", args, ac);
XtManageChild(scaleRC);
ac = 0;
scaleArea = XmCreateDrawingArea(scaleRC, "scaleArea", args, ac);
XtAddCallback(scaleArea, XmNexposeCallback,
(XtCallbackProc) scaleExposeCB, window);
XtManageChild(scaleArea);
ac = 0;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING("x"))); ac++;
XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
scaleLabel = (Widget) XmCreateLabelGadget(
scaleRC, "scaleLabel", args, ac);
XmStringFree(s1);
XtManageChild(scaleLabel);
ac = 0;
XtSetArg(args[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
XtSetArg(args[ac], XmNrecomputeSize, False); ac++;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING(
"00000 tracks, 00000 are stable\nx\nTrack of max. xxxxx is a(n) xxxx"))); ac++;
trackInfo = (Widget) XmCreateLabelGadget(
trackInfoFrame, "trackInfo", args, ac);
XmStringFree(s1);
XtManageChild(trackInfo);
ac = 0;
XtSetArg(args[ac], XmNshowAxes, True); ac++;
XtSetArg(args[ac], XmNperspectiveOn, True); ac++;
XtSetArg(args[ac], XmNdoubleBuffer, False); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftWidget, controls); ac++;
XtSetArg(args[ac], XmNtopWidget, stats); ac++;
XtSetArg(args[ac], XmNtopOffset, (int)0); ac++;
XtSetArg(args[ac], XmNbottomOffset, (int)0); ac++;
XtSetArg(args[ac], XmNleftOffset, (int)0); ac++;
XtSetArg(args[ac], XmNrightOffset, (int)0); ac++;
spin = XtCreateManagedWidget("spin", spinWidgetClass, form, args, ac);
XtAddCallback(spin, XmNresizeCallback,
(XtCallbackProc) resizeCB, window);
XtAddCallback(spin, XmNredisplayCallback,
(XtCallbackProc) redisplayCB, window);
XtAddCallback(spin, XmNbtn2Callback,
(XtCallbackProc) spinSelectCB, window);
/* Place now the Sliders, right attached to the spin widget */
formt1 = createSpaceSlider(&window->scaleSliderScale,
&window->scaleSliderValue,
allSliders, spin,
"scaleScale", "Overall Scale",
SLIDER_MAX, window, scaleCB);
formt1 = createSpaceSlider(&window->xTranslSliderScale,
&window->xTranslSliderValue,
allSliders, spin,
"scaleX", "X transl.",
(SLIDER_MAX/2), window, xTransCB);
formt1 = createSpaceSlider(&window->yTranslSliderScale,
&window->yTranslSliderValue,
allSliders, spin,
"scaleY", "Y transl.",
(SLIDER_MAX/2), window, yTransCB);
formt1 = createSpaceSlider(&window->zTranslSliderScale,
&window->zTranslSliderValue,
allSliders, spin,
"scaleZ", "Z transl.",
(SLIDER_MAX/2), window, zTransCB);
formt1 = createSpaceSlider(&window->momToSpaceSliderScale,
&window->momToSpaceSliderValue,
allSliders, spin,
"momtospace", "P to Dist",
(SLIDER_MAX/10), window, momToSpaceCB);
formt1 = createSpaceSlider(&window->longToTrSliderScale,
&window->longToTrSliderValue,
allSliders, spin,
"LongToTr",
"Aspect ratio Long/Tr. ",
(SLIDER_MAX/10), window, longToTrCB);
/* This last string is in fact constraining the appearance of the widget */
window->spin = spin;
window->eventNumText = eventNumText;
window->eventSelectorLabel = eventCtrlText;
window->statsLabel = trackInfo;
window->scaleArea = scaleArea;
window->scaleLabel = scaleLabel;
window->stable = True;
window->unstable = True;
window->charged = True;
window->neutral = True;
window->electrons = True;
window->muons = True;
window->gammas = True;
window->neutrinos = True;
window->quarks = True;
window->hadrons = True;
window->wz = True;
return(form);
}
Widget
_DtTermViewCreateGlobalOptionsDialog
(
Widget parent
)
{
OptionsDialogType *options;
Widget cursorFrame;
Widget cursorForm;
Widget backgroundFrame;
Widget backgroundForm;
Widget scrollFrame;
Widget scrollForm;
Widget bellFrame;
Widget bellForm;
Widget label;
Widget pulldown;
Widget tmp;
Widget separator;
Widget button;
Widget cancel;
Widget reset;
XmString string;
XmString helpString;
XmString okString;
XmString cancelString;
XmString resetString;
Arg al[20];
int ac;
_DtTermViewLineupList *lineupList;
DtTermViewWidget tw = (DtTermViewWidget) parent;
options = (OptionsDialogType *) XtMalloc(sizeof(OptionsDialogType));
(void) memset(options, '\0', sizeof(*options));
options->dtterm = tw->termview.term;
ac = 0;
string = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,34, "Terminal - Global Options")));
okString = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,2, "OK")));
cancelString = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,3, "Cancel")));
helpString = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,4, "Help")));
resetString = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,33, "Reset")));
(void) XtSetArg(al[ac], XmNdialogTitle, string); ac++;
(void) XtSetArg(al[ac], XmNokLabelString, okString); ac++;
(void) XtSetArg(al[ac], XmNcancelLabelString, cancelString); ac++;
(void) XtSetArg(al[ac], XmNhelpLabelString, helpString); ac++;
(void) XtSetArg(al[ac], XmNautoUnmanage, False); ac++;
options->dialog = XmCreateTemplateDialog(parent, (GETMESSAGE(NL_SETN_ViewGlobalDialog,5, "global")), al, ac);
(void) XmStringFree(okString);
(void) XmStringFree(cancelString);
(void) XmStringFree(helpString);
(void) XtSetArg(al[0], XmNlabelString, resetString);
reset = XmCreatePushButtonGadget(options->dialog, "ResetButton", al, 1);
XtManageChild(reset);
(void) XmStringFree(resetString);
(void) XtAddCallback(reset, XmNactivateCallback,
MapGlobalOptionsDialogCallback, (XtPointer) options);
(void) XtAddCallback(options->dialog, XmNokCallback,
OkGlobalOptionsDialogCallback, (XtPointer) options);
(void) XtAddCallback(options->dialog, XmNcancelCallback,
CancelGlobalOptionsDialogCallback, (XtPointer) options);
(void) XtAddCallback(options->dialog, XmNmapCallback,
MapGlobalOptionsDialogCallback, (XtPointer) options);
(void) XtAddCallback(options->dialog, XmNhelpCallback,
HelpTerminalOptionsCallback, (XtPointer) tw);
options->shell = XtParent(options->dialog);
ac = 0;
(void) XtSetArg(al[ac], XmNallowShellResize, False); ac++;
(void) XtSetValues(options->shell, al, ac);
ac = 0;
options->form = XmCreateForm(options->dialog, "form", al, ac);
(void) XtManageChild(options->form);
/****************************************************************
****************************************************************
*** Cursor parameters...
***/
ac = 0;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], DtNmarginWidth, 5); ac++;
(void) XtSetArg(al[ac], DtNmarginHeight, 5); ac++;
cursorFrame = XmCreateFrame(options->form, "cursorFrame", al, ac);
(void) XtManageChild(cursorFrame);
ac = 0;
string = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,6, "Cursor Control")));
(void) XtSetArg(al[ac], XmNlabelString, string); ac++;
(void) XtSetArg(al[ac], XmNchildType, XmFRAME_TITLE_CHILD); ac++;
(void) XtSetArg(al[ac], XmNtraversalOn, False); ac++;
label = XmCreateLabelGadget(cursorFrame, "cursorFrameLabel", al, ac);
(void) XmStringFree(string);
(void) XtManageChild(label);
ac = 0;
cursorForm = XmCreateForm(cursorFrame, "cursorForm", al, ac);
/****************************************************************
* option menu: type [ box | underline ]
*/
pulldown =
_DtTermViewCreatePulldown(cursorForm, "cursorTypePulldown");
options->cursor.type.box =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,7, "Box")), NoSymbol, NULL, NULL, NULL, NULL);
options->cursor.type.underline =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,8, "Underline")), NoSymbol, NULL, NULL, NULL, NULL);
options->cursor.type.invisible =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,14, "Invisible")), NoSymbol, NULL, NULL, NULL, NULL);
ac = 0;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
tmp = _DtTermViewCreateOptionMenu(cursorForm, pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,9, "Cursor Style")), NoSymbol, al, ac);
options->cursor.type.option = tmp;
/* add to the lineup list... */
lineupList = _DtTermViewLineupListCreate();
(void) _DtTermViewLineupListAddItem(lineupList,
XmOptionLabelGadget(options->cursor.type.option),
options->cursor.type.option,
CORRECTION_OPTION_MENU);
/****************************************************************
* option menu: blink [ on | off ]
*/
pulldown =
_DtTermViewCreatePulldown(cursorForm, "cursorBlinkPulldown");
(void) XtAddCallback(pulldown, XmNentryCallback,
CursorBlinkCallback, (XtPointer) options);
options->cursor.blink.on =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,10, "Enabled")), NoSymbol, NULL, NULL, NULL, NULL);
options->cursor.blink.off =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,11, "Disabled")), NoSymbol, NULL, NULL, NULL, NULL);
ac = 0;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, tmp); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
tmp = _DtTermViewCreateOptionMenu(cursorForm, pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,12, "Blinking Cursor")), NoSymbol, al, ac);
options->cursor.blink.option = tmp;
/* add to the lineup list... */
(void) _DtTermViewLineupListAddItem(lineupList,
XmOptionLabelGadget(options->cursor.blink.option),
options->cursor.blink.option,
CORRECTION_OPTION_MENU);
/****************************************************************
* text field: blink rate _250_
*/
ac = 0;
string = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,13, "Blink Rate (milliseconds)")));
(void) XtSetArg(al[ac], XmNlabelString, string); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, tmp); ac++;
(void) XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNtraversalOn, False); ac++;
options->cursor.blinkRate.label =
XmCreateLabelGadget(cursorForm, "blinkRateLabel", al, ac);
(void) XmStringFree(string);
(void) XtManageChild(options->cursor.blinkRate.label);
ac = 0;
(void) XtSetArg(al[ac], DtNcolumns, 4); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNleftWidget, options->cursor.blinkRate.label);
ac++;
(void) XtSetArg(al[ac], XmNleftOffset, CORRECTION_TEXT_OFFSET); ac++;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, tmp); ac++;
(void) XtSetArg(al[ac], XmNnavigationType, XmNONE); ac++;
options->cursor.blinkRate.text =
XmCreateTextField(cursorForm, (GETMESSAGE(NL_SETN_ViewGlobalDialog,15, "blinkRate")), al, ac);
(void) XtManageChild(options->cursor.blinkRate.text);
options->cursor.blinkRate.oldBlinkRate = 0;
/* make the label and textfield the same height... */
_DtTermViewEqualizeHeights(options->cursor.blinkRate.label,
options->cursor.blinkRate.text);
/* add to the lineup list... */
(void) _DtTermViewLineupListAddItem(lineupList,
options->cursor.blinkRate.label,
options->cursor.blinkRate.text,
CORRECTION_LABEL);
/* manage the cursor form... */
(void) XtManageChild(cursorForm);
/****************************************************************
****************************************************************
**** Background parameters...
***/
ac = 0;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, cursorFrame); ac++;
(void) XtSetArg(al[ac], XmNtopOffset, 5); ac++;
(void) XtSetArg(al[ac], DtNmarginWidth, 5); ac++;
(void) XtSetArg(al[ac], DtNmarginHeight, 5); ac++;
backgroundFrame = XmCreateFrame(options->form, "backgroundFrame",
al, ac);
(void) XtManageChild(backgroundFrame);
ac = 0;
string = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,16, "Color Control")));
(void) XtSetArg(al[ac], XmNlabelString, string); ac++;
(void) XtSetArg(al[ac], XmNchildType, XmFRAME_TITLE_CHILD); ac++;
(void) XtSetArg(al[ac], XmNtraversalOn, False); ac++;
label = XmCreateLabelGadget(backgroundFrame, "backgroundFrameLabel",
al, ac);
(void) XmStringFree(string);
(void) XtManageChild(label);
ac = 0;
backgroundForm = XmCreateForm(backgroundFrame, "backgroundForm", al, ac);
/****************************************************************
* option menu: inverse video [on | off ]
*/
pulldown =
_DtTermViewCreatePulldown(backgroundForm, "inverseVideoPulldown");
options->background.inverse.off =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,18, "Normal")), NoSymbol,
NULL, NULL, NULL, NULL);
options->background.inverse.on =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,17, "Inverse")), NoSymbol,
NULL, NULL, NULL, NULL);
ac = 0;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
tmp = _DtTermViewCreateOptionMenu(backgroundForm, pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,19, "Window Background")), NoSymbol, al, ac);
options->background.inverse.option = tmp;
/* add to the lineup list... */
(void) _DtTermViewLineupListAddItem(lineupList,
XmOptionLabelGadget(options->background.inverse.option),
options->background.inverse.option,
CORRECTION_OPTION_MENU);
/* manage the cursor form... */
(void) XtManageChild(backgroundForm);
/****************************************************************
****************************************************************
**** Scroll parameters...
***/
ac = 0;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, backgroundFrame); ac++;
(void) XtSetArg(al[ac], XmNtopOffset, 5); ac++;
(void) XtSetArg(al[ac], DtNmarginWidth, 5); ac++;
(void) XtSetArg(al[ac], DtNmarginHeight, 5); ac++;
scrollFrame = XmCreateFrame(options->form, "scrollFrame", al, ac);
(void) XtManageChild(scrollFrame);
ac = 0;
string = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,20, "Scroll Behavior")));
(void) XtSetArg(al[ac], XmNlabelString, string); ac++;
(void) XtSetArg(al[ac], XmNchildType, XmFRAME_TITLE_CHILD); ac++;
(void) XtSetArg(al[ac], XmNtraversalOn, False); ac++;
label = XmCreateLabelGadget(scrollFrame, "scrollFrameLabel", al, ac);
(void) XmStringFree(string);
(void) XtManageChild(label);
ac = 0;
scrollForm = XmCreateForm(scrollFrame, "scrollForm", al, ac);
/****************************************************************
* option menu: type [jump | smooth ]
*/
pulldown =
_DtTermViewCreatePulldown(scrollForm, "ScrollTypePulldown");
options->scroll.type.jump =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,21, "Disabled")), NoSymbol, NULL, NULL, NULL, NULL);
options->scroll.type.smooth =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,22, "Enabled")), NoSymbol, NULL, NULL, NULL, NULL);
ac = 0;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
tmp = _DtTermViewCreateOptionMenu(scrollForm, pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,23, "Smooth Scrolling")), NoSymbol, al, ac);
options->scroll.type.option = tmp;
/* add to the lineup list... */
(void) _DtTermViewLineupListAddItem(lineupList,
XmOptionLabelGadget(options->scroll.type.option),
options->scroll.type.option,
CORRECTION_OPTION_MENU);
/* manage the cursor form... */
(void) XtManageChild(scrollForm);
/****************************************************************
****************************************************************
*** Bell parameters...
***/
ac = 0;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, scrollFrame); ac++;
(void) XtSetArg(al[ac], XmNtopOffset, 5); ac++;
(void) XtSetArg(al[ac], DtNmarginWidth, 5); ac++;
(void) XtSetArg(al[ac], DtNmarginHeight, 5); ac++;
bellFrame = XmCreateFrame(options->form, "bellFrame",
al, ac);
(void) XtManageChild(bellFrame);
ac = 0;
string = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,24, "Bell Control")));
(void) XtSetArg(al[ac], XmNlabelString, string); ac++;
(void) XtSetArg(al[ac], XmNchildType, XmFRAME_TITLE_CHILD); ac++;
(void) XtSetArg(al[ac], XmNtraversalOn, False); ac++;
label = XmCreateLabelGadget(bellFrame, "bellFrameLabel", al, ac);
(void) XmStringFree(string);
(void) XtManageChild(label);
ac = 0;
bellForm = XmCreateForm(bellFrame, "bellForm", al, ac);
/****************************************************************
* option menu: Type [audible | visible ]
*/
pulldown =
_DtTermViewCreatePulldown(bellForm, "typePulldown");
options->bell.type.audible =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,25, "Audible")), NoSymbol, NULL, NULL, NULL, NULL);
options->bell.type.visual =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,26, "Visible")), NoSymbol, NULL, NULL, NULL, NULL);
ac = 0;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
tmp = _DtTermViewCreateOptionMenu(bellForm, pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,27, "Bell Type")), NoSymbol, al, ac);
options->bell.type.option = tmp;
/* add to the lineup list... */
(void) _DtTermViewLineupListAddItem(lineupList,
XmOptionLabelGadget(options->bell.type.option),
options->bell.type.option,
CORRECTION_OPTION_MENU);
/****************************************************************
* option menu: Margin Bell [on | off ]
*/
pulldown =
_DtTermViewCreatePulldown(bellForm, "bellMarginPulldown");
(void) XtAddCallback(pulldown, XmNentryCallback,
BellMarginCallback, (XtPointer) options);
options->bell.bellMargin.on =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,28, "Enabled")), NoSymbol, NULL, NULL, NULL, NULL);
options->bell.bellMargin.off =
_DtTermViewCreatePushButton(pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,29, "Disabled")), NoSymbol, NULL, NULL, NULL, NULL);
ac = 0;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, tmp); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
tmp = _DtTermViewCreateOptionMenu(bellForm, pulldown,
(GETMESSAGE(NL_SETN_ViewGlobalDialog,30, "Margin Warning")), NoSymbol, al, ac);
options->bell.bellMargin.option = tmp;
/* add to the lineup list... */
(void) _DtTermViewLineupListAddItem(lineupList,
XmOptionLabelGadget(options->bell.bellMargin.option),
options->bell.bellMargin.option,
CORRECTION_OPTION_MENU);
/****************************************************************
* text field: Margin _8_
*/
ac = 0;
string = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,31, "Margin Distance")));
(void) XtSetArg(al[ac], XmNlabelString, string); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, tmp); ac++;
(void) XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
(void) XtSetArg(al[ac], XmNtraversalOn, False); ac++;
options->bell.bellMarginDistance.label =
XmCreateLabelGadget(bellForm, "bellMarginDistanceLabel", al, ac);
(void) XmStringFree(string);
(void) XtManageChild(options->bell.bellMarginDistance.label);
ac = 0;
(void) XtSetArg(al[ac], DtNcolumns, 3); ac++;
(void) XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNleftWidget,
options->bell.bellMarginDistance.label); ac++;
(void) XtSetArg(al[ac], XmNleftOffset, CORRECTION_TEXT_OFFSET); ac++;
(void) XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
(void) XtSetArg(al[ac], XmNtopWidget, tmp); ac++;
(void) XtSetArg(al[ac], XmNnavigationType, XmNONE); ac++;
options->bell.bellMarginDistance.text =
XmCreateTextField(bellForm, "margin", al, ac);
(void) XtManageChild(options->bell.bellMarginDistance.text);
/* make the label and textfield the same height... */
_DtTermViewEqualizeHeights(options->bell.bellMarginDistance.label,
options->bell.bellMarginDistance.text);
/* add to the lineup list... */
(void) _DtTermViewLineupListAddItem(lineupList,
options->bell.bellMarginDistance.label,
options->bell.bellMarginDistance.text,
CORRECTION_LABEL);
/* manage the margin form... */
(void) XtManageChild(bellForm);
/* lineup all the labels... */
(void) _DtTermViewLineupListLineup(lineupList);
(void) _DtTermViewLineupListFree(lineupList);
lineupList = (_DtTermViewLineupList *) 0;
/* create the apply button... */
ac = 0;
string = XmStringCreateLocalized((GETMESSAGE(NL_SETN_ViewGlobalDialog,32, "Apply")));
(void) XtSetArg(al[ac], XmNlabelString, string); ac++;
button = XmCreatePushButtonGadget(options->dialog, "apply", al, ac);
(void) XmStringFree(string);
(void) XtAddCallback(button, XmNactivateCallback,
ApplyGlobalOptionsDialogCallback, (XtPointer) options);
(void) XtManageChild(button);
ac = 0;
(void) XtSetArg(al[ac], XmNmwmFunctions, MWM_FUNC_MOVE); ac++;
(void) XtSetArg(al[ac], XmNmwmDecorations,
MWM_DECOR_MENU | MWM_DECOR_BORDER | MWM_DECOR_TITLE); ac++;
(void) XtSetValues(options->shell, al, ac);
(void) XtManageChild(options->dialog);
return(options->dialog);
}
void XFE_ReadAttachPanel::displayAttachmentProperties(int pos)
{
if (pos<0 || pos>=_numItems)
return;
if (!_propertiesDialog) {
// create properties dialog
Arg args[20];
int n;
Visual *v=0;
Colormap cmap=0;
Cardinal depth=0;
Widget shell=getBaseWidget();
while (!XtIsShell(shell)) shell=XtParent(shell);
XtVaGetValues(shell,XtNvisual,&v,XtNcolormap,&cmap,XtNdepth,&depth,NULL);
Pixel bg;
XtVaGetValues(getBaseWidget(),XmNbackground,&bg,NULL);
fe_icon attachIcon={ 0 };
fe_MakeIcon(_context,bg, &attachIcon, NULL,
M_ToggleAttach.width, M_ToggleAttach.height,
M_ToggleAttach.mono_bits, M_ToggleAttach.color_bits, M_ToggleAttach.mask_bits,
FALSE);
n=0;
XtSetArg(args[n],XmNvisual,v); n++;
XtSetArg(args[n],XmNdepth,depth); n++;
XtSetArg(args[n],XmNcolormap,cmap); n++;
XtSetArg(args[n],XmNdeleteResponse,XmUNMAP);n++;
XtSetArg(args[n],XmNautoUnmanage,TRUE);n++;
XtSetArg(args[n],XmNdialogStyle,XmDIALOG_MODELESS);n++;
XtSetArg(args[n],XmNmwmFunctions,MWM_FUNC_MOVE|MWM_FUNC_CLOSE);n++;
XtSetArg(args[n],XmNmwmDecorations,MWM_DECOR_BORDER|MWM_DECOR_TITLE|MWM_DECOR_MENU);n++;
if (attachIcon.pixmap) {
XtSetArg(args[n],XmNsymbolPixmap,attachIcon.pixmap);n++;
}
_propertiesDialog=XmCreateTemplateDialog(getBaseWidget(),"attachmentProps",args,n);
fe_HackDialogTranslations(_propertiesDialog);
fe_NukeBackingStore(_propertiesDialog);
Widget form=XmCreateForm(_propertiesDialog,"form",NULL,0);
XtManageChild(form);
n=0;
XtSetArg(args[n],XmNpacking,XmPACK_COLUMN); n++;
XtSetArg(args[n],XmNnumColumns,1); n++;
XtSetArg(args[n],XmNisAligned,FALSE); n++;
XtSetArg(args[n],XmNalignment,XmVERTICAL); n++;
XtSetArg(args[n],XmNleftAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n],XmNtopAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n],XmNbottomAttachment,XmATTACH_FORM); n++;
Widget labelRC=XmCreateRowColumn(form,"labelRC",args,n);
XtManageChild(labelRC);
n=0;
XtSetArg(args[n],XmNalignment,XmALIGNMENT_END);n++;
_nameLabel=XmCreateLabelGadget(labelRC,"nameLabel",args,n);
_typeLabel=XmCreateLabelGadget(labelRC,"typeLabel",args,n);
_encLabel=XmCreateLabelGadget(labelRC,"encLabel",args,n);
_descLabel=XmCreateLabelGadget(labelRC,"descLabel",args,n);
n=0;
XtSetArg(args[n],XmNpacking,XmPACK_COLUMN); n++;
XtSetArg(args[n],XmNnumColumns,1); n++;
XtSetArg(args[n],XmNisAligned,FALSE); n++;
XtSetArg(args[n],XmNalignment,XmVERTICAL); n++;
XtSetArg(args[n],XmNleftAttachment,XmATTACH_WIDGET); n++;
XtSetArg(args[n],XmNleftWidget,labelRC); n++;
XtSetArg(args[n],XmNrightAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n],XmNtopAttachment,XmATTACH_FORM); n++;
XtSetArg(args[n],XmNbottomAttachment,XmATTACH_FORM); n++;
Widget valueRC=XmCreateRowColumn(form,"valueRC",args,n);
XtManageChild(valueRC);
n=0;
XtSetArg(args[n],XmNalignment,XmALIGNMENT_BEGINNING);n++;
_nameValue=XmCreateLabelGadget(valueRC,"nameValue",args,n);
_typeValue=XmCreateLabelGadget(valueRC,"typeValue",args,n);
_encValue=XmCreateLabelGadget(valueRC,"encValue",args,n);
_descValue=XmCreateLabelGadget(valueRC,"descValue",args,n);
}
// set value of data fields, manage/unmanage relevent fields
XmString xs;
// file name
char *name=_attachments[pos].real_name;
if (name) {
xs=XmStringCreateLocalized(name);
XtVaSetValues(_nameValue,XmNlabelString,xs,NULL);
XmStringFree(xs);
XtManageChild(_nameLabel);
XtManageChild(_nameValue);
}
else {
XtUnmanageChild(_nameLabel);
XtUnmanageChild(_nameValue);
}
// mime type
char *type=_attachments[pos].real_type;
if (type) {
xs=XmStringCreateLocalized(type);
XtVaSetValues(_typeValue,XmNlabelString,xs,NULL);
XmStringFree(xs);
XtManageChild(_typeLabel);
XtManageChild(_typeValue);
}
else {
XtUnmanageChild(_typeLabel);
XtUnmanageChild(_typeValue);
}
// encoding
char *enc=_attachments[pos].real_encoding;
if (enc) {
xs=XmStringCreateLocalized(enc);
XtVaSetValues(_encValue,XmNlabelString,xs,NULL);
XmStringFree(xs);
XtManageChild(_encLabel);
XtManageChild(_encValue);
}
else {
XtUnmanageChild(_encLabel);
XtUnmanageChild(_encValue);
}
// long description
char *desc=_attachments[pos].description;
if (desc) {
xs=XmStringCreateLocalized(desc);
XtVaSetValues(_descValue,XmNlabelString,xs,NULL);
XmStringFree(xs);
XtManageChild(_descLabel);
XtManageChild(_descValue);
}
else {
XtUnmanageChild(_descLabel);
XtUnmanageChild(_descValue);
}
// manage widget if not already managed
XtManageChild(_propertiesDialog);
}
/*+++++++++++++++++++++++++++++++++++++++*/
static Widget
BuildI18nDlg(
Widget shell )
{
register int i, n;
Arg args[MAX_ARGS];
XmString button_string[NUM_LABELS];
XmString string;
Widget form;
Widget inputMethodForm;
Widget imStartModeForm;
Widget preeditTypeForm;
int count = 0;
Widget widgetList1[6];
/* get i18n resource values */
/* Set up DialogBoxDialog button labels */
button_string[0] = CMPSTR((String) _DtOkString);
button_string[1] = CMPSTR((String) _DtCancelString);
button_string[2] = CMPSTR((String) _DtHelpString);
/* Create toplevel DialogBox */
/* Initialize the i18n structure */
i18n.pictLabel = NULL;
i18n.systemDefault = NULL;
i18n.inputMethodTB = NULL;
i18n.serverHostLabel = NULL;
i18n.serverHostCB = NULL;
i18n.inputMethodLabel = NULL;
i18n.inputMethodRC = NULL;
i18n.imStartModeTB = NULL;
i18n.imStartModeRC = NULL;
i18n.askAtLoginTG = NULL;
i18n.resumeCurrentImTG = NULL;
i18n.preeditTypeTB = NULL;
i18n.preeditTypeList = NULL;
i18n.buttonMoveUp = NULL;
i18n.buttonMoveDown = NULL;
i18n.warnDialog = NULL;
/* saveRestore
* Note that save.poscnt has been initialized elsewhere.
* save.posArgs may contain information from restoreBeep().*/
XtSetArg(save.posArgs[save.poscnt], XmNbuttonCount, NUM_LABELS);
save.poscnt++;
XtSetArg(save.posArgs[save.poscnt], XmNbuttonLabelStrings, button_string);
save.poscnt++;
XtSetArg(save.posArgs[save.poscnt], XmNdefaultPosition, False);
save.poscnt++;
style.i18nDialog =
__DtCreateDialogBoxDialog(shell, "i18nDialog", save.posArgs,
save.poscnt);
XtAddCallback(style.i18nDialog, XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_I18N_DIALOG);
XmStringFree(button_string[0]);
XmStringFree(button_string[1]);
XmStringFree(button_string[2]);
widgetList1[0] = _DtDialogBoxGetButton(style.i18nDialog,2);
n=0;
XtSetArg(args[n], XmNautoUnmanage, False); n++;
XtSetArg(args[n], XmNcancelButton, widgetList1[0]); n++;
XtSetValues (style.i18nDialog, args, n);
n=0;
XtSetArg(args[n], XmNtitle,
((char *)GETMESSAGE(19, 1, "Style Manager - Internationalization")));
n++;
XtSetArg (args[n], XmNuseAsyncGeometry, True); n++;
XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC); n++;
XtSetValues (XtParent(style.i18nDialog), args, n);
n = 0;
XtSetArg(args[n], XmNallowOverlap, False); n++;
XtSetArg(args[n], XmNchildType, XmWORK_AREA); n++;
form = XmCreateForm(style.i18nDialog, "i18nForm", args, n);
n = 0;
XtSetArg(args[n], XmNfillMode, XmFILL_SELF); n++;
XtSetArg(args[n], XmNbehavior, XmICON_LABEL); n++;
XtSetArg(args[n], XmNpixmapForeground, style.secBSCol); n++;
XtSetArg(args[n], XmNpixmapBackground, style.secTSCol); n++;
XtSetArg(args[n], XmNstring, NULL); n++;
XtSetArg(args[n], XmNshadowThickness, 0); n++;
XtSetArg(args[n], XmNimageName, I18N_ICON); n++;
XtSetArg(args[n], XmNtraversalOn, False); n++;
widgetList1[count++] = i18n.pictLabel =
_DtCreateIcon(form, "i18npictLabel", args, n);
n = 0;
XtSetArg(args[n], XmNmarginHeight, LB_MARGIN_HEIGHT); n++;
XtSetArg(args[n], XmNmarginWidth, LB_MARGIN_WIDTH); n++;
string = CMPSTR(((char *)GETMESSAGE(19, 2, "Default")));
XtSetArg(args[n], XmNlabelString, string); n++;
widgetList1[count++] = i18n.systemDefault =
XmCreatePushButtonGadget(form, "systemDefault", args, n);
XmStringFree(string);
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 3, "Input Method"));
XtSetArg(args[n], XmNtitleString, string); n++;
widgetList1[count++] = i18n.inputMethodTB =
_DtCreateTitleBox(form, "inputMethodTB", args, n);
XmStringFree(string);
n = 0;
XtSetArg(args[n], XmNallowOverlap, False); n++;
XtSetArg(args[n], XmNchildType, XmWORK_AREA); n++;
inputMethodForm =
XmCreateForm(i18n.inputMethodTB, "inputMethodForm", args, n);
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 4, "Input Method Start Mode"));
XtSetArg(args[n], XmNtitleString, string); n++;
widgetList1[count++] = i18n.imStartModeTB =
_DtCreateTitleBox(form, "imStartModeTB", args, n);
XmStringFree(string);
n = 0;
XtSetArg(args[n], XmNallowOverlap, False); n++;
XtSetArg(args[n], XmNchildType, XmWORK_AREA); n++;
imStartModeForm =
XmCreateForm(i18n.imStartModeTB, "imStartModeForm", args, n);
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 5, "Preedit Type"));
XtSetArg(args[n], XmNtitleString, string); n++;
widgetList1[count++] = i18n.preeditTypeTB =
_DtCreateTitleBox(form, "preeditTypeTB", args, n);
XmStringFree(string);
n = 0;
XtSetArg(args[n], XmNallowOverlap, False); n++;
XtSetArg(args[n], XmNchildType, XmWORK_AREA); n++;
preeditTypeForm =
XmCreateForm(i18n.preeditTypeTB, "preeditTypeForm", args, n);
/* Create widgets inside the inputMethodForm */
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 6, "Server Host :"));
XtSetArg(args[n], XmNlabelString, string); n++;
i18n.serverHostLabel =
XmCreateLabelGadget(inputMethodForm, "serverHostLabel", args, n);
n = 0;
XtSetArg(args[n], XmNcomboBoxType, XmDROP_DOWN_COMBO_BOX); n++;
i18n.serverHostCB =
(Widget) (intptr_t) XmCreateComboBox(inputMethodForm, "serverHostCB", args, n);
XtAddCallback(XtNameToWidget(i18n.serverHostCB, "Text"),
XmNactivateCallback, ServerHostCB, NULL);
XtAddCallback(XtNameToWidget(i18n.serverHostCB, "Text"),
XmNfocusCallback, TextFocusCB, NULL);
XtAddCallback(XtNameToWidget(i18n.serverHostCB, "Text"),
XmNlosingFocusCallback, TextLosingFocusCB, NULL);
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 7, "Input Method"));
XtSetArg(args[n], XmNlabelString, string); n++;
i18n.inputMethodLabel =
XmCreateLabelGadget(inputMethodForm, "inputMethodLabel", args, n);
n = 0;
XtSetArg(args[n], XmNmarginWidth, LB_MARGIN_WIDTH); n++;
XtSetArg(args[n], XmNmarginHeight, LB_MARGIN_HEIGHT); n++;
i18n.inputMethodRC =
XmCreateRadioBox(inputMethodForm, "inputMethodRC", args, n);
/* Create widgets inside the imStartModeForm */
n = 0;
XtSetArg(args[n], XmNmarginWidth, 0); n++;
XtSetArg(args[n], XmNmarginHeight, 0); n++;
i18n.imStartModeRC =
XmCreateRadioBox(imStartModeForm, "imStartModeRC", args, n);
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 8, "Ask at login"));
XtSetArg(args[n], XmNlabelString, string); n++;
i18n.askAtLoginTG =
XmCreateToggleButtonGadget(i18n.imStartModeRC, "askAtLoginTG",
args, n);
XmStringFree(string);
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 9, "Resume Current Input Method"));
XtSetArg(args[n], XmNlabelString, string); n++;
i18n.resumeCurrentImTG =
XmCreateToggleButtonGadget(i18n.imStartModeRC, "resumeCurrentImTG",
args, n);
XmStringFree(string);
/* Create widgets inside the preeditTypeForm */
n = 0;
XtSetArg(args[n], XmNselectionPolicy, XmBROWSE_SELECT); n++;
i18n.preeditTypeList =
(Widget) (intptr_t) XmCreateList(preeditTypeForm, "preeditTypeList", args, n);
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 10, "Move Up"));
XtSetArg(args[n], XmNlabelString, string); n++;
XtSetArg(args[n], XmNsensitive, False); n++;
i18n.buttonMoveUp =
XmCreatePushButtonGadget(preeditTypeForm, "buttonMoveUp", args, n);
XmStringFree(string);
n = 0;
string = CMPSTR((char *)GETMESSAGE(19, 11, "Move Down"));
XtSetArg(args[n], XmNlabelString, string); n++;
XtSetArg(args[n], XmNsensitive, False); n++;
i18n.buttonMoveDown =
XmCreatePushButtonGadget(preeditTypeForm, "buttonMoveDown", args, n);
XmStringFree(string);
XtAddCallback(style.i18nDialog, XmNmapCallback, FormLayoutCB, NULL);
XtAddCallback(style.i18nDialog, XmNmapCallback, MapCB, shell);
XtAddCallback(style.i18nDialog, XmNcallback, ButtonCB, NULL);
XtAddCallback(i18n.systemDefault, XmNactivateCallback,
SystemDefaultCB, NULL);
XtAddCallback(i18n.preeditTypeList, XmNbrowseSelectionCallback,
ListItemSelectCB, NULL);
XtAddCallback(i18n.buttonMoveUp, XmNactivateCallback,
MoveUpCB, NULL);
XtAddCallback(i18n.buttonMoveDown, XmNactivateCallback,
MoveDownCB, NULL);
XtManageChild(form);
XtManageChildren(widgetList1,count);
XtManageChild(inputMethodForm);
XtManageChild(imStartModeForm);
XtManageChild(preeditTypeForm);
XtManageChild(i18n.serverHostLabel);
XtManageChild(i18n.serverHostCB);
XtManageChild(i18n.inputMethodLabel);
XtManageChild(i18n.inputMethodRC);
XtManageChild(i18n.imStartModeRC);
XtManageChild(i18n.askAtLoginTG);
XtManageChild(i18n.resumeCurrentImTG);
XtManageChild(i18n.preeditTypeList);
XtManageChild(i18n.buttonMoveUp);
XtManageChild(i18n.buttonMoveDown);
return(style.i18nDialog);
}
main (int argc, char *argv[])
{
Widget top, main_w, rc, text_w, label_w;
XtAppContext app;
XmString file, open, exit;
Arg args[10];
int n;
//XtSetLanguageProc (NULL, NULL, NULL);
/* initialize toolkit and create toplevel shell */
top = XtVaOpenApplication (&app, "Demos", NULL, 0, &argc, argv, NULL,
sessionShellWidgetClass, NULL);
/*
main_w = XmCreateMainWindow (top, "main_w", NULL, 0);
rc = XmCreateRowColumn (main_w, "work_area", NULL, 0);
*/
#if 0
n = 0;
XtSetArg (args[n], XmNorientation, XmVERTICAL/*XmHORIZONTAL*/);
n++;
XtSetArg (args[n], XmNresizeHeight, True);
n++;
rc = XmCreateRowColumn (top, "work_area", args, n);
#endif
n = 0;
rc = XmCreateFrame (top, "work_area", args, n);
/*
n = 0;
//XtSetArg (args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
label_w = XmCreateLabel (rc, "Filename:", args, n);
XtManageChild (label_w);
*/
n = 0;
XtSetArg (args[n], XmNframeChildType, XmFRAME_TITLE_CHILD);
n++;
XtSetArg (args[n], XmNchildVerticalAlignment, XmALIGNMENT_CENTER);
n++;
label_w = XmCreateLabelGadget (rc, "!!! TITLE !!!", args, n);
XtManageChild (label_w);
/* Create ScrolledText -- this is work area for the MainWindow */
#if 1
n = 0;
XtSetArg (args[n], XmNrows, 12);
n++;
XtSetArg (args[n], XmNcolumns, 70);
n++;
XtSetArg (args[n], XmNeditMode, XmMULTI_LINE_EDIT);
n++;
XtSetArg (args[n], XmNtopAttachment, label_w/*XmATTACH_FORM*/);
n++;
text_w = XmCreateScrolledText (rc, "text_w", args, n);
XtManageChild (text_w);
#endif
XtManageChild (rc);
XtRealizeWidget (top);
XtAppMainLoop (app);
}
/*
* Function: _DtPrintCreateMarginFrame
*
* Creates a frame for specifying margins. The frame contains four text
* fields, one for each _DtPrintMarginEnum.
*
* parent - specifies the parent of the frame.
*
* Returns the widget id of the frame.
*/
Widget
_DtPrintCreateMarginFrame(
Widget parent
)
{
DtpoMarginFrame
*info;
Arg args[16];
int n;
XmString xms;
info = (DtpoMarginFrame *) XtMalloc( sizeof(DtpoMarginFrame) );
n = 0;
XtSetArg(args[n], XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING); n++;
XtSetArg(args[n], XmNchildVerticalAlignment, XmALIGNMENT_CENTER); n++;
XtSetArg(args[n], XmNuserData, info); n++;
info->frame = XmCreateFrame(parent, "MarginFrame", args, n);
XtAddCallback(
info->frame,
XmNdestroyCallback,
_DtPrintDestroyMarginFrameCB,
(XtPointer) info
);
xms = XmStringCreateLocalized(DTPO_MARGIN_FRAME_LABEL);
n = 0;
XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
XtSetArg(args[n], XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING); n++;
XtSetArg(args[n], XmNchildVerticalAlignment, XmALIGNMENT_CENTER); n++;
XtSetArg(args[n], XmNlabelString, xms); n++;
info->label = XmCreateLabel(info->frame, "MarginLabel", args, n);
XtManageChild(info->label);
XmStringFree(xms);
n = 0;
XtSetArg(args[n], XmNallowOverlap, False); n++;
XtSetArg(args[n], XmNfractionBase, 2); n++;
info->form = XmCreateForm(info->frame, "MarginForm", args, n);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
XtSetArg(args[n], XmNrightPosition, 1); n++;
XtSetArg(args[n], XmNrightOffset, 5); n++;
info->top = XmCreateTextField(info->form, "MarginTopText", args, n);
XtManageChild(info->top);
xms = XmStringCreateLocalized(DTPO_MARGIN_FRAME_TOP_MARGIN_LABEL);
n = 0;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->top); n++;
XtSetArg(args[n], XmNtopOffset, 0); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, info->top); n++;
XtSetArg(args[n], XmNrightOffset, 3); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNbottomWidget, info->top); n++;
XtSetArg(args[n], XmNbottomOffset, 0); n++;
info->top_label =
XmCreateLabelGadget(info->form, "MarginTopLabel", args, n);
XmStringFree(xms);
XtManageChild(info->top_label);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->top); n++;
XtSetArg(args[n], XmNtopOffset, 0); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
info->right = XmCreateTextField(info->form, "MarginRightText", args, n);
XtManageChild(info->right);
xms = XmStringCreateLocalized(DTPO_MARGIN_FRAME_RIGHT_MARGIN_LABEL);
n = 0;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->right); n++;
XtSetArg(args[n], XmNtopOffset, 0); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, info->right); n++;
XtSetArg(args[n], XmNrightOffset, 3); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNbottomWidget, info->right); n++;
XtSetArg(args[n], XmNbottomOffset, 0); n++;
info->right_label =
XmCreateLabelGadget(info->form, "MarginRightLabel", args, n);
XmStringFree(xms);
XtManageChild(info->right_label);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->top); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, info->top); n++;
XtSetArg(args[n], XmNrightOffset, 0); n++;
info->bottom = XmCreateTextField(info->form, "MarginBottomText", args, n);
XtManageChild(info->bottom);
xms = XmStringCreateLocalized(DTPO_MARGIN_FRAME_BOTTOM_MARGIN_LABEL);
n = 0;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->bottom); n++;
XtSetArg(args[n], XmNtopOffset, 0); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, info->bottom); n++;
XtSetArg(args[n], XmNrightOffset, 3); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNbottomWidget, info->bottom); n++;
XtSetArg(args[n], XmNbottomOffset, 0); n++;
info->bottom_label =
XmCreateLabelGadget(info->form, "MarginBottomLabel", args, n);
XmStringFree(xms);
XtManageChild(info->bottom_label);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->bottom); n++;
XtSetArg(args[n], XmNtopOffset, 0); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, info->right); n++;
XtSetArg(args[n], XmNrightOffset, 0); n++;
info->left = XmCreateTextField(info->form, "MarginLeftText", args, n);
XtManageChild(info->left);
xms = XmStringCreateLocalized(DTPO_MARGIN_FRAME_LEFT_MARGIN_LABEL);
n = 0;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->left); n++;
XtSetArg(args[n], XmNtopOffset, 0); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, info->left); n++;
XtSetArg(args[n], XmNrightOffset, 3); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNbottomWidget, info->left); n++;
XtSetArg(args[n], XmNbottomOffset, 0); n++;
info->left_label =
XmCreateLabelGadget(info->form, "MarginLeftLabel", args, n);
XmStringFree(xms);
XtManageChild(info->left_label);
XtManageChild(info->form);
return info->frame;
}
void InitAccessTab()
{
XmString xmstr;
Widget host_label, family_label, rowcol, access_form;
/*
* widget creation and management
*/
access_frame = XmCreateFrame( tab_form, "access_form", NULL, 0 );
access_form = XmCreateForm( access_frame, "access_form", NULL , 0 );
XtManageChild( access_form );
rowcol = XmCreateRowColumn( access_form, "rowcol", NULL, 0 );
XtManageChild( rowcol );
host_label = XmCreateLabelGadget( rowcol, "host_label", NULL, 0 );
XtManageChild( host_label );
family_label = XmCreateLabelGadget( rowcol, "family_label", NULL, 0 );
XtManageChild( family_label );
access_out = XmCreateText( access_form, "access_out", NULL, 0 );
XtManageChild( access_out );
/*
* widget resources
*/
XtVaSetValues( access_frame,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, main_tab,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNchildType, XmFRAME_WORKAREA_CHILD,
XmNshadowType, XmSHADOW_ETCHED_OUT,
XmNmarginHeight, 3,
XmNmarginWidth, 3,
NULL );
XtVaSetValues( access_form,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL );
XtVaSetValues( rowcol,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNnumColumns, 2,
XmNpacking, XmPACK_COLUMN,
XmNresizeHeight, TRUE,
XmNresizeWidth, TRUE,
NULL );
xmstr = XmStringCreateSimple( "Host" );
XtVaSetValues( host_label,
XmNlabelString, xmstr,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, family_label,
XmNwidth, 30,
NULL );
XmStringFree( xmstr );
xmstr = XmStringCreateSimple( "Network Family" );
XtVaSetValues( family_label,
XmNlabelString, xmstr,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_NONE,
XmNwidth, 30,
NULL );
XmStringFree( xmstr );
XtVaSetValues( access_out,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, rowcol,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNshadowThickness, 0,
XmNeditMode, XmMULTI_LINE_EDIT,
XmNeditable, FALSE, /* can't edit */
XmNcursorPositionVisible, FALSE, /* no cursor */
XmNscrollingPolicy, XmAUTOMATIC,
XmNwordWrap, TRUE,
NULL );
}
/*+++++++++++++++++++++++++++++++++++++++*/
static Widget
build_keyboardDlg(
Widget shell )
{
register int i, n;
Arg args[MAX_ARGS];
Widget widget_list[12];
int count = 0;
Widget form;
Pixel foreground, background;
Boolean set;
XmString button_string[NUM_LABELS];
XmString string;
/* Set up DialogBoxDialog button labels */
button_string[0] = CMPSTR(_DtOkString);
button_string[1] = CMPSTR(_DtCancelString);
button_string[2] = CMPSTR(_DtHelpString);
/* Create toplevel DialogBox */
/* saveRestore
* Note that save.poscnt has been initialized elsewhere.
* save.posArgs may contain information from restoreBeep().*/
XtSetArg(save.posArgs[save.poscnt], XmNbuttonCount, NUM_LABELS);
save.poscnt++;
XtSetArg(save.posArgs[save.poscnt], XmNbuttonLabelStrings, button_string);
save.poscnt++;
XtSetArg (save.posArgs[save.poscnt], XmNdefaultPosition, False);
save.poscnt++;
style.kbdDialog = __DtCreateDialogBoxDialog(shell, "KeyboardDialog", save.posArgs, save.poscnt);
XtAddCallback(style.kbdDialog, XmNcallback, ButtonCB, NULL);
XtAddCallback(style.kbdDialog, XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_KEYBOARD_DIALOG);
XmStringFree(button_string[0]);
XmStringFree(button_string[1]);
XmStringFree(button_string[2]);
widget_list[0] = _DtDialogBoxGetButton(style.kbdDialog,2);
n=0;
XtSetArg(args[n], XmNautoUnmanage, False); n++;
XtSetArg(args[n], XmNcancelButton, widget_list[0]); n++;
XtSetValues (style.kbdDialog, args, n);
n=0;
XtSetArg(args[n], XmNtitle, ((char *)GETMESSAGE(13, 6, "Style Manager - Keyboard"))); n++;
XtSetArg (args[n], XmNuseAsyncGeometry, True); n++;
XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC ); n++;
XtSetValues (XtParent(style.kbdDialog), args, n);
n = 0;
XtSetArg(args[n], XmNhorizontalSpacing, style.horizontalSpacing); n++;
XtSetArg(args[n], XmNverticalSpacing, style.verticalSpacing); n++;
XtSetArg(args[n], XmNallowOverlap, False); n++;
XtSetArg(args[n], XmNchildType, XmWORK_AREA); n++;
form = XmCreateForm(style.kbdDialog, "keyboardForm", args, n);
/* create keyboard pixmap */
n = 0;
XtSetArg(args[n], XmNfillMode, XmFILL_SELF); n++;
XtSetArg(args[n], XmNbehavior, XmICON_LABEL); n++;
XtSetArg(args[n], XmNpixmapForeground, style.secBSCol); n++;
XtSetArg(args[n], XmNpixmapBackground, style.secTSCol); n++;
XtSetArg(args[n], XmNstring, NULL); n++;
XtSetArg(args[n], XmNshadowThickness, 0); n++;
XtSetArg(args[n], XmNimageName, KEYBOARD_ICON); n++;
XtSetArg(args[n], XmNtraversalOn, False); n++;
widget_list[count++] =
kbd.pictLabel= _DtCreateIcon(form, "keyboardpictLabel", args, n);
n = 0;
XtSetArg(args[n], XmNmarginHeight, LB_MARGIN_HEIGHT); n++;
XtSetArg(args[n], XmNmarginWidth, LB_MARGIN_WIDTH); n++;
string = CMPSTR(((char *)GETMESSAGE(13, 2, "Default")));
XtSetArg(args[n], XmNlabelString, string); n++;
XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
widget_list[count++] =
kbd.systemDefault= XmCreatePushButtonGadget(form, "systemDefault", args, n);
XmStringFree(string);
n = 0;
set = (kbd.values.global_auto_repeat == AutoRepeatModeOn) ? True : False;
XtSetArg(args[n], XmNset, set); n++;
string = CMPSTR(((char *)GETMESSAGE(13, 3, "Auto Repeat")));
XtSetArg(args[n], XmNlabelString, string); n++;
XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
widget_list[count++] =
kbd.autoRepeatToggle= XmCreateToggleButtonGadget(form, "autoRepeatToggle", args, n);
XmStringFree(string);
n = 0;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_END); n++;
string = CMPSTR(((char *)GETMESSAGE(13, 4, "Click Volume")));
XtSetArg(args[n], XmNmarginHeight, 0); n++;
XtSetArg(args[n], XmNlabelString, string); n++;
widget_list[count++] =
kbd.volumeLabGad= XmCreateLabelGadget(form,"volumeLabGad", args, n);
XmStringFree(string);
n = 0;
XtSetArg(args[n], XmNmaximum, VOLUME_MAX); n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg(args[n], XmNprocessingDirection, XmMAX_ON_RIGHT); n++;
XtSetArg(args[n], XmNshowValue, True); n++;
XtSetArg(args[n], XmNhighlightThickness, SCALE_HIGHLIGHT_THICKNESS); n++;
XtSetArg(args[n], XmNscaleWidth, SCALE_WIDTH); n++;
widget_list[count++] =
kbd.volumeScale= XmCreateScale(form,"volumeScale", args, n);
XtAddCallback(style.kbdDialog, XmNmapCallback, layoutCB, NULL);
XtAddCallback(style.kbdDialog, XmNmapCallback, _DtmapCB_keyboardDlg, shell);
XtAddCallback(kbd.systemDefault, XmNactivateCallback, systemDefaultCB, NULL);
XtAddCallback(kbd.volumeScale, XmNvalueChangedCallback, valueChangedCB, NULL);
XtAddCallback(kbd.autoRepeatToggle, XmNvalueChangedCallback, autoRepeatToggleCB, NULL);
XtManageChild(form);
XtManageChildren(widget_list,count);
return(style.kbdDialog);
}
XFE_PrefsLdapPropDialog::XFE_PrefsLdapPropDialog(XFE_PrefsDialog *prefsDialog,
XFE_PrefsPageMailNewsAddrBook *addrBookPage,
Widget parent, // dialog parent
char *name, // dialog name
Boolean modal) // modal dialog?
: XFE_Dialog(parent,
name,
TRUE, // ok
TRUE, // cancel
FALSE, // help
FALSE, // apply
FALSE, // separator
modal // modal
),
m_prefsDialog(prefsDialog),
m_addrBookPage(addrBookPage),
m_prefsDataLdapProp(0)
{
PrefsDataLdapProp *fep = NULL;
fep = new PrefsDataLdapProp;
memset(fep, 0, sizeof(PrefsDataLdapProp));
m_prefsDataLdapProp = fep;
Widget kids[100];
Arg av[50];
int ac;
int i;
Widget form;
form = XtVaCreateWidget("form", xmFormWidgetClass, m_chrome,
XmNmarginWidth, 8,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XtManageChild (form);
Widget desc_label;
Widget server_label;
Widget root_label;
Widget port_number_label;
Widget number_of_hit_label;
Widget desc_text;
Widget server_text;
Widget root_text;
Widget port_number_text;
Widget number_of_hit_text;
Widget secure_toggle;
#if 0
Widget save_passwd_toggle;
#endif
ac = 0;
i = 0;
kids[i++] = desc_label =
XmCreateLabelGadget(form, "descLabel", av, ac);
kids[i++] = server_label =
XmCreateLabelGadget(form, "serverLabel", av, ac);
kids[i++] = root_label =
XmCreateLabelGadget(form, "rootLabel", av, ac);
kids[i++] = port_number_label =
XmCreateLabelGadget(form, "portNumberLabel", av, ac);
kids[i++] = number_of_hit_label =
XmCreateLabelGadget(form, "numHitLabel", av, ac);
kids[i++] = desc_text =
fe_CreateTextField(form, "descText", av, ac);
kids[i++] = server_text =
fe_CreateTextField(form, "serverText", av, ac);
kids[i++] = root_text =
fe_CreateTextField(form, "rootText", av, ac);
kids[i++] = port_number_text =
fe_CreateTextField(form, "portNumberText", av, ac);
kids[i++] = number_of_hit_text =
fe_CreateTextField(form, "numberOfHitText", av, ac);
kids[i++] = secure_toggle =
XmCreateToggleButtonGadget(form, "secure", av, ac);
#if 0
kids[i++] = save_passwd_toggle =
XmCreateToggleButtonGadget(form, "savePasswd", av, ac);
#endif
fep->desc_text = desc_text;
fep->server_text = server_text;
fep->root_text = root_text;
fep->port_number_text = port_number_text;
fep->number_of_hit_text = number_of_hit_text;
fep->secure_toggle = secure_toggle;
#if 0
fep->save_passwd_toggle = save_passwd_toggle;
#endif
int labels_width;
labels_width = XfeVaGetWidestWidget(desc_label,
server_label,
root_label,
port_number_label,
number_of_hit_label,
NULL);
int labels_height;
labels_height = XfeVaGetTallestWidget(desc_label,
desc_text,
secure_toggle,
NULL);
XtVaSetValues(desc_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(desc_label,labels_width),
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(desc_text,
XmNcolumns, 35,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, labels_width,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(server_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(server_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, desc_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(server_text,
XmNcolumns, 35,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, server_label,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, desc_text,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(root_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(root_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, server_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(root_text,
XmNcolumns, 35,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, root_label,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, desc_text,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(port_number_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(port_number_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, root_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(port_number_text,
XmNcolumns, 6,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, port_number_label,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, desc_text,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(number_of_hit_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(number_of_hit_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, port_number_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(number_of_hit_text,
XmNcolumns, 6,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, number_of_hit_label,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, desc_text,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(secure_toggle,
XmNindicatorType, XmONE_OF_MANY,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, port_number_text,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, port_number_text,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
#if 0
XtVaSetValues(save_passwd_toggle,
XmNindicatorType, XmONE_OF_MANY,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, number_of_hit_text,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, secure_toggle,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
#endif
// Add callbacks
XtAddCallback(m_chrome, XmNokCallback, cb_ok, this);
XtAddCallback(m_chrome, XmNcancelCallback, cb_cancel, this);
XtManageChildren(kids, i);
XtManageChild(form);
}
XFE_PrefsProxiesViewDialog::XFE_PrefsProxiesViewDialog(XFE_PrefsDialog *prefsDialog, // prefs dialog
Widget parent, // dialog parent
char *name, // dialog name
Boolean modal) // modal dialog?
: XFE_Dialog(parent,
name,
TRUE, // ok
TRUE, // cancel
FALSE, // help
FALSE, // apply
FALSE, // separator
modal // modal
),
m_prefsDialog(prefsDialog),
m_prefsDataProxiesView(0)
{
PrefsDataProxiesView *fep = NULL;
fep = new PrefsDataProxiesView;
memset(fep, 0, sizeof(PrefsDataProxiesView));
m_prefsDataProxiesView = fep;
Widget form;
Widget kids[100];
Arg av[50];
int ac;
int i;
form = XtVaCreateWidget("form", xmFormWidgetClass, m_chrome,
XmNmarginWidth, 8,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XtManageChild (form);
Widget ftp_proxy_label;
Widget ftp_proxy_text;
Widget ftp_port_label;
Widget ftp_port_text;
Widget gopher_proxy_label;
Widget gopher_proxy_text;
Widget gopher_port_label;
Widget gopher_port_text;
Widget http_proxy_label;
Widget http_proxy_text;
Widget http_port_label;
Widget http_port_text;
Widget https_proxy_label;
Widget https_proxy_text;
Widget https_port_label;
Widget https_port_text;
Widget wais_proxy_label;
Widget wais_proxy_text;
Widget wais_port_label;
Widget wais_port_text;
Widget no_proxy_label;
Widget no_proxy_text;
Widget socks_host_label;
Widget socks_host_text;
Widget socks_port_label;
Widget socks_port_text;
Widget label1;
Widget label2;
ac = 0;
i = 0;
kids[i++] = label1 =
XmCreateLabelGadget(form, "proxyViewLabel1", av, ac);
kids[i++] = label2 =
XmCreateLabelGadget(form, "proxyViewLabel2", av, ac);
kids[i++] = ftp_proxy_label =
XmCreateLabelGadget(form, "ftpProxyLabel", av, ac);
kids[i++] = gopher_proxy_label =
XmCreateLabelGadget(form, "gopherProxyLabel", av, ac);
kids[i++] = http_proxy_label =
XmCreateLabelGadget(form, "httpProxyLabel", av, ac);
kids[i++] = https_proxy_label =
XmCreateLabelGadget(form, "httpsProxyLabel", av, ac);
kids[i++] = wais_proxy_label =
XmCreateLabelGadget(form, "waisProxyLabel", av, ac);
kids[i++] = no_proxy_label =
XmCreateLabelGadget(form, "noProxyLabel", av, ac);
kids[i++] = socks_host_label =
XmCreateLabelGadget(form, "socksHostLabel", av, ac);
kids[i++] = ftp_port_label =
XmCreateLabelGadget(form, "ftpPortLabel", av, ac);
kids[i++] = gopher_port_label =
XmCreateLabelGadget(form, "gopherPortLabel", av, ac);
kids[i++] = http_port_label =
XmCreateLabelGadget(form, "httpPortLabel", av, ac);
kids[i++] = https_port_label =
XmCreateLabelGadget(form, "httpsPortLabel", av, ac);
kids[i++] = wais_port_label =
XmCreateLabelGadget(form, "waisPortLabel", av, ac);
kids[i++] = socks_port_label =
XmCreateLabelGadget(form, "socksPortLabel", av, ac);
kids[i++] = ftp_proxy_text =
fe_CreateTextField(form, "ftpProxyText", av, ac);
kids[i++] = gopher_proxy_text =
fe_CreateTextField(form, "gopherProxyText", av, ac);
kids[i++] = http_proxy_text =
fe_CreateTextField(form, "httpProxyText", av, ac);
kids[i++] = https_proxy_text =
fe_CreateTextField(form, "httpsProxyText", av, ac);
kids[i++] = wais_proxy_text =
fe_CreateTextField(form, "waisProxyText", av, ac);
kids[i++] = no_proxy_text =
fe_CreateTextField(form, "noProxyText", av, ac);
kids[i++] = socks_host_text =
fe_CreateTextField(form, "socksHostText", av, ac);
kids[i++] = ftp_port_text =
fe_CreateTextField(form, "ftpPortText", av, ac);
kids[i++] = gopher_port_text =
fe_CreateTextField(form, "gopherPortText", av, ac);
kids[i++] = http_port_text =
fe_CreateTextField(form, "httpPortText", av, ac);
kids[i++] = https_port_text =
fe_CreateTextField(form, "httpsPortText", av, ac);
kids[i++] = wais_port_text =
fe_CreateTextField(form, "waisPortText", av, ac);
kids[i++] = socks_port_text =
fe_CreateTextField(form, "socksPortText", av, ac);
int labels_width;
labels_width = XfeVaGetWidestWidget(ftp_proxy_label,
gopher_proxy_label,
http_proxy_label,
https_proxy_label,
wais_proxy_label,
no_proxy_label,
socks_host_label,
NULL);
Dimension margin_width;
XtVaGetValues(form,
XmNmarginWidth, &margin_width,
NULL);
labels_width+= margin_width;
int labels_height;
labels_height = XfeVaGetTallestWidget(ftp_proxy_label,
ftp_proxy_text,
NULL);
XtVaSetValues(label1,
XmNalignment, XmALIGNMENT_BEGINNING,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(ftp_proxy_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(ftp_proxy_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, label1,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(gopher_proxy_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(gopher_proxy_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, ftp_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(http_proxy_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(http_proxy_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, gopher_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(https_proxy_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(https_proxy_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, http_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(wais_proxy_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(wais_proxy_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, https_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(label2,
XmNalignment, XmALIGNMENT_BEGINNING,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, wais_proxy_label,
XmNtopOffset, 8,
XmNleftAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(no_proxy_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(no_proxy_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, label2,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(socks_host_label,
XmNheight, labels_height,
RIGHT_JUSTIFY_VA_ARGS(socks_host_label,labels_width),
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, no_proxy_label,
XmNtopOffset, 8,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(ftp_proxy_text,
XmNcolumns, 20,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, labels_width,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, ftp_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(gopher_proxy_text,
XmNcolumns, 20,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, labels_width,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, gopher_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(http_proxy_text,
XmNcolumns, 20,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, labels_width,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, http_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(https_proxy_text,
XmNcolumns, 20,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, labels_width,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, https_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(wais_proxy_text,
XmNcolumns, 20,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, labels_width,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, wais_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(no_proxy_text,
XmNcolumns, 20,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, labels_width,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, no_proxy_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(socks_host_text,
XmNcolumns, 20,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, labels_width,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, socks_host_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(ftp_port_label,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, ftp_proxy_text,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, ftp_proxy_text,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(gopher_port_label,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, gopher_proxy_text,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, gopher_proxy_text,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(http_port_label,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, http_proxy_text,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, http_proxy_text,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(https_port_label,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, https_proxy_text,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, https_proxy_text,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(wais_port_label,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, wais_proxy_text,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, wais_proxy_text,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(socks_port_label,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, socks_host_text,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, socks_host_text,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(ftp_port_text,
XmNcolumns, 5,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, ftp_port_label,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, ftp_port_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(gopher_port_text,
XmNcolumns, 5,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, gopher_port_label,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, gopher_port_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(http_port_text,
XmNcolumns, 5,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, http_port_label,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, http_port_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(https_port_text,
XmNcolumns, 5,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, https_port_label,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, https_port_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(wais_port_text,
XmNcolumns, 5,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, wais_port_label,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, wais_port_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(socks_port_text,
XmNcolumns, 5,
XmNheight, labels_height,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, socks_port_label,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, socks_port_label,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
if (fe_globalData.nonterminal_text_translations) {
XtOverrideTranslations (ftp_proxy_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (ftp_port_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (gopher_proxy_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (gopher_port_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (http_proxy_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (http_port_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (https_proxy_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (https_port_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (wais_proxy_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (wais_port_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (no_proxy_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (socks_host_text,
fe_globalData.nonterminal_text_translations);
XtOverrideTranslations (socks_port_text,
fe_globalData.nonterminal_text_translations);
}
fep->ftp_proxy_text = ftp_proxy_text;
fep->ftp_port_text = ftp_port_text;
fep->gopher_proxy_text = gopher_proxy_text;
fep->gopher_port_text = gopher_port_text;
fep->http_proxy_text = http_proxy_text;
fep->http_port_text = http_port_text;
fep->https_proxy_text = https_proxy_text;
fep->https_port_text = https_port_text;
fep->wais_proxy_text = wais_proxy_text;
fep->wais_port_text = wais_port_text;
fep->no_proxy_text = no_proxy_text;
fep->socks_host_text = socks_host_text;
fep->socks_port_text = socks_port_text;
// Add callbacks
XtAddCallback(m_chrome, XmNokCallback, prefsProxiesViewCb_ok, this);
XtAddCallback(m_chrome, XmNcancelCallback, prefsProxiesViewCb_cancel, this);
XtManageChildren(kids, i);
}
void
MakeChooser( void )
{
int i;
/** greeting **/
XtGetSubresources(table, &greetInfo, "greeting", "Greeting",
greetResources, XtNumber(greetResources), NULL, 0);
i = InitArg(LabelG);
xmstr = ReadCatalogXms(MC_CHOOSER_SET, MC_CHOOSER_TITLE, MC_DEF_CHOOSER_TITLE);
XtSetArg(argt[i], XmNtraversalOn, False); i++;
XtSetArg(argt[i], XmNlabelString, xmstr); i++;
XtSetArg(argt[i], XmNtopAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNtopOffset, 10); i++;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNrightAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNalignment, XmALIGNMENT_CENTER); i++;
if ( greetInfo.fontList != NULL ) {
XtSetArg(argt[i], XmNfontList, greetInfo.fontList); i++;
}
greeting = XmCreateLabel(matte1, "greeting", argt, i);
XtManageChild(greeting);
XmStringFree(xmstr);
/** list head **/
i = InitArg(LabelG);
xmstr = ReadCatalogXms(MC_CHOOSER_SET, MC_CHOOSER_HEADING,
MC_DEF_CHOOSER_HEADING);
XtSetArg(argt[i], XmNtraversalOn, False); i++;
XtSetArg(argt[i], XmNlabelString, xmstr); i++;
XtSetArg(argt[i], XmNtopAttachment, XmATTACH_WIDGET); i++;
XtSetArg(argt[i], XmNtopWidget, greeting); i++;
XtSetArg(argt[i], XmNtopOffset, 10); i++;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNleftOffset, 13); i++;
if (appInfo.chlistFont != NULL) {
XtSetArg(argt[i], XmNfontList, appInfo.chlistFont); i++;
}
list_head = XmCreateLabelGadget(matte1, "list_head", argt, i);
XtManageChild(list_head);
XmStringFree(xmstr);
i = 0;
XtSetArg(argt[i], XmNresizable, True);
XtSetValues(matte, argt, i);
XtSetValues(matte1, argt, i);
/** chooser_list **/
i = 0;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNleftOffset, 10); i++;
XtSetArg(argt[i], XmNrightAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNrightOffset, 10); i++;
XtSetArg(argt[i], XmNtopAttachment, XmATTACH_WIDGET); i++;
XtSetArg(argt[i], XmNtopWidget, list_head); i++;
XtSetArg(argt[i], XmNtopOffset, 1); i++;
XtSetArg(argt[i], XmNbottomAttachment, XmATTACH_WIDGET); i++;
XtSetArg(argt[i], XmNbottomWidget, ok_button); i++;
XtSetArg(argt[i], XmNbottomOffset, 10); i++;
XtSetArg(argt[i], XmNallowShellResize, True); i++;
XtSetArg(argt[i], XmNlistSizePolicy, XmCONSTANT); i++;
XtSetArg(argt[i], XmNscrollBarDisplayPolicy, XmSTATIC); i++;
if (appInfo.chlistFont != NULL) {
XtSetArg(argt[i], XmNfontList, appInfo.chlistFont); i++;
}
chooser_list = XmCreateScrolledList(matte1, "chooser_list", argt, i);
XtAddCallback(chooser_list, XmNdefaultActionCallback, DoAccept, NULL);
XtManageChild(chooser_list);
if (appInfo.workspaceCursor)
{
MakeRootCursor();
}
else
{
XUndefineCursor(dpyinfo.dpy, dpyinfo.root);
}
}
static Widget
h_create_colors_form(Widget top, struct topic_info *info)
{
Widget text_bg_frame, text_bg_label, text_bg_form;
Widget links_frame, links_label, links_form;
Widget fg_label, fg_button;
Widget bg_label, bg_button;
Widget unvisited_label, unvisited_button;
Widget visited_label, visited_button;
Widget underline_toggle;
Widget colorspecials_toggle;
Widget form = XmCreateForm(top, "colors_form", NULL, 0);
Pixel visited_link_pix, link_pix;
str_to_pixel(top, resource.visited_link_color, &visited_link_pix);
str_to_pixel(top, resource.link_color, &link_pix);
text_bg_frame = XmCreateFrame(form, "text_bg_frame", NULL, 0);
XtVaSetValues(text_bg_frame,
XmNmarginWidth, 10,
XmNmarginHeight, 10,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 50,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
text_bg_label = XmCreateLabelGadget(text_bg_frame, "Text Color", &frame_title, 1);
XtManageChild(text_bg_label);
text_bg_form = XmCreateForm(text_bg_frame, "fg_form", NULL, 0);
XtVaSetValues(text_bg_form, XmNverticalSpacing, 2, NULL);
fg_label = XmCreateLabelGadget(text_bg_form, Xdvi_FG_COLOR_STR, NULL, 0);
fg_button = h_create_colorsample(text_bg_form, fg_label,
Xdvi_FG_COLOR_BTN, "foreground",
resource.fore_Pixel, info);
XtVaSetValues(fg_label,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
NULL);
XtVaSetValues(fg_button,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_NONE,
NULL);
adjust_heights(fg_label, fg_button, NULL);
XtManageChild(fg_label);
XtManageChild(fg_button);
bg_label = XmCreateLabelGadget(text_bg_form, Xdvi_BG_COLOR_STR, NULL, 0);
bg_button = h_create_colorsample(text_bg_form, bg_label,
Xdvi_BG_COLOR_BTN, "background",
resource.back_Pixel, info);
XtVaSetValues(bg_label,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, fg_label,
NULL);
XtVaSetValues(bg_button,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_NONE,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, fg_label,
NULL);
adjust_heights(bg_label, bg_button, NULL);
XtManageChild(bg_label);
XtManageChild(bg_button);
colorspecials_toggle = XmCreateToggleButtonGadget(text_bg_form, Xdvi_DOCUMENT_COLORS_STR, &n_of_many, 1);
XtVaSetValues(colorspecials_toggle,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, bg_label,
NULL);
XtManageChild(colorspecials_toggle);
XmToggleButtonGadgetSetState(colorspecials_toggle, resource.use_color, False);
XtAddCallback(colorspecials_toggle, XmNvalueChangedCallback, colorspecial_toggle_cb, (XtPointer)info);
links_frame = XmCreateFrame(form, "links_frame", NULL, 0);
XtVaSetValues(links_frame,
XmNmarginWidth, 10,
XmNmarginHeight, 10,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, text_bg_frame,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
links_label = XmCreateLabelGadget(links_frame, "Hyperlinks", &frame_title, 1);
XtManageChild(links_label);
links_form = XmCreateForm(links_frame, "links_form", NULL, 0);
XtVaSetValues(links_form,
XmNverticalSpacing, 2,
NULL);
unvisited_label = XmCreateLabelGadget(links_form, Xdvi_UNVISITED_LINKS_STR, NULL, 0);
unvisited_button = h_create_colorsample(links_form, unvisited_label,
Xdvi_UNVISITED_LINKS_BTN, "linkColor",
link_pix, info);
XtVaSetValues(unvisited_label,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
NULL);
XtVaSetValues(unvisited_button,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_NONE,
XmNtopAttachment, XmATTACH_FORM,
NULL);
adjust_heights(unvisited_label, unvisited_button, NULL);
XtManageChild(unvisited_label);
XtManageChild(unvisited_button);
visited_label = XmCreateLabelGadget(links_form, Xdvi_VISITED_LINKS_STR, NULL, 0);
visited_button = h_create_colorsample(links_form, visited_label,
Xdvi_VISITED_LINKS_BTN, "visitedLinkColor",
visited_link_pix, info);
XtVaSetValues(visited_label,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, unvisited_label,
NULL);
XtVaSetValues(visited_button,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_NONE,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, unvisited_label,
NULL);
adjust_heights(visited_label, visited_button, NULL);
XtManageChild(visited_label);
XtManageChild(visited_button);
underline_toggle = XmCreateToggleButtonGadget(links_form, Xdvi_LINKS_UNDERLINED_STR, &n_of_many, 1);
XtVaSetValues(underline_toggle,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, visited_label,
NULL);
XtManageChild(underline_toggle);
/* if (res->link_style & 1) */
if (resource.link_style & 1)
XmToggleButtonGadgetSetState(underline_toggle, True, False);
else
XmToggleButtonGadgetSetState(underline_toggle, False, False);
XtAddCallback(underline_toggle, XmNvalueChangedCallback, underline_toggle_cb, (XtPointer)info);
XtManageChild(links_frame);
XtManageChild(text_bg_frame);
XtManageChild(text_bg_form);
XtManageChild(links_form);
return form;
}
Widget
prefs_fonts_and_colors(struct topic_info *info)
{
Widget form;
Widget colors_form;
Widget other_colors_frame, fonts_frame;
form = XmCreateForm(info->right_form, "fonts_colors_form", NULL, 0);
h_attach_below(form, NULL);
colors_form = h_create_colors_form(form, info);
h_attach_below(colors_form, NULL);
XtManageChild(colors_form);
{ /* other colors - currently only highlight color */
Widget other_colors_form, other_colors_label;
Widget hl_color_text, hl_color_button;
other_colors_frame = XmCreateFrame(form, "other_colors_frame", &v_off, 1);
XtVaSetValues(other_colors_frame,
XmNmarginWidth, 10,
NULL);
h_attach_below(other_colors_frame, colors_form);
other_colors_label = XmCreateLabelGadget(other_colors_frame, "Highlight Color", &frame_title, 1);
other_colors_form = XmCreateForm(other_colors_frame, "other_colors_form", NULL, 0);
XtVaSetValues(other_colors_form, XmNverticalSpacing, 2, NULL);
hl_color_text = XmCreateLabelGadget(other_colors_form,
#if defined(LESSTIF_VERSION) /* stupid LessTif doesn't wrap Labels at '\n' */
"Color of page border, rulers and bounding boxes.",
#else
"Color used for page border, rulers in `ruler mode', and\n"
"bounding boxes for forward search and EPS images.",
#endif
NULL, 0);
hl_color_button = h_create_colorsample(other_colors_form, hl_color_text,
Xdvi_HL_COLOR_BTN, "highlight",
resource.hl_Pixel, info);
XtVaSetValues(hl_color_text,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 10,
XmNalignment, XmALIGNMENT_BEGINNING,
NULL);
XtVaSetValues(hl_color_button,
XmNtopAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
XtManageChild(hl_color_text);
XtManageChild(hl_color_button);
XtManageChild(other_colors_form);
XtManageChild(other_colors_label);
XtManageChild(other_colors_frame);
}
fonts_frame = h_create_fonts_frame(form, info);
h_attach_below(fonts_frame, other_colors_frame);
XtManageChild(fonts_frame);
XtManageChild(form);
return form;
}
static void createBrowserOneDHistPanel(nTuBrowserInfo *nTuBr)
{
Arg args[50];
int ac;
XmString s1, *st1;
Widget dismissBtn, nbinLabel, lowEdgeLabel, highEdgeLabel, multLabel;
Widget histForm, ntupleForm, titleLabel, histLabel, ntupleLabel;
Widget ntupleCatLabel, ntupleTitleLabel;
ac = 0;
XtSetArg(args[ac], XmNautoUnmanage, False); ac++;
XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_NONE); ac++;
OneDHistFormW = XmCreateFormDialog(McfioMainPanelW, "form", args, ac);
OneDHistShellW = XtParent(OneDHistFormW);
XtVaSetValues(OneDHistShellW, XmNtitle,
"One Dimensional Histogram Utility", 0);
AddMotifCloseCallback(XtParent(OneDHistFormW),
(XtCallbackProc)dismissOneDHistCB, NULL);
OneDHistCreateW = XtVaCreateManagedWidget("create1DBtn",
xmPushButtonGadgetClass, OneDHistFormW,
XmNlabelString, s1=XmStringCreateSimple("Create"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 2,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 18, 0);
XmStringFree(s1);
XtAddCallback( OneDHistCreateW, XmNactivateCallback,
(XtCallbackProc)createOneDHistCB, (nTuBrowserInfo *) nTuBr );
OneDHistModifyW = XtVaCreateManagedWidget("modify1DBtn",
xmPushButtonGadgetClass, OneDHistFormW,
XmNlabelString, s1=XmStringCreateSimple("Modify"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 20,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 40, 0);
XmStringFree(s1);
XtAddCallback( OneDHistModifyW, XmNactivateCallback,
(XtCallbackProc)modifyOneDHistCB, NULL);
OneDHistDeleteW = XtVaCreateManagedWidget("delete1DBtn",
xmPushButtonGadgetClass, OneDHistFormW,
XmNlabelString, s1=XmStringCreateSimple("Delete"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 42,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 60, 0);
XmStringFree(s1);
XtAddCallback( OneDHistDeleteW, XmNactivateCallback,
(XtCallbackProc)deleteOneDHistCB, NULL);
dismissBtn = XtVaCreateManagedWidget("dismissBtn",
xmPushButtonGadgetClass, OneDHistFormW,
XmNlabelString, s1=XmStringCreateSimple("Dismiss"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 80,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 98, 0);
XmStringFree(s1);
XtAddCallback(dismissBtn, XmNactivateCallback,
(XtCallbackProc)dismissOneDHistCB, NULL);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Number of bins:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,5); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
nbinLabel =
XmCreateLabelGadget(OneDHistFormW, "num1Dbin", args, ac);
XmStringFree(s1);
XtManageChild(nbinLabel);
OneDHistNumBinsW = XtVaCreateManagedWidget("numBin1D",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 5,
XmNmaxLength, 5,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistCreateW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,nbinLabel, 0);
RemapDeleteKey(OneDHistNumBinsW);
XmTextSetString(OneDHistNumBinsW, "100");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Low Edge:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,OneDHistNumBinsW); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
lowEdgeLabel =
XmCreateLabelGadget(OneDHistFormW, "low1Dbin", args, ac);
XmStringFree(s1);
XtManageChild(lowEdgeLabel);
OneDHistLowBinW = XtVaCreateManagedWidget("lowEdge1D",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 10,
XmNmaxLength, 20,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistCreateW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,lowEdgeLabel, 0);
RemapDeleteKey(OneDHistLowBinW);
XmTextSetString(OneDHistLowBinW, "0.");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("High Edge:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,OneDHistLowBinW); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
highEdgeLabel =
XmCreateLabelGadget(OneDHistFormW, "high1Dbin", args, ac);
XmStringFree(s1);
XtManageChild(highEdgeLabel);
OneDHistHighBinW = XtVaCreateManagedWidget("highEdge1D",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 10,
XmNmaxLength, 20,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistCreateW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,highEdgeLabel, 0);
RemapDeleteKey(OneDHistHighBinW);
XmTextSetString(OneDHistHighBinW, "1.");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Instance:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,OneDHistHighBinW); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
multLabel =
XmCreateLabelGadget(OneDHistFormW, "inst1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(multLabel);
OneDHistMultW = XtVaCreateManagedWidget("inst1DTw",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 10,
XmNmaxLength, 20,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistCreateW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,multLabel, 0);
RemapDeleteKey(OneDHistMultW);
XmTextSetString(OneDHistMultW, "All");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Title:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistNumBinsW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
titleLabel =
XmCreateLabelGadget(OneDHistFormW, "title1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(titleLabel);
OneDHistTitleW = XtVaCreateManagedWidget("title1DTw",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 80,
XmNmaxLength, 255,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistNumBinsW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,titleLabel, 0);
RemapDeleteKey(OneDHistTitleW);
XmTextSetString(OneDHistTitleW, "Please enter a meaningful title here");
/*
** Now the list of 1D histograms.
*/
/* Create a form to hold the list and the top label */
ac = 0;
XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget, OneDHistTitleW); ac++;
XtSetArg(args[ac], XmNbottomOffset, 3); ac++;
XtSetArg(args[ac], XmNleftOffset, 2); ac++;
XtSetArg(args[ac], XmNtopOffset, 2); ac++;
histForm = XmCreateForm(OneDHistFormW, "hist1DForm", args, ac);
XtManageChild(histForm);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple(
"One Dimensional Histogram Listing"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
histLabel =
XmCreateLabelGadget(histForm, "HIST1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(histLabel);
ac = 0;
XtSetArg(args[ac], XmNitems, (st1=StringTable(1,
"No histogram defined "))); ac++;
XtSetArg(args[ac], XmNitemCount, 1); ac++;
XtSetArg(args[ac], XmNscrollBarDisplayPolicy, XmAS_NEEDED); ac++;
XtSetArg(args[ac], XmNvisibleItemCount, 10); ac++;
XtSetArg(args[ac], XmNselectionPolicy, XmBROWSE_SELECT); ac++;
XtSetArg(args[ac], XmNlistSizePolicy, XmCONSTANT); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopWidget, histLabel); ac++;
XtSetArg(args[ac], XmNtopOffset, 0); ac++;
XtSetArg(args[ac], XmNleftOffset, 3); ac++;
XtSetArg(args[ac], XmNbottomOffset, 4); ac++;
OneDHistHistoListW = XmCreateScrolledList(histForm, "hist1DList", args,ac);
FreeStringTable(st1);
XtAddCallback(OneDHistHistoListW, XmNbrowseSelectionCallback,
(XtCallbackProc) oneDHistListCB, NULL);
XtManageChild(OneDHistHistoListW);
OneDHistSizeOfList = 10;
OneDHistNumberListed = 0;
OneDHistListedIDs = (int *) malloc(sizeof(int) * OneDHistSizeOfList);
/*
** Now the list of Ntuple Variables. Also a few Label to refer to the
** Ntuple category/title listed on the Main panel.
**
*/
/* Create a form to hold the list and the top label */
ac = 0;
XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget, histForm); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget, OneDHistTitleW); ac++;
XtSetArg(args[ac], XmNbottomOffset, 3); ac++;
XtSetArg(args[ac], XmNleftOffset, 6); ac++;
XtSetArg(args[ac], XmNtopOffset, 2); ac++;
ntupleForm = XmCreateForm(OneDHistFormW, "ntu1DForm", args, ac);
XtManageChild(ntupleForm);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Selected NTuple Synopsis"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
ntupleLabel =
XmCreateLabelGadget(ntupleForm, "NTU1DDlabel", args, ac);
XmStringFree(s1);
XtManageChild(ntupleLabel);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Category:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset, 3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopOffset, 1); ac++;
XtSetArg(args[ac], XmNtopWidget,ntupleLabel ); ac++;
ntupleCatLabel =
XmCreateLabelGadget(ntupleForm, "NTU1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(ntupleCatLabel);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("None----------------------"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,ntupleCatLabel ); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopOffset, 1); ac++;
XtSetArg(args[ac], XmNtopWidget,ntupleLabel ); ac++;
OneDHistNtupleCategoryLabelW =
XmCreateLabelGadget(ntupleForm, "NTU1DCatlabel", args, ac);
XmStringFree(s1);
XtManageChild(OneDHistNtupleCategoryLabelW);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Title:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, ntupleCatLabel); ac++;
XtSetArg(args[ac], XmNtopOffset, 1); ac++;
ntupleTitleLabel =
XmCreateLabelGadget(ntupleForm, "NTU1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(ntupleTitleLabel);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("None----------------------"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,ntupleCatLabel ); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget,ntupleCatLabel ); ac++;
XtSetArg(args[ac], XmNtopOffset, 1); ac++;
OneDHistNtupleTitleLabelW =
XmCreateLabelGadget(ntupleForm, "NTU1DTitlabel", args, ac);
XmStringFree(s1);
XtManageChild(OneDHistNtupleTitleLabelW);
ac = 0;
XtSetArg(args[ac], XmNitems, (st1=StringTable(1, " "))); ac++;
XtSetArg(args[ac], XmNitemCount, 1); ac++;
XtSetArg(args[ac], XmNscrollBarDisplayPolicy, XmAS_NEEDED); ac++;
XtSetArg(args[ac], XmNvisibleItemCount, 10); ac++;
XtSetArg(args[ac], XmNselectionPolicy, XmBROWSE_SELECT); ac++;
XtSetArg(args[ac], XmNlistSizePolicy, XmCONSTANT); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopWidget, OneDHistNtupleTitleLabelW); ac++;
XtSetArg(args[ac], XmNtopOffset, 2); ac++;
XtSetArg(args[ac], XmNleftOffset, 3); ac++;
OneDHistVariableListW = XmCreateScrolledList(ntupleForm, "hist1DList", args,ac);
FreeStringTable(st1);
XtManageChild(OneDHistVariableListW);
FirstOneDHistogram = True;
XtManageChild(OneDHistFormW);
}
static void
initialize(Widget request, Widget new_w, ArgList args, Cardinal *num_args)
{
Widget option = NULL, menu = NULL, demo, form, top = NULL, count_label;
Arg al[10];
int ac, i;
XmString xms;
char *p, *q, *fn, *n;
MB_DialogType(new_w) = XmDIALOG_MESSAGE;
ac = 0;
form = XmCreateForm(new_w, "form", al, ac);
p = fn = strdup(FC_FieldNames(new_w));
n = XtMalloc(strlen(fn) + 10);
FC_Menus(new_w) = (Widget *)XtCalloc(14, sizeof(Widget));
FC_Setting(new_w) = (String *)XtCalloc(14, sizeof(String));
for (i=0; i<14; i++)
FC_Setting(new_w)[i] = NULL;
for (i=0; i<14; i++) { /* XLFD has this many fields */
q = strchr(p, ',');
if (q)
*q = '\0';
strcpy(n, p);
strcat(n, "_pulldown");
ac = 0;
FC_Menus(new_w)[i] = menu = XmCreatePulldownMenu(form, n, al, ac);
XtAddCallback(menu, XmNmapCallback, FitMenuOnScreen, NULL);
strcpy(n, p);
xms = XmStringCreateSimple(n);
strcat(n, "_option");
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, menu); ac++;
if (i == 0 || i == 4 || i == 10) {
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
} else {
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, option); ac++;
}
if (i >= 4) {
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, top); ac++;
}
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNlabelString, xms); ac++;
option = XmCreateOptionMenu(form, n, al, ac);
XtManageChild(option);
XmStringFree(xms);
if (i == 3 || i == 9)
top = option;
if (q)
p = q+1;
}
free(fn);
XtFree(n);
ac = 0;
xms = XmStringCreateSimple(FC_CountString(new_w));
XtSetArg(al[ac], XmNlabelString, xms); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 10); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, option); ac++;
XtSetArg(al[ac], XmNtopOffset, 10); ac++;
FC_CountWidget(new_w) = count_label = XmCreateLabelGadget(form, "count_label", al, ac);
XmStringFree(xms);
ac = 0;
xms = XmStringCreateSimple(FC_DemoString(new_w));
XtSetArg(al[ac], XmNlabelString, xms); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 10); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, option); ac++;
XtSetArg(al[ac], XmNtopOffset, 10); ac++;
FC_DemoWidget(new_w) = demo = XmCreateLabelGadget(form, "demo_label", al, ac);
XmStringFree(xms);
if (FC_ShowDemo(new_w)) {
XtManageChild(count_label);
XtManageChild(demo);
}
GetFullFontList(new_w);
XtManageChild(form);
}
Widget
prefs_appearance(struct topic_info *info)
{
Widget form;
Widget gui_frame, gui_label, gui_rowcol,
gui_statusline, gui_toolbar, gui_pagelist, gui_scrollbars;
Widget tips_frame, tips_label, tips_form, tips_statusline;
Widget tips_popups, tips_delay_text, tips_delay_label1, tips_delay_label2;
Widget match_frame, match_label, match_rowcol, match_inverted, match_boxed;
#if 0
Widget tb_buttons_frame, tb_buttons_label, tb_buttons_rowcol,
tb_buttons_flat, tb_buttons_raised;
#endif
XmString str;
char buf[LENGTH_OF_INT];
Arg args[10];
int n;
form = XmCreateForm(info->right_form, "appearance_form", NULL, 0);
h_attach_below(form, NULL);
n = 0;
XtSetArg(args[n], XmNmarginWidth, 8); n++;
XtSetArg(args[n], XmNmarginHeight, 4); n++;
gui_frame = XmCreateFrame(form, "gui_frame", args, n);
h_attach_below(gui_frame, NULL);
gui_label = XmCreateLabelGadget(gui_frame, "Window Configuration", &frame_title, 1);
XtManageChild(gui_label);
gui_rowcol = XmCreateRowColumn(gui_frame, "gui_rowcol", two_cols_fixed, XtNumber(two_cols_fixed));
XtManageChild(gui_rowcol);
gui_statusline = XmCreateToggleButtonGadget(gui_rowcol, Xdvi_GUI_STATUSLINE_STR, &n_of_many, 1);
XmToggleButtonGadgetSetState(gui_statusline, resource.expert_mode & XPRT_SHOW_STATUSLINE ? True : False, False);
XtManageChild(gui_statusline);
gui_toolbar = XmCreateToggleButtonGadget(gui_rowcol, Xdvi_GUI_TOOLBAR_STR, &n_of_many, 1);
XmToggleButtonGadgetSetState(gui_toolbar, resource.expert_mode & XPRT_SHOW_TOOLBAR ? True : False, False);
XtManageChild(gui_toolbar);
gui_pagelist = XmCreateToggleButtonGadget(gui_rowcol, Xdvi_GUI_PAGELIST_STR, &n_of_many, 1);
XmToggleButtonGadgetSetState(gui_pagelist, resource.expert_mode & XPRT_SHOW_PAGELIST ? True : False, False);
XtManageChild(gui_pagelist);
gui_scrollbars = XmCreateToggleButtonGadget(gui_rowcol, Xdvi_GUI_SCROLLBARS_STR, &n_of_many, 1);
XmToggleButtonGadgetSetState(gui_scrollbars, resource.expert_mode & XPRT_SHOW_SCROLLBARS ? True : False, False);
XtManageChild(gui_scrollbars);
XtAddCallback(gui_statusline, XmNvalueChangedCallback, gui_buttons_cb, (XtPointer)info);
XtAddCallback(gui_toolbar, XmNvalueChangedCallback, gui_buttons_cb, (XtPointer)info);
XtAddCallback(gui_pagelist, XmNvalueChangedCallback, gui_buttons_cb, (XtPointer)info);
XtAddCallback(gui_scrollbars, XmNvalueChangedCallback, gui_buttons_cb, (XtPointer)info);
n = 0;
XtSetArg(args[n], XmNmarginWidth, 8); n++;
XtSetArg(args[n], XmNmarginHeight, 4); n++;
XtSetArg(args[n], XmNtopOffset, 10); n++;
tips_frame = XmCreateFrame(form, "tips_frame", args, n);
h_attach_below(tips_frame, gui_frame);
tips_label = XmCreateLabelGadget(tips_frame, "Show Tooltips", &frame_title, 1);
XtManageChild(tips_label);
tips_form = XmCreateForm(tips_frame, "tips_form", NULL, 0);
str = XmStringCreateLocalized("As Text in Statusline");
tips_statusline = XtVaCreateManagedWidget(Xdvi_TIPS_STATUSLINE,
xmToggleButtonGadgetClass, tips_form,
XmNlabelString, str,
XmNindicatorType, XmN_OF_MANY,
XmNset, True,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
NULL);
XmStringFree(str);
str = XmStringCreateLocalized("As Popups");
tips_popups = XtVaCreateManagedWidget(Xdvi_TIPS_POPUPS,
xmToggleButtonGadgetClass, tips_form,
XmNlabelString, str,
XmNindicatorType, XmN_OF_MANY,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_statusline,
XmNleftAttachment, XmATTACH_FORM,
NULL);
XmStringFree(str);
str = XmStringCreateLocalized("with");
tips_delay_label1 = XtVaCreateManagedWidget(Xdvi_TIPS_DELAY_LABEL1,
xmLabelGadgetClass, tips_form,
XmNlabelString, tips_form,
XmNlabelString, str,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_statusline,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, tips_popups,
XmNleftOffset, 0, /* no spacing to prev text */
NULL);
XmStringFree(str);
SNPRINTF(buf, LENGTH_OF_INT, "%d", ABS(resource.tooltips_wait_period));
tips_delay_text = XtVaCreateManagedWidget(Xdvi_TIPS_DELAY_TEXT,
xmTextFieldWidgetClass, tips_form,
XmNcolumns, 4,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_statusline,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, tips_delay_label1,
XmNvalue, buf,
NULL);
str = XmStringCreateLocalized("milliseconds delay");
tips_delay_label2 = XtVaCreateManagedWidget(Xdvi_TIPS_DELAY_LABEL2,
xmLabelGadgetClass, tips_form,
XmNlabelString, str,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_statusline,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, tips_delay_text,
NULL);
adjust_heights(tips_popups, tips_delay_label1, tips_delay_text, tips_delay_label2, NULL);
XmToggleButtonGadgetSetState(tips_statusline, resource.tooltips_in_statusline, False);
XmToggleButtonGadgetSetState(tips_popups, resource.show_tooltips, False);
if (resource.toolbar_unusable) {
XtSetSensitive(tips_frame, False);
}
else {
XtSetSensitive(tips_delay_label1, resource.show_tooltips);
XtSetSensitive(tips_delay_text, resource.show_tooltips);
XtSetSensitive(tips_delay_label2, resource.show_tooltips);
XtAddCallback(tips_statusline, XmNvalueChangedCallback, tooltips_cb, (XtPointer)info);
XtAddCallback(tips_popups, XmNvalueChangedCallback, tooltips_cb, (XtPointer)info);
XtAddCallback(tips_delay_text, XmNvalueChangedCallback, tooltips_cb, (XtPointer)info);
}
#if 0
tb_buttons_frame = XmCreateFrame(form, "tb_buttons_frame", &v_off, 1);
h_attach_below(tb_buttons_frame, tips_frame);
tb_buttons_label = XmCreateLabelGadget(tb_buttons_frame, "Toolbar Buttons:", &frame_title, 1);
XtManageChild(tb_buttons_label);
tb_buttons_rowcol = XmCreateRowColumn(tb_buttons_frame, "tb_buttons_rowcol", two_cols, XtNumber(two_cols));
XtManageChild(tb_buttons_rowcol);
tb_buttons_raised = XmCreateToggleButtonGadget(tb_buttons_rowcol, "Raised", &one_of_many, 1);
XtManageChild(tb_buttons_raised);
tb_buttons_flat = XmCreateToggleButtonGadget(tb_buttons_rowcol, "Flat", &one_of_many, 1);
XtManageChild(tb_buttons_flat);
toolbar_buttons_init((XtPointer)info, tb_buttons_raised, tb_buttons_flat);
#endif /* 0 */
n = 0;
XtSetArg(args[n], XmNmarginWidth, 8); n++;
XtSetArg(args[n], XmNmarginHeight, 4); n++;
XtSetArg(args[n], XmNtopOffset, 10); n++;
match_frame = XmCreateFrame(form, "match_frame", args, n);
XtVaSetValues(match_frame,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_frame,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
match_label = XmCreateLabelGadget(match_frame, "String Matches are shown:", &frame_title, 1);
XtManageChild(match_label);
match_rowcol = XmCreateRowColumn(match_frame, "tb_buttons_rowcol", two_cols, XtNumber(two_cols));
XtManageChild(match_rowcol);
match_inverted = XmCreateToggleButtonGadget(match_rowcol, Xdvi_MATCH_INVERTED_STR, &one_of_many, 1);
XtManageChild(match_inverted);
match_boxed = XmCreateToggleButtonGadget(match_rowcol, Xdvi_MATCH_BOXED_STR, &one_of_many, 1);
XtManageChild(match_boxed);
XmToggleButtonGadgetSetState(match_inverted, resource.match_highlight_inverted, False);
XmToggleButtonGadgetSetState(match_boxed, !resource.match_highlight_inverted, False);
XtAddCallback(match_inverted, XmNvalueChangedCallback, match_cb, (XtPointer)info);
XtAddCallback(match_boxed, XmNvalueChangedCallback, match_cb, (XtPointer)info);
/* manage children (order shouldn't matter, since children are already managed, but ...) */
XtManageChild(gui_frame);
XtManageChild(tips_form);
XtManageChild(tips_frame);
#if 0
XtManageChild(tb_buttons_frame);
#endif
XtManageChild(match_frame);
XtManageChild(form);
return form;
}
Widget XmCreateLabelGadget_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateLabelGadget(parent, name, arglist, argcount);}
/*****************************************************************************
* Function: void _DtHelpBuildPathArea(Widget parent,
* DtHelpDialogWidget nw);
*
*
* Parameters: parent Specifies the widget ID of the help dialog you
* want to set the topic in.
* nw Specifies the current help dialog widget.
*
* Return Value: Void.
*
* Purpose: Creates/updates the Path Display area on top of the help
* dialog.
*
*****************************************************************************/
void _DtHelpBuildPathArea(
Widget parent,
DtHelpDialogWidget nw)
{
Arg args[20];
int n;
Widget pathForm, pathLabel, btnBox, tocFrame;
Widget _pathForm;
XmString labelString;
XmFontList defaultList;
DtHelpDialogWidget hw = (DtHelpDialogWidget) nw ;
Dimension button1, button2, button3, button4;
Dimension maxBtnWidth;
/* Create a form to hold the topic map stuff */
n = 0;
XtSetArg (args[n], XmNmarginWidth, 1); n++;
XtSetArg (args[n], XmNmarginHeight, 1); n++;
XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT); n++;
XtSetArg (args[n], XmNautoUnmanage, False); n++;
pathForm = XmCreateForm (parent, "pathForm", args, n);
n = 0;
XtSetArg (args[n], XmNmarginWidth, 1); n++;
XtSetArg (args[n], XmNmarginHeight, 1); n++;
XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT); n++;
XtSetArg (args[n], XmNautoUnmanage, False); n++;
_pathForm = XmCreateForm (pathForm, "_pathForm", args, n);
labelString = XmStringCreateLocalized(((char *)_DTGETMESSAGE
(9, 1,"Volume: ")));
n = 0;
XtSetArg (args[n], XmNlabelString, labelString); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNleftOffset, 0); n++;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNtopOffset, 0); n++;
XtSetArg (args[n], XmNtraversalOn, FALSE); n++;
pathLabel =
XmCreateLabelGadget (_pathForm, "pathLabel", args, n);
XtManageChild (pathLabel);
XmStringFree (labelString);
/* Create a label for our volume title. We fill it out later
* bacause at this point we may not have yet opened the volume.
*/
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNleftWidget, pathLabel); n++;
XtSetArg (args[n], XmNleftOffset, 1); n++;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNtopOffset, 0); n++;
XtSetArg (args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
hw->help_dialog.browser.volumeLabel =
XmCreateLabelGadget (_pathForm, "volumeLabel", args, n);
XtManageChild (hw->help_dialog.browser.volumeLabel);
/* Build a container for our toc to sit in. We do this because we cannot
* set form constraints on our toc, but can on the container.
*/
n = 0;
XtSetArg(args[n], XmNshadowThickness, 0); n++;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNleftOffset, 0); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNbottomOffset, 0); n++;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNtopOffset, 0); n++;
XtSetArg (args[n], XmNtopWidget, _pathForm);n++;
tocFrame = XmCreateFrame (pathForm, "tocFrame", args, n);
XtManageChild (tocFrame);
/* Build our button box rowcol widget container */
n = 0;
XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
XtSetArg (args[n], XmNleftOffset,3); n++;
XtSetArg (args[n], XmNleftWidget, tocFrame); n++;
XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNbottomOffset, 2); n++;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg (args[n], XmNtopOffset, 2); n++;
XtSetArg (args[n], XmNtopWidget, tocFrame); n++;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNrightOffset, 1); n++;
XtSetArg (args[n], XmNspacing, 5); n++;
XtSetArg (args[n], XmNentryVerticalAlignment, XmALIGNMENT_CENTER); n++;
XtSetArg (args[n], XmNpacking, XmPACK_COLUMN); n++;
XtSetArg (args[n], XmNorientation, XmVERTICAL); n++;
btnBox = XmCreateRowColumn (pathForm, "BtnBox", args, n);
XtManageChild (btnBox);
/* Backtrack button */
labelString = XmStringCreateLocalized(((char *)_DTGETMESSAGE(9, 2,"Backtrack")));
n = 0;
XtSetArg(args[n], XmNlabelString, labelString); n++;
hw->help_dialog.browser.btnBoxBackBtn = XmCreatePushButtonGadget(btnBox,
"btnBoxBackBtn", args, n);
XtManageChild (hw->help_dialog.browser.btnBoxBackBtn);
XmStringFree(labelString);
XtAddCallback(hw->help_dialog.browser.btnBoxBackBtn,XmNactivateCallback,
_DtHelpDisplayBackCB, (XtPointer) hw);
XtSetSensitive(hw->help_dialog.browser.btnBoxBackBtn, FALSE);
/* History Button */
labelString = XmStringCreateLocalized(((char *)_DTGETMESSAGE(9, 3,"History...")));
n = 0;
XtSetArg(args[n], XmNlabelString, labelString); n++;
hw->help_dialog.browser.btnBoxHistoryBtn = XmCreatePushButtonGadget(btnBox,
"btnBoxHistoryBtn",args, n);
XtManageChild (hw->help_dialog.browser.btnBoxHistoryBtn);
XmStringFree(labelString);
XtAddCallback(hw->help_dialog.browser.btnBoxHistoryBtn,XmNactivateCallback,
_DtHelpDisplayHistoryCB, (XtPointer) hw);
/* Index button */
labelString =
XmStringCreateLocalized(((char *)_DTGETMESSAGE(9, 4,"Index...")));
n = 0;
XtSetArg(args[n], XmNlabelString, labelString); n++;
hw->help_dialog.browser.btnBoxIndexBtn = XmCreatePushButtonGadget(btnBox,
"btnBoxIndexBtn",args, n);
XtManageChild (hw->help_dialog.browser.btnBoxIndexBtn);
XmStringFree(labelString);
XtAddCallback(hw->help_dialog.browser.btnBoxIndexBtn,XmNactivateCallback,
_DtHelpDisplayIndexCB, (XtPointer) hw);
/* Top Level Browser Button */
if (hw->help_dialog.browser.showTopLevelBtn == TRUE)
{
labelString =
XmStringCreateLocalized(((char *)_DTGETMESSAGE(9, 5,"Top Level")));
n = 0;
XtSetArg(args[n], XmNlabelString, labelString); n++;
hw->help_dialog.browser.btnBoxTopLevelBtn = XmCreatePushButtonGadget(btnBox,
"btnBoxTopLevelBtn",args, n);
XtManageChild (hw->help_dialog.browser.btnBoxTopLevelBtn);
XmStringFree(labelString);
XtAddCallback(hw->help_dialog.browser.btnBoxTopLevelBtn,XmNactivateCallback,
_DtHelpDisplayBrowserHomeCB, (XtPointer) hw);
}
/* Get our current fontlist value */
n = 0;
XtSetArg (args[n], XmNfontList, &(defaultList)); ++n;
XtGetValues (hw->help_dialog.menu.topBtn, args, n);
/* Build the Display Area */
hw->help_dialog.browser.pTocArea = _DtHelpCreateDisplayArea(tocFrame,
"TocArea",
((short) hw->help_dialog.display.scrollBarPolicy),
((short) hw->help_dialog.display.scrollBarPolicy),
True,
((int) hw->help_dialog.browser.visiblePathCount),
1,
_DtHelpDialogHypertextCB,
NULL /*ResizeHelpDialogCB*/,
_DtHelpFilterExecCmdCB,
(XtPointer) hw,
defaultList);
/* We build a blank toc at first, it gets filled in later when
* updatePathArea gets called.
*/
XtManageChild(_pathForm);
XtManageChild(pathForm);
/* Perform some sizing stuff here to ensure that we layout our UI
* per the current fonts.
*/
/* Get the size of each button */
n = 0;
XtSetArg(args[n], XmNwidth, &button1); ++n;
XtGetValues(hw->help_dialog.browser.btnBoxBackBtn, args, n);
n = 0;
XtSetArg(args[n], XmNwidth, &button2); ++n;
XtGetValues(hw->help_dialog.browser.btnBoxHistoryBtn, args, n);
n = 0;
XtSetArg(args[n], XmNwidth, &button3); ++n;
XtGetValues(hw->help_dialog.browser.btnBoxIndexBtn, args, n);
if (hw->help_dialog.browser.showTopLevelBtn == True)
{
n = 0;
XtSetArg(args[n], XmNwidth, &button4); ++n;
XtGetValues(hw->help_dialog.browser.btnBoxTopLevelBtn, args, n);
}
else
button4 = 0;
if (button1 >= button2)
maxBtnWidth = button1;
else
maxBtnWidth = button2;
if (button3 >= maxBtnWidth)
maxBtnWidth = button3;
if (hw->help_dialog.browser.showTopLevelBtn == True)
if (button4 >= maxBtnWidth)
maxBtnWidth = button4;
/* Set our toc right hand attachments */
n = 0;
XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg (args[n], XmNrightOffset, maxBtnWidth +10); n++;
XtSetValues (tocFrame, args, n);
}
XFE_PrefsDiskMoreDialog::XFE_PrefsDiskMoreDialog(XFE_PrefsDialog *prefsDialog,
Widget parent, // dialog parent
char *name, // dialog name
Boolean modal) // modal dialog?
: XFE_Dialog(parent,
name,
TRUE, // ok
TRUE, // cancel
FALSE, // help
FALSE, // apply
FALSE, // separator
modal // modal
),
m_prefsDialog(prefsDialog),
m_prefsDataDiskMore(0)
{
PrefsDataDiskMore *fep = NULL;
fep = new PrefsDataDiskMore;
memset(fep, 0, sizeof(PrefsDataDiskMore));
m_prefsDataDiskMore = fep;
Widget form;
Widget desc_label;
Widget rm_msg_body_toggle;
Widget num_days_text;
Widget days_label;
Widget kids[100];
Arg av[50];
int ac;
int i;
form = XtVaCreateWidget("form", xmFormWidgetClass, m_chrome,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XtManageChild (form);
ac = 0;
i = 0;
kids[i++] = desc_label =
XmCreateLabelGadget(form, "descLabel", av, ac);
kids[i++] = rm_msg_body_toggle =
XmCreateToggleButtonGadget (form, "rmMsgBodyToggle", av, ac);
kids[i++] = num_days_text =
fe_CreateTextField(form, "numDaysText", av, ac);
kids[i++] = days_label =
XmCreateLabelGadget(form, "daysLabel", av, ac);
XtVaSetValues(desc_label,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
int labels_height;
labels_height = XfeVaGetTallestWidget(rm_msg_body_toggle,
num_days_text,
days_label,
NULL);
XtVaSetValues(rm_msg_body_toggle,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, desc_label,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, desc_label,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(num_days_text,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, rm_msg_body_toggle,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, rm_msg_body_toggle,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(days_label,
XmNheight, labels_height,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, rm_msg_body_toggle,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, num_days_text,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
fep->rm_msg_body_toggle = rm_msg_body_toggle;
fep->num_days_text = num_days_text;
// Add callbacks
XtAddCallback(m_chrome, XmNokCallback, prefsDiskMoreCb_ok, this);
XtAddCallback(m_chrome, XmNcancelCallback, prefsDiskMoreCb_cancel, this);
XtManageChildren(kids, i);
}
void Find(Widget w, XtPointer client_data, XtPointer call_data)
{
Widget frm, pane, rc, b, list, opt;
XmString item;
int n, i;
Arg args[MAX_ARGS];
n=0;
XtSetArg(args[n], XmNallowShellResize, True); n++;
cbdata.top=XmCreateDialogShell(globl.parent, "findbox", args, n);
XtManageChild(cbdata.top);
n=0;
/* XtSetArg(args[n], XmNpacking, XmPACK_COLUMN); n++; */
frm=XmCreateRowColumn(cbdata.top, "container", args, n);
XtManageChild(frm);
n=0;
XtSetArg(args[n], XmNnumColumns, 2); n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
rc=XmCreateRowColumn(frm, "inputs", args, n);
XtManageChild(rc);
n=0;
XtManageChild(XmCreateLabelGadget(rc, "Find entries where", args, n));
n=0;
opt=XmCreatePulldownMenu(rc, "pane", args, n);
for(i=0; i<NFIELDS; i++)
{
n=0;
b=XmCreatePushButtonGadget(opt, dbrnames[i], args, n);
XtAddCallback(b, XmNactivateCallback, FindSetFrom, (XtPointer) i);
XtManageChild(b);
}
n=0;
XtSetArg(args[n], XmNsubMenuId, opt); n++;
list=XmCreateOptionMenu(rc, "fromMenu", args, n);
XtManageChild(list);
/* relation */
n=0;
opt=XmCreatePulldownMenu(rc, "pane", args, n);
for(i=0; relentries[i]!=NULL; i++)
{
n=0;
b=XmCreatePushButtonGadget(opt, relentries[i], args, n);
XtAddCallback(b, XmNactivateCallback, FindSetRelation, (XtPointer) i);
XtManageChild(b);
}
n=0;
XtSetArg(args[n], XmNsubMenuId, opt); n++;
list=XmCreateOptionMenu(rc, "relationMenu", args, n);
XtManageChild(list);
/* end of relation */
n=0;
cbdata.value=XmCreateTextField(rc, "findsel", args, n);
XtManageChild(cbdata.value);
n=0;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg(args[n], XmNnumColumns, 2); n++;
rc=XmCreateRowColumn(frm, "inputs", args, n);
XtManageChild(rc);
n=0;
b=XmCreatePushButtonGadget(rc, "Go", args, n);
XtAddCallback(b, XmNactivateCallback, FindCB, (XtPointer) &cbdata);
XtManageChild(b);
n=0;
b=XmCreatePushButtonGadget(rc, "Close", args, n);
XtAddCallback(b, XmNactivateCallback, CloseFindWindow, NULL);
XtManageChild(b);
}
