Widget
_DtTermViewCreateOptionMenu
(
Widget parent,
Widget submenu,
char *label,
KeySym mnemonic,
Arg al[],
int ac
)
{
Widget w;
XmString string;
if (label) {
string = XmStringCreateLocalized(label);
(void) XtSetArg(al[ac], XmNlabelString, string); ac++;
}
if (mnemonic != NoSymbol) {
(void) XtSetArg(al[ac], XmNmnemonic, mnemonic); ac++;
(void) XtSetArg(al[ac], XmNmnemonicCharSet, XmFONTLIST_DEFAULT_TAG);
ac++;
}
(void) XtSetArg(al[ac], XmNsubMenuId, submenu); ac++;
w = XmCreateOptionMenu(parent, label, al, ac);
(void) XtManageChild(w);
if (label) {
(void) XmStringFree(string);
}
return(w);
}
void Menu::CreateMenu(Widget parent, char *name, char * /*category*/,
char *mnemonic, MenuType menu_type)
{
XmString xm_string = StringCreate(name);
_title = NULL;
_sep = NULL;
switch (_menu_type = menu_type)
{
case PULLDOWN_MENU:
_w = XmCreatePulldownMenu(parent, "pulldown_menu", NULL, 0);
break;
case OPTION_MENU:
_w = XmCreateOptionMenu(parent, "option_menu", NULL, 0);
break;
case POPUP_MENU:
_w = XmCreatePopupMenu(parent, "popup_menu", NULL, 0);
XtVaSetValues(_w, XmNwhichButton, MotifUI::bMenuButton, NULL);
break;
}
if (_menu_type != POPUP_MENU)
{
_cascadeButton = XtVaCreateManagedWidget("cascadeButton",
xmCascadeButtonWidgetClass,
parent,
XmNlabelString, xm_string,
XmNsubMenuId, _w, NULL);
if (depth == 1)
{
Pixel bg;
XtVaGetValues(_cascadeButton, XmNbackground, &bg, NULL);
if (bg == white)
{
XtVaSetValues(_w, XmNuserData, (XtPointer)this, NULL);
XtAddCallback(_w, XmNmapCallback, &(Menu::MapCB), NULL);
XtAddCallback(_w, XmNunmapCallback, &(Menu::MapCB), NULL);
}
}
}
StringFree(xm_string);
if (mnemonic)
XtVaSetValues(_cascadeButton,
XmNmnemonic, XStringToKeysym(mnemonic), NULL);
InstallHelpCB();
}
int main(int argc, char *argv[])
{
int i, n;
Arg args[10];
XtAppContext app;
Widget toplevel;
Widget mymenu, optmenu;
WidgetList entries;
setlocale(LC_ALL, "");
//建立顶级窗口
toplevel = XtVaAppInitialize(&app, "Option", NULL, 0,
&argc, argv, NULL, NULL);
//建立选项菜单
mymenu = XmCreatePulldownMenu(toplevel, "文件", NULL, 0);
make_menu_item(mymenu, "硬盘", "Hard Disk");
make_menu_item(mymenu, "鼠标", "Mouse");
make_menu_item(mymenu, "键盘", "Keyboard");
make_menu_item(mymenu, "显示器", "Monitor");
n = 0;
XtSetArg(args[n], XmNsubMenuId, mymenu); n++;
optmenu = XmCreateOptionMenu(toplevel, "计算机: ", args, n);
XtManageChild(optmenu);
//设置为第三项
XtVaGetValues(mymenu,
XmNchildren, &entries,
NULL);
XtVaSetValues(mymenu,
XmNmenuHistory, entries[2],
NULL);
//显示窗口
XtRealizeWidget(toplevel);
//进入事件循环
XtAppMainLoop(app);
}
/* -------------------------------------------------------------------- */
static Widget CreateDropDownMenu(Widget parent, char menu_name[],
struct ccb_info menu_info[])
{
int i;
Widget PD, OM, buttons[16];
Cardinal n;
Arg args[4];
XmString name;
/* Pre-filter menu
*/
n = 0;
PD = XmCreatePulldownMenu(parent, "pullDown", args, n);
n = 0;
XtSetArg(args[n], XmNsubMenuId, PD); ++n;
OM = XmCreateOptionMenu(parent, menu_name, args, n);
XtManageChild(OM);
for (i = 0; menu_info[i].name; ++i)
{
name = XmStringCreateLocalized(menu_info[i].name);
n = 0;
XtSetArg(args[n], XmNlabelString, name); ++n;
buttons[i] = XmCreatePushButton(PD, "opMenB", args, n);
XtAddCallback(buttons[i], XmNactivateCallback, menu_info[i].callBack,
(XtPointer)menu_info[i].client);
XmStringFree(name);
}
XtManageChildren(buttons, i);
return(OM);
} /* END CREATEDROPDOWNMENU */
Widget GXCreateOptionMenu(Widget parent, char **entries)
{
Arg args[10];
XmString *buttonArray;
char **cptr;
int cnt,i,n;
Widget opt,pulldown;
cptr=entries;
cnt=0;
do {
cnt++;
cptr++;
} while (*cptr);
if (!(buttonArray=(XmString*)malloc(cnt*sizeof(XmString)))) {
return NULL;
}
/* create the menu */
for (i=0;i<cnt;i++)
buttonArray[i]=XmStringCreateSimple(entries[i]);
n=0;
XtSetArg(args[n], XmNbuttonCount, cnt); n++;
XtSetArg(args[n], XmNbuttons, buttonArray); n++;
pulldown = XmCreateSimplePulldownMenu(parent,"OptionMenuPulldown",args,n);
for (i=0;i<cnt;i++)
XmStringFree(buttonArray[i]);
free(buttonArray);
n=0;
XtSetArg(args[n], XmNsubMenuId, pulldown); n++;
opt=XmCreateOptionMenu(parent,"OptionMenu",args,n);
XtManageChild(opt);
return opt;
}
static Widget
CreateAccountDialog (Widget W)
{
Widget AccountDialog;
Widget Type;
Widget PB;
char **type;
AccountDialog = XmCreateMessageBox (W, "AccountDialog", NULL, 0);
Pulldown = XmCreatePulldownMenu (AccountDialog, "Pulldown", NULL, 0);
type = AccountTypes;
while (*type != NULL)
{
PB = XmCreatePushButton (Pulldown, *type, NULL, 0);
XtManageChild (PB);
type++;
}
Type = XmCreateOptionMenu (AccountDialog, "Type", NULL, 0);
XtVaSetValues (Type,
XmNsubMenuId, Pulldown,
NULL);
XtManageChild (Type);
PB = XmCreatePushButton (AccountDialog, "Apply", NULL, 0);
XtVaSetValues (AccountDialog,
#if 1
/* add this and you get the cache problem??? */
XmNdefaultButton, PB,
#endif
NULL);
XtManageChild (PB);
XtAddCallback(PB, XmNactivateCallback, (XtCallbackProc)ChangeLabels, NULL);
return (AccountDialog);
}
////////////////////////////////////////////////////////////////////////
//
// Description:
// This creates the tracking rate preference sheet stuff.
//
// Use: protected
Widget
InvFullViewer::createTrackingPrefSheetGuts(Widget parent)
//
////////////////////////////////////////////////////////////////////////
{
Widget label, thumb, text, device, devicem, devices[6];
Arg args[12];
XmString string;
int n;
// create a form to hold everything together
Widget form = XtCreateWidget("", xmFormWidgetClass,
parent, NULL, 0);
// create device choice
devicem = XmCreatePulldownMenu(form, (char *)"trackingmenu", NULL, 0);
devices[0] = XmCreatePushButtonGadget(devicem, (char *)"Logitec on com1", NULL, 0);
devices[1] = XmCreatePushButtonGadget(devicem, (char *)"Logitec on com2", NULL, 0);
devices[2] = XmCreatePushButtonGadget(devicem, (char *)"Fastrak on com1", NULL, 0);
devices[3] = XmCreatePushButtonGadget(devicem, (char *)"Fastrak on com2", NULL, 0);
devices[4] = XmCreatePushButtonGadget(devicem, (char *)"Fastrak on com3", NULL, 0);
devices[5] = XmCreatePushButtonGadget(devicem, (char *)"Fastrak on com4", NULL, 0);
XtAddCallback(devices[0], XmNactivateCallback,
(XtCallbackProc)InvFullViewer::trackingDevice1CB, (XtPointer) this);
XtAddCallback(devices[1], XmNactivateCallback,
(XtCallbackProc)InvFullViewer::trackingDevice2CB, (XtPointer) this);
XtAddCallback(devices[2], XmNactivateCallback,
(XtCallbackProc)InvFullViewer::trackingDevice3CB, (XtPointer) this);
XtAddCallback(devices[3], XmNactivateCallback,
(XtCallbackProc)InvFullViewer::trackingDevice4CB, (XtPointer) this);
XtAddCallback(devices[4], XmNactivateCallback,
(XtCallbackProc)InvFullViewer::trackingDevice5CB, (XtPointer) this);
XtAddCallback(devices[5], XmNactivateCallback,
(XtCallbackProc)InvFullViewer::trackingDevice6CB, (XtPointer) this);
XtManageChildren(devices, 6);
string = XmStringCreate((char *)"xxTrackingdevices:", (XmStringCharSet)XmSTRING_DEFAULT_CHARSET);
n = 0;
XtSetArg(args[n], XmNlabelString, string);
n++;
XtSetArg(args[n], XmNsubMenuId, devicem);
n++;
device = XmCreateOptionMenu(form, (char *)"trackingoption", args, n);
// create the label
label = XtCreateWidget("Tracking rate:", xmLabelGadgetClass,
form, NULL, 0);
// allocate the thumbwheel
n = 0;
XtSetArg(args[n], XmNvalue, 110);
n++;
XtSetArg(args[n], SgNangleRange, 720);
n++;
XtSetArg(args[n], XmNmaximum, 1010);
n++;
XtSetArg(args[n], XmNminimum, 10);
n++;
// XtSetArg(args[n], SgNunitsPerRotation, 1000); n++;
XtSetArg(args[n], SgNshowHomeButton, FALSE);
n++;
XtSetArg(args[n], XmNhighlightThickness, 0);
n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL);
n++;
trackingWheel = thumb = SgCreateThumbWheel(form, (char *)"", args, n);
XtAddCallback(thumb, XmNvalueChangedCallback,
(XtCallbackProc)InvFullViewer::trackingWheelCB, (XtPointer) this);
// XtAddCallback(thumb, XmNdragCallback,
// (XtCallbackProc) InvFullViewer::trackingWheelCB, (XtPointer) this);
// allocate the text field
n = 0;
char str[15];
sprintf(str, "%.6f", trackingWheelVal);
XtSetArg(args[n], XmNvalue, str);
n++;
XtSetArg(args[n], XmNhighlightThickness, 1);
n++;
XtSetArg(args[n], XmNcolumns, 8);
n++;
trackingField = text = XtCreateWidget("", xmTextWidgetClass,
form, args, n);
XtAddCallback(text, XmNactivateCallback,
(XtCallbackProc)InvFullViewer::trackingFieldCB,
(XtPointer) this);
// layout
n = 0;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);
n++;
XtSetValues(text, args, n);
n = 0;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);
n++;
XtSetArg(args[n], XmNbottomWidget, text);
n++;
XtSetArg(args[n], XmNbottomOffset, 3);
n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET);
n++;
XtSetArg(args[n], XmNrightWidget, text);
n++;
XtSetArg(args[n], XmNrightOffset, 3);
n++;
XtSetValues(thumb, args, n);
n = 0;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);
n++;
XtSetArg(args[n], XmNbottomWidget, thumb);
n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET);
n++;
XtSetArg(args[n], XmNrightWidget, thumb);
n++;
XtSetArg(args[n], XmNrightOffset, 5);
n++;
XtSetValues(label, args, n);
n = 0;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);
n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);
n++;
XtSetArg(args[n], XmNtopWidget, thumb);
n++;
XtSetArg(args[n], XmNtopOffset, 3);
n++;
XtSetValues(device, args, n);
// manage children
XtManageChild(text);
XtManageChild(thumb);
XtManageChild(label);
XtManageChild(device);
return form;
}
Widget
XmCreateSimpleOptionMenu(
Widget parent,
String name,
ArgList args,
Cardinal arg_count )
{
Widget rc, sub_rc;
XmSimpleMenuRec mr;
int n, i, button_count;
Arg local_args[5];
WidgetList buttons;
Cardinal num_buttons;
_XmWidgetToAppContext(parent);
_XmAppLock(app);
XtGetSubresources(parent, &mr, name, XmCSimpleOptionMenu,
SimpleMenuResources, XtNumber(SimpleMenuResources),
args, arg_count);
rc = XmCreateOptionMenu(parent, name, args, arg_count);
sub_rc = XmCreatePulldownMenu(parent, name, args, arg_count);
EvaluateConvenienceStructure(sub_rc, &mr);
n = 0;
if (mr.option_label)
{
XtSetArg(local_args[n], XmNlabelString, mr.option_label); n++;
}
if (mr.option_mnemonic)
{
XtSetArg(local_args[n], XmNmnemonic, mr.option_mnemonic); n++;
}
XtSetArg(local_args[n], XmNsubMenuId, sub_rc); n++;
XtSetValues(rc, local_args, n);
if (mr.button_set >= 0)
{
n = 0;
XtSetArg(local_args[n], XtNchildren, &buttons); n++;
XtSetArg(local_args[n], XtNnumChildren, &num_buttons); n++;
XtGetValues(sub_rc, local_args, n);
if (!num_buttons)
{
/* error condition */
_XmAppUnlock(app);
return(rc);
}
else
{
button_count = 0;
for (i = 0; i < num_buttons; i++)
{ /* count only PushB */
if ((XmIsPushButtonGadget(buttons[i])) ||
(XmIsPushButton(buttons[i])))
{
if (button_count == mr.button_set)
break;
button_count++;
}
}
if ( i < num_buttons)
{
n = 0;
XtSetArg(local_args[n], XmNmenuHistory, buttons[i]); n++;
XtSetValues(rc, local_args, n);
}
}
}
_XmAppUnlock(app);
return(rc);
}
void
create_appShell (Display *display, char *app_name, int app_argc, char **app_argv)
{
Widget children[12]; /* Children to manage */
Arg al[64]; /* Arg List */
register int ac = 0; /* Arg Count */
char from_s [256]; /* For font list conversion */
XrmValue from_value, to_value; /* ditto */
int fg, bg; /* colour values for pixmaps */
XmString *list_items; /* For list items */
int list_item; /* Index for list_items */
XmString xmstrings[15]; /* temporary storage for XmStrings */
Widget widget1 = (Widget)NULL;
Widget widget2 = (Widget)NULL;
Widget widget3 = (Widget)NULL;
Widget widget7 = (Widget)NULL;
Widget widget8 = (Widget)NULL;
Widget widget9 = (Widget)NULL;
Widget widget10 = (Widget)NULL;
Widget widget11 = (Widget)NULL;
Widget widget12 = (Widget)NULL;
Widget generateButton = (Widget)NULL;
Widget deleteButton = (Widget)NULL;
Widget browseButton = (Widget)NULL;
Widget widget13 = (Widget)NULL;
Widget widget14 = (Widget)NULL;
Widget widget15 = (Widget)NULL;
Widget widget16 = (Widget)NULL;
Widget widget17 = (Widget)NULL;
Widget nameLabel = (Widget)NULL;
Widget textLabel = (Widget)NULL;
Widget severityLabel = (Widget)NULL;
Widget widget25 = (Widget)NULL;
Widget widget27 = (Widget)NULL;
Widget widget28 = (Widget)NULL;
Widget widget29 = (Widget)NULL;
Widget widget30 = (Widget)NULL;
Widget widget31 = (Widget)NULL;
Widget widget32 = (Widget)NULL;
Widget widget33 = (Widget)NULL;
Widget moduleLabel = (Widget)NULL;
Widget widget37 = (Widget)NULL;
Widget *modbutton; /* replaces 38-49 */
Widget categoryLabel = (Widget)NULL;
Widget descriptionLabel = (Widget)NULL;
Widget toolMenu = (Widget)NULL;
Widget toolCascade = (Widget)NULL;
Widget lockMenu = (Widget)NULL;
Widget lockCascade = (Widget)NULL;
Widget unlockButton = (Widget)NULL;
Widget lockButton = (Widget)NULL;
int imod;
XtSetArg(al[ac], XmNallowShellResize, TRUE); ac++;
XtSetArg(al[ac], XmNargc, app_argc); ac++;
XtSetArg(al[ac], XmNargv, app_argv); ac++;
appShell = XtAppCreateShell ( app_name, "EditMessage", applicationShellWidgetClass, display, al, ac );
ac = 0;
XtSetArg(al[ac], XmNscrollingPolicy, XmAUTOMATIC); ac++;
widget1 = XmCreateMainWindow ( appShell, "mainWindow", al, ac );
ac = 0;
XtSetArg(al[ac], XmNhorizontalScrollBar, &widget2 ); ac++;
XtSetArg(al[ac], XmNverticalScrollBar, &widget3 ); ac++;
XtGetValues(widget1, al, ac );
ac = 0;
widget7 = XmCreateMenuBar ( widget1, "widget7", al, ac );
widget9 = XmCreatePulldownMenu ( widget7, "fileMenu", al, ac );
/*
XtAddCallback(widget9, XmNunmapCallback, grab_input, NULL);
*/
widget10 = XmCreatePushButton ( widget9, "openButton", al, ac );
widget11 = XmCreatePushButton ( widget9, "newButton", al, ac );
ac = 0; XtSetArg(al[ac], XmNsensitive, False); ac++;
widget12 = XmCreatePushButton ( widget9, "saveButton", al, ac );
ac = 0; XtSetArg(al[ac], XmNsensitive, False); ac++;
deleteButton = XmCreatePushButton ( widget9, "deleteButton", al, ac );
ac = 0;
widget13 = XmCreateSeparator ( widget9, "widget13", al, ac );
widget14 = XmCreatePushButton ( widget9, "exitButton", al, ac );
XtSetArg(al[ac], XmNsubMenuId, widget9); ac++;
widget8 = XmCreateCascadeButton ( widget7, "fileCascade", al, ac );
ac = 0;
toolMenu = XmCreatePulldownMenu ( widget7, "toolMenu", al, ac );
/*
XtAddCallback(toolMenu, XmNunmapCallback, grab_input, NULL);
*/
generateButton = XmCreatePushButton ( toolMenu, "generateButton", al, ac );
browseButton = XmCreatePushButton ( toolMenu, "browseButton", al, ac );
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, toolMenu); ac++;
toolCascade = XmCreateCascadeButton ( widget7, "toolCascade", al, ac );
lockMenu = XmCreatePulldownMenu ( widget7, "lockMenu", al, ac );
/*
XtAddCallback(widget9, XmNunmapCallback, grab_input, NULL);
*/
lockButton = XmCreatePushButton ( lockMenu, "lockButton", al, ac );
ac = 0; XtSetArg(al[ac], XmNsensitive, False); ac++;
unlockButton = XmCreatePushButton ( lockMenu, "unlockButton", al, ac );
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, lockMenu); ac++;
lockCascade = XmCreateCascadeButton ( widget7, "lockCascade", al, ac );
ac = 0;
widget16 = XmCreatePulldownMenu ( widget7, "widget16", al, ac );
/*
XtAddCallback(widget16, XmNunmapCallback, grab_input, NULL);
*/
XtSetArg(al[ac], XmNsubMenuId, widget16); ac++;
widget15 = XmCreateCascadeButton ( widget7, "helpCascade", al, ac );
/* Hand-added */
XtVaSetValues(widget7, XmNmenuHelpWidget, widget15, NULL);
ac = 0;
widget17 = XmCreateForm ( widget1, "editMsgForm", al, ac );
XtSetArg(al[ac], XmNwidth, 100); ac++;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
nameLabel = XmCreateLabel ( widget17, "nameLabel", al, ac );
ac = 0;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
textLabel = XmCreateLabel ( widget17, "textLabel", al, ac );
ac = 0;
XtSetArg(al[ac], XmNmaxLength, 20); ac++;
nameTextField = XmCreateTextField( widget17, "nameTextField", al, ac );
XtAddCallback(nameTextField, XmNvalueChangedCallback, message_modified,
NULL);
ac = 0;
XtSetArg(al[ac], XmNmaxLength, 50); ac++;
msgTextField = XmCreateTextField ( widget17, "msgTextField", al, ac );
XtAddCallback(msgTextField, XmNvalueChangedCallback, message_modified,
NULL);
ac = 0;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
severityLabel = XmCreateLabel ( widget17, "severityLabel", al, ac );
ac = 0;
severityMenu = XmCreatePulldownMenu ( widget17, "severityPulldown", al, ac );
/*
XtAddCallback(severityMenu, XmNunmapCallback, grab_input, NULL);
*/
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_DEBUG);
widget27 = XmCreatePushButton ( severityMenu, "debugButton", al, 1);
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_INFORM);
widget28 = XmCreatePushButton ( severityMenu, "informButton", al, 1 );
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_WARN);
widget29 = XmCreatePushButton ( severityMenu, "warnButton", al, 1 );
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_ERROR);
widget30 = XmCreatePushButton ( severityMenu, "errorButton", al, 1 );
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_ALARM);
widget31 = XmCreatePushButton ( severityMenu, "alarmButton", al, 1 );
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_FATAL);
widget32 = XmCreatePushButton ( severityMenu, "fatalButton", al, 1 );
ac = 0;
XtSetArg(al[ac], XmNuserData, (caddr_t)SEV_UNKNOWN); ac++;
/* "Unknown" is only allowed if it is found in the DB */
XtSetArg(al[ac], XmNsensitive, FALSE); ac++;
widget33 = XmCreatePushButton (severityMenu, "unknownButton", al, ac );
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, severityMenu); ac++;
severityOptionMenu = XmCreateOptionMenu ( widget17, "severityOptionMenu", al, ac );
ac = 0;
widget25 = XmOptionButtonGadget ( severityOptionMenu );
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
moduleLabel = XmCreateLabel ( widget17, "moduleLabel", al, ac );
ac = 0;
moduleMenu = XmCreatePulldownMenu ( widget17, "moduleMenu", al, ac );
/*
XtAddCallback(moduleMenu, XmNunmapCallback, grab_input, NULL);
*/
/* Create the button for the chosen module as the default.
*/
if (strcmp(module_names[0], g_module)) {
for (imod=0; imod<nmodule_names; imod++)
if (!strcmp(module_names[imod], g_module)) break;
strcpy(module_names[imod], module_names[0]);
strcpy(module_names[0], g_module);
}
modbutton = (Widget *)XtMalloc(nmodule_names * sizeof(Widget));
for (imod = 0; imod < nmodule_names; imod++) {
XtSetArg(al[0], XmNuserData, module_names[imod]);
modbutton[imod] = XmCreatePushButton(moduleMenu, module_names[imod],
al, 1 );
}
XtSetArg(al[ac], XmNsubMenuId, moduleMenu); ac++;
moduleOptionMenu = XmCreateOptionMenu ( widget17, "moduleOptionMenu", al, ac );
ac = 0;
widget37 = XmOptionButtonGadget ( moduleOptionMenu );
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
categoryLabel = XmCreateLabel ( widget17, "categoryLabel", al, ac );
ac = 0;
categoryTextField = XmCreateTextField ( widget17, "categoryTextField", al, ac );
XtAddCallback(categoryTextField, XmNvalueChangedCallback,
message_modified, NULL);
XtSetArg(al[ac], XmNwidth, 101); ac++;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
descriptionLabel = XmCreateLabel ( widget17, "descriptionLabel", al, ac );
ac = 0;
XtSetArg(al[ac], XmNmaxLength, 255); ac++;
descriptionText = XmCreateText ( widget17, "descriptionText", al, ac );
XtAddCallback(descriptionText, XmNvalueChangedCallback,
message_modified, NULL);
ac = 0;
children[ac++] = widget10;
children[ac++] = widget11;
children[ac++] = widget12;
children[ac++] = deleteButton;
children[ac++] = widget13;
children[ac++] = widget14;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = generateButton;
children[ac++] = browseButton;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = unlockButton;
children[ac++] = lockButton;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = widget8;
children[ac++] = widget15;
children[ac++] = toolCascade;
children[ac++] = lockCascade;
XtManageChildren(children, ac);
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, nameTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, nameTextField); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, nameTextField); ac++;
XtSetValues ( nameLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, msgTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, msgTextField); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, msgTextField); ac++;
XtSetValues ( textLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetValues ( nameTextField,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, nameTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, nameTextField); ac++;
XtSetValues ( msgTextField,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, severityOptionMenu); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, severityOptionMenu); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, severityOptionMenu); ac++;
XtSetValues ( severityLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, msgTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, msgTextField); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetValues ( severityOptionMenu,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, moduleOptionMenu); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, moduleOptionMenu); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, moduleOptionMenu); ac++;
XtSetValues ( moduleLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, severityOptionMenu); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, severityOptionMenu); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetValues ( moduleOptionMenu,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, categoryTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, categoryTextField); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, categoryTextField); ac++;
XtSetValues ( categoryLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, moduleOptionMenu); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, moduleOptionMenu); ac++;
XtSetValues ( categoryTextField,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, descriptionText); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, descriptionText); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, descriptionText); ac++;
XtSetValues ( descriptionLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, categoryTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, categoryTextField); ac++;
XtSetValues ( descriptionText,al, ac );
XtAddCallback(widget10, XmNactivateCallback, open_message, NULL);
XtAddCallback(browseButton, XmNactivateCallback, browse_messages,
g_module);
XtAddCallback(widget11, XmNactivateCallback, new_message, NULL);
XtAddCallback(widget12, XmNactivateCallback, save_message, NULL);
XtAddCallback(deleteButton, XmNactivateCallback, delete_message, NULL);
XtAddCallback(generateButton, XmNactivateCallback, generate_header, NULL);
XtAddCallback(lockButton, XmNactivateCallback, set_lock, widget9);
XtAddCallback(unlockButton, XmNactivateCallback, unset_lock, widget9);
XtAddCallback(widget14, XmNactivateCallback, exit_app, NULL);
XtAddCallback(widget27, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget28, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget29, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget30, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget31, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget32, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget33, XmNactivateCallback, set_severity, NULL);
for (imod = 0; imod < nmodule_names; imod++)
XtAddCallback(modbutton[imod], XmNactivateCallback, set_module,
NULL);
ac = 0;
children[ac++] = widget27;
children[ac++] = widget28;
children[ac++] = widget29;
children[ac++] = widget30;
children[ac++] = widget31;
children[ac++] = widget32;
children[ac++] = widget33;
XtManageChildren(children, ac);
XtManageChildren(modbutton, nmodule_names);
ac = 0;
children[ac++] = nameLabel;
children[ac++] = textLabel;
children[ac++] = nameTextField;
children[ac++] = msgTextField;
children[ac++] = severityLabel;
children[ac++] = severityOptionMenu;
children[ac++] = moduleLabel;
children[ac++] = moduleOptionMenu;
children[ac++] = categoryLabel;
children[ac++] = categoryTextField;
children[ac++] = descriptionLabel;
children[ac++] = descriptionText;
XtManageChildren(children, ac);
ac = 0;
XtManageChild ( widget7 );
XtManageChild ( widget17 );
XmMainWindowSetAreas(widget1, widget7, (Widget) NULL, widget2, widget3, widget17 );
XtManageChild ( widget1);
}
static void pgcycle_createPanel1 ( void )
/************************************************************************
* pgcycle_createPanel1 *
* *
* This function creates the day and cycle selection menus and sets the *
* initial (default) values for the _curDay and _curCycle. *
* *
* void pgcycle_createPanel1( void ) *
* *
* Input parameters: *
* Output parameters: *
* none *
** *
* Log: *
* E. Safford/SAIC 07/07 initial coding *
***********************************************************************/
{
int tmType, ier, tmArray[ 5 ], isDst, strLen;
int nearest, minDiff, intCycle, minCycle, minCycleIndex;
long ii;
char **cycles;
char dayStr[ 3 ], dattim[ 20 ];
time_t tt;
struct tm *tStruct;
XmString labelStr, nrml, other;
Widget issueForm;
/*---------------------------------------------------------------------*/
_form1 = XtVaCreateManagedWidget( "form1",
xmFormWidgetClass, _cycleForm,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL );
/*
* Create 'Day' pulldown menu
*/
_dayMenu = XmCreateOptionMenu ( _form1, "day", NULL, 0);
_dayPdMenu = XmCreatePulldownMenu ( _form1, "daypd", NULL, 0);
_dayButtons = (WidgetList)XtMalloc ( NUM_DAYS * sizeof( Widget ) );
for ( ii = 0; ii < NUM_DAYS; ii++ ) {
sprintf ( dayStr, "%02d", (int)ii + 1 );
_dayButtons[ ii ] = XtVaCreateManagedWidget ( dayStr,
xmPushButtonWidgetClass, _dayPdMenu,
NULL );
}
labelStr = XmStringCreateLocalized ( "Day:" );
tt = time ( NULL );
tStruct = localtime ( &tt );
XtVaSetValues ( _dayMenu,
XmNsubMenuId, _dayPdMenu,
XmNmenuHistory, _dayButtons[ tStruct->tm_mday - 1 ],
XmNlabelString, labelStr,
XmNspacing, 10,
XmNx, 0,
XmNy, 30,
NULL );
XtManageChild ( _dayMenu );
XmStringFree ( labelStr );
/*
* Set the default day
*/
sprintf( _curDay, "%d", tStruct->tm_mday );
/*
* Read the cycle times from the airmet table
*/
tmType = 0;
css_gtim ( &tmType, dattim, &ier );
ti_ctoi ( dattim, tmArray, &ier, strlen ( dattim ) );
ti_dst ( tmArray, &isDst, &ier );
ctb_airmetGetCycleTms( (isDst != 0), &_nCycles, &cycles, &ier );
if ( ier < 0 ) {
_nCycles = 1;
strLen = 3;
G_MALLOC ( cycles, char *, _nCycles, "airmet cycle menu" );
G_MALLOC ( cycles[ 0 ], char, strLen, "airmet cycle menu" );
strcpy ( cycles[ 0 ], "03" );
}
void
color_init(struct ida_image *img)
{
Widget menu,push,rc;
struct ida_coledit *me;
Arg args[2];
me = malloc(sizeof(*me));
memset(me,0,sizeof(*me));
color_calchist(img,me);
/* dialog shell */
me->dlg = XmCreatePromptDialog(app_shell,"color",NULL,0);
XmdRegisterEditres(XtParent(me->dlg));
XtUnmanageChild(XmSelectionBoxGetChild(me->dlg,XmDIALOG_SELECTION_LABEL));
XtUnmanageChild(XmSelectionBoxGetChild(me->dlg,XmDIALOG_HELP_BUTTON));
XtUnmanageChild(XmSelectionBoxGetChild(me->dlg,XmDIALOG_TEXT));
me->form = XtVaCreateManagedWidget("form",xmFormWidgetClass,
me->dlg,NULL);
XtAddCallback(XtParent(me->dlg),XmNdestroyCallback,color_destroy,me);
XtAddCallback(me->dlg,XmNokCallback,color_button_cb,me);
XtAddCallback(me->dlg,XmNcancelCallback,color_button_cb,me);
/* histograms */
XtVaCreateManagedWidget("hist",xmLabelWidgetClass,
me->form,NULL);
color_createhist(me->form,"red", x11_red, &me->red);
color_createhist(me->form,"green",x11_green,&me->green);
color_createhist(me->form,"blue", x11_blue, &me->blue);
me->red.up = me;
me->green.up = me;
me->blue.up = me;
XtVaCreateManagedWidget("map",xmLabelWidgetClass,
me->form,NULL);
/* control */
me->toggle = XtVaCreateManagedWidget("lock",xmToggleButtonWidgetClass,
me->form,NULL);
XtAddCallback(me->toggle,XmNvalueChangedCallback,color_lock,me);
menu = XmCreatePulldownMenu(me->form,"valsM",NULL,0);
XtSetArg(args[0],XmNsubMenuId,menu);
me->vals = XmCreateOptionMenu(me->form,"vals",args,1);
XtManageChild(me->vals);
push = XtVaCreateManagedWidget("red",xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(push,XmNactivateCallback,color_vals,&me->red);
push = XtVaCreateManagedWidget("green",xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(push,XmNactivateCallback,color_vals,&me->green);
push = XtVaCreateManagedWidget("blue",xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(push,XmNactivateCallback,color_vals,&me->blue);
/* in range */
rc = XtVaCreateManagedWidget("in",xmRowColumnWidgetClass,me->form,NULL);
XtVaCreateManagedWidget("label",xmLabelWidgetClass,rc,NULL);
me->l = XtVaCreateManagedWidget("left",xmTextWidgetClass,rc,NULL);
XtAddCallback(me->l,XmNvalueChangedCallback,color_text,me);
me->r = XtVaCreateManagedWidget("right",xmTextWidgetClass,rc,NULL);
XtAddCallback(me->r,XmNvalueChangedCallback,color_text,me);
/* out range */
rc = XtVaCreateManagedWidget("out",xmRowColumnWidgetClass,me->form,NULL);
XtVaCreateManagedWidget("label",xmLabelWidgetClass,rc,NULL);
me->b = XtVaCreateManagedWidget("bottom",xmTextWidgetClass,rc,NULL);
XtAddCallback(me->b,XmNvalueChangedCallback,color_text,me);
me->t = XtVaCreateManagedWidget("top",xmTextWidgetClass,rc,NULL);
XtAddCallback(me->t,XmNvalueChangedCallback,color_text,me);
/* gamma */
rc = XtVaCreateManagedWidget("gamma",xmRowColumnWidgetClass,me->form,NULL);
XtVaCreateManagedWidget("label",xmLabelWidgetClass,rc,NULL);
me->g = XtVaCreateManagedWidget("gamma",xmTextWidgetClass,rc,NULL);
XtAddCallback(me->g,XmNvalueChangedCallback,color_text,me);
/* testing stuff */
rc = XtVaCreateManagedWidget("pick",xmRowColumnWidgetClass,me->form,NULL);
push = XtVaCreateManagedWidget("white",xmPushButtonWidgetClass,rc,NULL);
XtAddCallback(push,XmNactivateCallback,color_pick,me);
XtManageChild(me->dlg);
me->cur = &me->red;
color_update(me,me->cur,2);
XmToggleButtonSetState(me->toggle,True,True);
}
Widget
CreateConstraintResourceControls( Widget parent, Widget left_widget,
Widget bottom_widget,
unsigned int child_type )
{
XmString string;
Widget RowColumn;
Widget ArrowSensLabel, ArrowSensPulldown, ArrowSensOptions,
ArrowSensPB[NUM_ARROW_SENS_BTNS];
Widget DecimalPtsLabel, DecimalPtsTF;
Widget IncrValueLabel, IncrValueTF;
Widget MaxValueLabel, MaxValueTF;
Widget MinValueLabel, MinValueTF;
Widget NumValuesLabel, NumValuesTF;
Widget PositionLabel;
Widget ChildTypeLabel, ChildTypePulldown, ChildTypeOptions,
ChildTypePB[NUM_CHILD_TYPE_BTNS];
Widget ValuesLabel, ValuesList;
char buffer[30], buffer2[30];
Widget client_widget;
int i, j;
XmStringTable stringTable;
client_widget = ( child_type == XmSTRING ) ? StringTextF :
NumericTextF;
n = 0;
XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
XtSetArg( args[n], XmNleftWidget, left_widget ); n++;
XtSetArg( args[n], XmNbottomAttachment, XmATTACH_WIDGET ); n++;
XtSetArg( args[n], XmNbottomWidget, bottom_widget ); n++;
XtSetArg(args[n], XmNnumColumns, 9); n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg(args[n], XmNpacking, XmPACK_COLUMN); n++;
RowColumn = XmCreateRowColumn( parent, "RowColumn", args, n );
XtManageChild( RowColumn );
/*
* Create label and option menu for XmNarrowSensitivity resource.
*/
string = XmStringCreateLtoR("Arrow Sensitivity",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ArrowSensLabel = XmCreateLabel( RowColumn, "ArrowSensLabel",
args, n );
XtManageChild( ArrowSensLabel );
XmStringFree( string );
n = 0;
ArrowSensPulldown = XmCreatePulldownMenu(RowColumn,
"ArrowSensPulldown",
args, n);
for ( i = 0; i < NUM_ARROW_SENS_BTNS; i++ )
{
string = XmStringCreateLtoR( arrow_sens_strings[i],
XmFONTLIST_DEFAULT_TAG );
if ( child_type == XmSTRING )
sprintf( buffer, "StringArrowSensPB%d", i );
else if ( child_type == XmNUMERIC )
sprintf( buffer, "NumericArrowSensPB%d", i );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ArrowSensPB[i] =
XmCreatePushButton( ArrowSensPulldown, buffer, args, n );
XmStringFree( string );
if ( child_type == XmSTRING )
{
string_arrow_sens_cd[i].textfield = client_widget;
string_arrow_sens_cd[i].sensitivity = arrow_sens[i];
XtAddCallback( ArrowSensPB[i], XmNactivateCallback,
ArrowSensCB, &string_arrow_sens_cd[i]);
}
else if ( child_type = XmNUMERIC )
{
numeric_arrow_sens_cd[i].textfield = client_widget;
numeric_arrow_sens_cd[i].sensitivity = arrow_sens[i];
XtAddCallback( ArrowSensPB[i], XmNactivateCallback,
ArrowSensCB, &numeric_arrow_sens_cd[i]);
}
}
XtManageChildren( ArrowSensPB, NUM_ARROW_SENS_BTNS );
if ( child_type == XmSTRING )
sprintf( buffer, "StringArrowSensOptions", i );
else if ( child_type == XmNUMERIC )
sprintf( buffer, "NumericArrowSensOptions", i );
n = 0;
XtSetArg( args[n], XmNmenuHistory,
ArrowSensPB[NUM_ARROW_SENS_BTNS - 1] ); n++;
XtSetArg( args[n], XmNsubMenuId, ArrowSensPulldown ); n++;
ArrowSensOptions =
XmCreateOptionMenu( RowColumn, buffer, args, n );
XtManageChild( ArrowSensOptions );
string = XmStringCreateLtoR("Decimal Points",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
DecimalPtsLabel =
XmCreateLabel( RowColumn, "DecimalPtsLabel", args, n );
XtManageChild( DecimalPtsLabel );
XmStringFree( string );
n = 0;
XtSetArg( args[n], XmNvalue, "0" ); n++;
if ( child_type == XmSTRING )
sprintf( buffer, "%s", "StringDecimalPtsTF" );
else if ( child_type == XmNUMERIC )
sprintf( buffer, "%s", "NumericDecimalPtsTF" );
DecimalPtsTF =
XmCreateTextField( RowColumn, buffer, args, n );
XtManageChild( DecimalPtsTF );
XtAddCallback( DecimalPtsTF, XmNactivateCallback,
DecimalPtsCB, (XtPointer)client_widget );
string = XmStringCreateLtoR("Increment Value",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
IncrValueLabel =
XmCreateLabel( RowColumn, "IncrValueLabel", args, n );
XtManageChild( IncrValueLabel );
XmStringFree( string );
n = 0;
XtSetArg( args[n], XmNvalue, "1" ); n++;
if ( child_type == XmSTRING )
sprintf( buffer, "%s", "StringIncrValueTF" );
else if ( child_type == XmNUMERIC )
sprintf( buffer, "%s", "NumericIncrValueTF" );
IncrValueTF =
XmCreateTextField( RowColumn, buffer, args, n );
XtManageChild( IncrValueTF );
XtAddCallback( IncrValueTF, XmNactivateCallback,
IncrValueCB, (XtPointer)client_widget );
string = XmStringCreateLtoR("Maximum Value",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
MaxValueLabel =
XmCreateLabel( RowColumn, "MaxValueLabel", args, n );
XtManageChild( MaxValueLabel );
XmStringFree( string );
n = 0;
XtSetArg( args[n], XmNvalue, "10" ); n++;
if ( child_type == XmSTRING )
sprintf( buffer, "%s", "StringMaxValueTF" );
else if ( child_type == XmNUMERIC )
sprintf( buffer, "%s", "NumericMaxValueTF" );
MaxValueTF =
XmCreateTextField( RowColumn, buffer, args, n );
XtManageChild( MaxValueTF );
XtAddCallback( MaxValueTF, XmNactivateCallback,
MaxValueCB, (XtPointer)client_widget );
string = XmStringCreateLtoR("Minimum Value",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
MinValueLabel =
XmCreateLabel( RowColumn, "MinValueLabel", args, n );
XtManageChild( MinValueLabel );
XmStringFree( string );
n = 0;
XtSetArg( args[n], XmNvalue, "0" ); n++;
if ( child_type == XmSTRING )
sprintf( buffer, "%s", "StringMinValueTF" );
else if ( child_type == XmNUMERIC )
sprintf( buffer, "%s", "NumericMinValueTF" );
MinValueTF =
XmCreateTextField( RowColumn, buffer, args, n );
XtManageChild( MinValueTF );
XtAddCallback( MinValueTF, XmNactivateCallback,
MinValueCB, (XtPointer)client_widget );
string = XmStringCreateLtoR("Num Values",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
NumValuesLabel =
XmCreateLabel( RowColumn, "NumValuesLabel", args, n );
XtManageChild( NumValuesLabel );
XmStringFree( string );
client_widget = ( child_type == XmSTRING ) ? StringTextF :
NumericTextF;
/*
* Get current value of XmNnumValues resource.
*/
n = 0;
XtSetArg( args[n], XmNnumValues, &j ); n++;
XtGetValues( client_widget, args, n );
sprintf( buffer, "%d", j );
n = 0;
XtSetArg( args[n], XmNvalue, buffer ); n++;
if ( child_type == XmSTRING )
sprintf( buffer2, "%s", "StringNumValuesTF" );
else if ( child_type == XmNUMERIC )
sprintf( buffer2, "%s", "NumericNumValuesTF" );
NumValuesTF =
XmCreateTextField( RowColumn, buffer2, args, n );
XtManageChild( NumValuesTF );
XtAddCallback( NumValuesTF, XmNactivateCallback,
NumValuesCB, (XtPointer)client_widget );
string = XmStringCreateLtoR("Position",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
PositionLabel =
XmCreateLabel( RowColumn, "PositionLabel", args, n );
XtManageChild( PositionLabel );
XmStringFree( string );
n = 0;
XtSetArg( args[n], XmNvalue, "0" ); n++;
if ( child_type == XmSTRING )
{
sprintf( buffer, "%s", "StringPositionTF" );
StringPositionTF =
XmCreateTextField( RowColumn, buffer, args, n );
XtManageChild( StringPositionTF );
XtAddCallback( StringPositionTF, XmNactivateCallback,
PositionCB, (XtPointer)client_widget );
XtAddCallback( SpinBox1, XmNvalueChangedCallback,
UpdatePositionCB, (XtPointer)StringPositionTF );
}
else if ( child_type == XmNUMERIC )
{
sprintf( buffer, "%s", "NumericPositionTF" );
NumericPositionTF =
XmCreateTextField( RowColumn, buffer, args, n );
XtManageChild( NumericPositionTF );
XtAddCallback( NumericPositionTF, XmNactivateCallback,
PositionCB, (XtPointer)client_widget );
XtAddCallback( SpinBox2, XmNvalueChangedCallback,
UpdatePositionCB, (XtPointer)NumericPositionTF );
}
string = XmStringCreateLtoR("SpinBox Child Type",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ChildTypeLabel =
XmCreateLabel( RowColumn, "ChildTypeLabel", args, n );
XtManageChild( ChildTypeLabel );
XmStringFree( string );
n = 0;
ChildTypePulldown = XmCreatePulldownMenu(RowColumn,
"ChildTypePulldown",
args, n);
for ( i = 0; i < NUM_CHILD_TYPE_BTNS; i++ )
{
string = XmStringCreateLtoR( child_type_strings[i],
XmFONTLIST_DEFAULT_TAG );
if ( child_type == XmSTRING )
sprintf( buffer, "StringChildTypePB%d", i );
else if ( child_type == XmNUMERIC )
sprintf( buffer, "NumericChildTypePB%d", i );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ChildTypePB[i] =
XmCreatePushButton( ChildTypePulldown, buffer, args, n );
XmStringFree( string );
if ( child_type == XmSTRING )
{
string_child_type_cd[i].textfield = client_widget;
string_child_type_cd[i].child_type = child_types[i];
XtAddCallback( ChildTypePB[i], XmNactivateCallback,
ChildTypeCB, &string_child_type_cd[i] );
}
else if ( child_type == XmNUMERIC )
{
numeric_child_type_cd[i].textfield = client_widget;
numeric_child_type_cd[i].child_type = child_types[i];
XtAddCallback( ChildTypePB[i], XmNactivateCallback,
ChildTypeCB, &numeric_child_type_cd[i] );
}
}
XtManageChildren( ChildTypePB, NUM_CHILD_TYPE_BTNS );
n = 0;
if ( child_type == XmSTRING )
{
XtSetArg( args[n], XmNmenuHistory, ChildTypePB[0] ); n++;
}
else if ( child_type == XmNUMERIC )
{
XtSetArg( args[n], XmNmenuHistory, ChildTypePB[1] ); n++;
}
XtSetArg( args[n], XmNsubMenuId, ChildTypePulldown ); n++;
ChildTypeOptions =
XmCreateOptionMenu( RowColumn, "ChildTypeOptions", args, n );
XtManageChild( ChildTypeOptions );
string = XmStringCreateLtoR( "Values",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ValuesLabel =
XmCreateLabel( RowColumn, "ValuesLabel", args, n );
XtManageChild( ValuesLabel );
XmStringFree( string );
/*
* Get current values for XmNvalues resource.
*/
n = 0;
XtSetArg( args[n], XmNnumValues, &j ); n++;
XtSetArg( args[n], XmNvalues, &stringTable ); n++;
XtGetValues( client_widget, args, n );
/*
* Assign current string values to List for display.
*/
if ( child_type == XmSTRING )
sprintf( buffer, "%s", "StringValuesList" );
else if ( child_type == XmNUMERIC )
sprintf( buffer, "%s", "NumericValuesList" );
n = 0;
XtSetArg( args[n], XmNitemCount, j ); n++;
XtSetArg( args[n], XmNitems, stringTable ); n++;
XtSetArg( args[n], XmNvisibleItemCount, 1 ); n++;
ValuesList = XmCreateScrolledList( RowColumn, buffer,
args, n );
XtManageChild( ValuesList );
return( RowColumn );
}
Widget *CreateBlockChoice(Widget parent, char *labelstr, int nsets, int type)
{
int nmal, i = 0;
XmString str;
char *name = (char *)"setchoice";
char buf[10];
Widget *retval = NULL;
switch (type)
{
case 0:
nmal = nsets + 2;
retval = (Widget *)XtMalloc(nmal * sizeof(Widget));
retval[1] = XmCreatePulldownMenu(parent, name, NULL, 0);
XtVaSetValues(retval[1],
XmNorientation, XmVERTICAL,
XmNpacking, XmPACK_COLUMN,
XmNnumColumns, nsets / 10,
NULL);
i = 0;
for (i = 0; i < nsets; i++)
{
sprintf(buf, "%d", i + 1);
retval[i + 2] = XmCreatePushButton(retval[1], buf, NULL, 0);
}
XtManageChildren(retval + 2, nsets);
str = XmStringCreate(labelstr, charset);
retval[0] = XmCreateOptionMenu(parent, name, NULL, 0);
XtVaSetValues(retval[0],
XmNlabelString, str,
XmNsubMenuId, retval[1],
XmNentryBorder, 2,
XmNwhichButton, 1,
NULL);
XtManageChild(retval[0]);
break;
case 1:
nmal = nsets + 3;
retval = (Widget *)XtMalloc(nmal * sizeof(Widget));
retval[1] = XmCreatePulldownMenu(parent, name, NULL, 0);
XtVaSetValues(retval[1],
XmNorientation, XmVERTICAL,
XmNpacking, XmPACK_COLUMN,
XmNnumColumns, nsets / 10,
NULL);
i = 0;
retval[2] = XmCreatePushButton(retval[1], (char *)"Index", NULL, 0);
for (i = 1; i < nsets + 1; i++)
{
sprintf(buf, "%d", i);
retval[i + 2] = XmCreatePushButton(retval[1], buf, NULL, 0);
}
XtManageChildren(retval + 2, nsets + 1);
str = XmStringCreate(labelstr, charset);
retval[0] = XmCreateOptionMenu(parent, name, NULL, 0);
XtVaSetValues(retval[0],
XmNlabelString, str,
XmNsubMenuId, retval[1],
XmNentryBorder, 2,
XmNwhichButton, 1,
NULL);
XtManageChild(retval[0]);
break;
default:
fprintf(stderr, "eblockwin.cpp:CreateBlockChoice(): retval not initialized\n");
break;
}
return retval;
}
EIF_POINTER font_box_create (char * a_name, EIF_POINTER a_parent, EIF_BOOLEAN dialog)
{
Widget form, select_form, mode_option;
Widget mode_menu, stand_fonts_button, non_stand_fonts_button;
Widget non_stand_list;
Widget stand_column, frame;
Widget form_button;
Widget ok_button, apply_button, cancel_button;
Widget family_menu_b, weight_menu_b, slant_menu_b;
Widget width_menu_b, point_menu_b, resolution_menu_b;
Widget family_menu, weight_menu, slant_menu;
Widget width_menu, point_menu, resolution_menu;
Widget text;
Widget *family_menu_buttons;
Widget *weight_menu_buttons;
Widget *slant_menu_buttons;
Widget *width_menu_buttons;
Widget *point_menu_buttons;
Widget *resolution_menu_buttons;
font_box_data * client;
XmString string;
Display * display;
int number_fonts;
char ** fonts_list;
char ** non_stand_fonts_list;
int number_non_stand, number_stand;
XmString * non_stand_strings;
font_box_font_info ** stand_fonts_list;
int i, j;
char * tmp_string;
XmString tmp_xm_string;
char **family_menu_list;
char **weight_menu_list;
char **slant_menu_list;
char **width_menu_list;
char **point_menu_list;
char **resolution_menu_list;
int number_family, number_weight, number_slant;
int number_width, number_point, number_resolution;
/*
* Creation of form dialog
*/
if (dialog) {
form = XmCreateFormDialog ((Widget) a_parent, (String) a_name, NULL, 0);
XtVaSetValues (form, XmNautoUnmanage, False, NULL);
}
else form = XmCreateForm ((Widget) a_parent, (String) a_name, NULL, 0);
/*
* Creation of sub-widgets
*/
select_form = XmCreateForm (form, "selectForm", NULL, 0);
XtManageChild (select_form);
text = XmCreateText (form, "text", NULL, 0);
XtManageChild (text);
form_button = XmCreateForm (form, "buttonsForm", NULL, 0);
XtManageChild (form_button);
mode_option = XmCreateOptionMenu (select_form, "switchOption", NULL, 0);
XtManageChild (mode_option);
mode_menu = XmCreatePulldownMenu (select_form, "switchMenu", NULL, 0);
stand_fonts_button = XmCreatePushButtonGadget (mode_menu, "standFont", NULL, 0);
XtManageChild (stand_fonts_button);
non_stand_fonts_button = XmCreatePushButtonGadget (mode_menu, "nonStandFont", NULL, 0);
XtManageChild (non_stand_fonts_button);
/*
* Creation of non-standard font selection system
*/
non_stand_list = XmCreateScrolledList (select_form, "nonStandList", NULL, 0);
XtManageChild (non_stand_list);
/*
* Creation of standard font selection system
*/
frame = XmCreateFrame (select_form, "standFrame", NULL, 0);
XtManageChild (frame);
stand_column = XmCreateRowColumn (frame, "standColumn", NULL, 0);
XtManageChild (stand_column);
family_menu_b = XmCreateOptionMenu (stand_column, "familyMenuButton", NULL, 0);
XtManageChild (family_menu_b);
weight_menu_b = XmCreateOptionMenu (stand_column, "weightMenuButton", NULL, 0);
XtManageChild (weight_menu_b);
slant_menu_b = XmCreateOptionMenu (stand_column, "slantMenuButton", NULL, 0);
XtManageChild (slant_menu_b);
width_menu_b = XmCreateOptionMenu (stand_column, "widthMenuButton", NULL, 0);
XtManageChild (width_menu_b);
point_menu_b = XmCreateOptionMenu (stand_column, "pointMenuButton", NULL, 0);
XtManageChild (point_menu_b);
resolution_menu_b = XmCreateOptionMenu (stand_column, "resolutionMenuButton", NULL, 0);
XtManageChild (resolution_menu_b);
family_menu = XmCreatePulldownMenu (stand_column, "familyMenu", NULL, 0);
weight_menu = XmCreatePulldownMenu (stand_column, "weightMenu", NULL, 0);
slant_menu = XmCreatePulldownMenu (stand_column, "slantMenu", NULL, 0);
width_menu = XmCreatePulldownMenu (stand_column, "widthMenu", NULL, 0);
point_menu = XmCreatePulldownMenu (stand_column, "pointMenu", NULL, 0);
resolution_menu = XmCreatePulldownMenu (stand_column, "resolutionMenu", NULL, 0);
/*
* Creation of buttons
*/
ok_button = XmCreatePushButtonGadget (form_button, "Ok", NULL, 0);
XtManageChild (ok_button);
apply_button = XmCreatePushButtonGadget (form_button, "Apply", NULL, 0);
XtManageChild (apply_button);
cancel_button = XmCreatePushButtonGadget (form_button, "Cancel", NULL, 0);
XtManageChild (cancel_button);
/*
* Attachments in font selection system
*/
AttachTop (mode_option, 0);
AttachLeft (mode_option, 0);
AttachRight (mode_option, 0);
/*
* Attachments in non-standard font selection system
*/
AttachTopWidget (mode_option, XtParent (non_stand_list), 5);
AttachLeft (XtParent (non_stand_list), 0);
AttachRight (XtParent (non_stand_list), 0);
AttachBottom (XtParent (non_stand_list), 0);
/*
* Attachments in standard font selection system
*/
AttachTopWidget (mode_option, frame, 5);
AttachLeft (frame, 0);
AttachRight (frame, 0);
AttachBottom (frame, 0);
/*
* Attachments in buttons form
*/
XtVaSetValues (form_button, XmNfractionBase, 6, NULL);
AttachTop (ok_button, 0);
AttachBottom (ok_button, 0);
AttachTop (apply_button, 0);
AttachBottom (apply_button, 0);
AttachTop (cancel_button, 0);
AttachBottom (cancel_button, 0);
/*
* Attachments in global form
*/
AttachTop (select_form, 10);
AttachLeft (select_form, 10);
AttachRight (select_form, 10);
AttachTopWidget (select_form, text, 10);
AttachLeft (text, 10);
AttachRight (text, 10);
AttachBottomWidget (form_button, text, 10);
AttachLeft (form_button, 10);
AttachRight (form_button, 10);
AttachBottom (form_button, 10);
/*
* Default values
*/
XtVaSetValues (family_menu_b, XmNsubMenuId, family_menu, NULL);
XtVaSetValues (weight_menu_b, XmNsubMenuId, weight_menu, NULL);
XtVaSetValues (slant_menu_b, XmNsubMenuId, slant_menu, NULL);
XtVaSetValues (width_menu_b, XmNsubMenuId, width_menu, NULL);
XtVaSetValues (point_menu_b, XmNsubMenuId, point_menu, NULL);
XtVaSetValues (resolution_menu_b, XmNsubMenuId, resolution_menu, NULL);
XmTextSetString (text, "Current_selected_font");
XtVaSetValues (text, XmNresizeHeight, True, XmNeditMode, XmMULTI_LINE_EDIT, NULL);
XtVaSetValues (XtParent (non_stand_list), XmNmappedWhenManaged, False, NULL);
string = XmStringCreateLtoR ("Non standard fonts", XmSTRING_DEFAULT_CHARSET);
XtVaSetValues (non_stand_fonts_button, XmNlabelString, string, NULL);
XmStringFree (string);
string = XmStringCreateLtoR ("Standard fonts", XmSTRING_DEFAULT_CHARSET);
XtVaSetValues (stand_fonts_button, XmNlabelString, string, NULL);
XmStringFree (string);
XtVaSetValues (mode_option, XmNsubMenuId, mode_menu, NULL);
XtVaSetValues (mode_option, XmNmenuHistory, stand_fonts_button, NULL);
/*
* Callbacks
*/
client = (font_box_data *) cmalloc (sizeof (font_box_data));
XtAddCallback (non_stand_list, XmNbrowseSelectionCallback, (XtCallbackProc) font_box_select_non_stand, client);
XtAddCallback (stand_fonts_button, XmNactivateCallback, (XtCallbackProc) font_box_switch_to_stand, client);
XtAddCallback (non_stand_fonts_button, XmNactivateCallback, (XtCallbackProc) font_box_switch_to_non_stand, client);
XtAddCallback (form, XmNdestroyCallback, (XtCallbackProc) font_box_destroy_action, client);
/*
* Fill the client structure
*/
client->non_stand_list = non_stand_list;
client->is_stand_mode = 1;
client->frame = frame;
client->text = text;
client->family_menu_b = family_menu_b;
client->weight_menu_b = weight_menu_b;
client->slant_menu_b = slant_menu_b;
client->width_menu_b = width_menu_b;
client->point_menu_b = point_menu_b;
client->resolution_menu_b = resolution_menu_b;
client->form = form;
client->ok_button = ok_button;
client->apply_button = apply_button;
client->cancel_button = cancel_button;
client->buttons_shown = 7;
client->stand_fonts_button = stand_fonts_button;
client->non_stand_fonts_button = non_stand_fonts_button;
font_box_attach_buttons (client);
/*
* Get the font list of current display
*/
display = XtDisplay (form);
fonts_list = XListFonts (display, "*", 10000, &number_fonts);
/*
* Get the non standard fonts
*/
number_non_stand = 0;
for (i = 0; i < number_fonts; i++)
if ('-' != *(fonts_list [i])) number_non_stand++;
non_stand_strings = (XmString *) cmalloc (number_non_stand*sizeof (XmString));
non_stand_fonts_list = (char **) cmalloc (number_non_stand*sizeof (char *));
for (i = j = 0; i < number_fonts; i++)
if ('-' != *(fonts_list [i])) {
non_stand_fonts_list [j] = fonts_list [i];
non_stand_strings [j++] = XmStringCreate (fonts_list [i], XmSTRING_DEFAULT_CHARSET);
}
i = 1;
while (i)
for (j = i = 0; j < number_non_stand-1; j++)
if (strcmp (non_stand_fonts_list [j], non_stand_fonts_list [j+1]) > 0) {
i = 1;
tmp_string = non_stand_fonts_list [j];
non_stand_fonts_list [j] = non_stand_fonts_list [j+1];
non_stand_fonts_list [j+1] = tmp_string;
tmp_xm_string = non_stand_strings [j];
non_stand_strings [j] = non_stand_strings [j+1];
non_stand_strings [j+1] = tmp_xm_string;
}
XmListAddItems (non_stand_list, non_stand_strings, number_non_stand, 1);
XmListSelectPos (non_stand_list, 1, False);
/*
* Get the standard fonts
*/
number_stand = number_fonts-number_non_stand;
stand_fonts_list = (font_box_font_info **) cmalloc (number_stand*sizeof (font_box_font_info *));
for (i = j = 0; i < number_fonts; i++)
if ('-' == *(fonts_list [i])) {
stand_fonts_list [j++] = font_box_create_font_info (fonts_list [i]);
}
number_family = 0;
number_weight = 0;
number_slant = 0;
number_width = 0;
number_point = 0;
number_resolution = 0;
for (i = 0; i < number_stand; i++) {
font_box_put_item (&(stand_fonts_list [i]->family), &number_family, &family_menu_list);
font_box_put_item (&(stand_fonts_list [i]->weight), &number_weight, &weight_menu_list);
font_box_put_item (&(stand_fonts_list [i]->slant), &number_slant, &slant_menu_list);
font_box_put_item (&(stand_fonts_list [i]->width), &number_width, &width_menu_list);
font_box_put_item (&(stand_fonts_list [i]->point), &number_point, &point_menu_list);
font_box_put_item (&(stand_fonts_list [i]->resolution), &number_resolution, &resolution_menu_list);
}
font_box_sort_alpha (&number_family, &family_menu_list);
font_box_sort_alpha (&number_weight, &weight_menu_list);
font_box_sort_alpha (&number_slant, &slant_menu_list);
font_box_sort_alpha (&number_width, &width_menu_list);
font_box_sort_num (&number_point, &point_menu_list);
font_box_sort_alpha (&number_resolution, &resolution_menu_list);
font_box_fill_menu (&family_menu_buttons, family_menu, &number_family, &family_menu_list);
font_box_fill_menu (&weight_menu_buttons, weight_menu, &number_weight, &weight_menu_list);
font_box_fill_menu (&slant_menu_buttons, slant_menu, &number_slant, &slant_menu_list);
font_box_fill_menu (&width_menu_buttons, width_menu, &number_width, &width_menu_list);
font_box_fill_menu (&point_menu_buttons, point_menu, &number_point, &point_menu_list);
font_box_fill_menu (&resolution_menu_buttons, resolution_menu, &number_resolution, &resolution_menu_list);
for (i = 0; i < number_family; i++)
XtAddCallback (family_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_family, client);
for (i = 0; i < number_weight; i++)
XtAddCallback (weight_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_weight, client);
for (i = 0; i < number_slant; i++)
XtAddCallback (slant_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_slant, client);
for (i = 0; i < number_width; i++)
XtAddCallback (width_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_width, client);
for (i = 0; i < number_point; i++)
XtAddCallback (point_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_point, client);
for (i = 0; i < number_resolution; i++)
XtAddCallback (resolution_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_resolution, client);
/*
* Fill the client structure
*/
client->non_stand_fonts_list = non_stand_fonts_list;
client->stand_fonts_list = stand_fonts_list;
client->current_font_name = non_stand_fonts_list [0];
client->current_stand_font = 0;
client->current_non_stand_font = 0;
client->family_menu_buttons = family_menu_buttons;
client->weight_menu_buttons = weight_menu_buttons;
client->slant_menu_buttons = slant_menu_buttons;
client->width_menu_buttons = width_menu_buttons;
client->point_menu_buttons = point_menu_buttons;
client->resolution_menu_buttons = resolution_menu_buttons;
client->family_menu_list = family_menu_list;
client->weight_menu_list = weight_menu_list;
client->slant_menu_list = slant_menu_list;
client->width_menu_list = width_menu_list;
client->point_menu_list = point_menu_list;
client->resolution_menu_list = resolution_menu_list;
client->number_stand = number_stand;
client->number_family = number_family;
client->number_weight = number_weight;
client->number_slant = number_slant;
client->number_width = number_width;
client->number_point = number_point;
client->number_resolution = number_resolution;
client->current_font = NULL;
client->current_family = client->current_weight = client->current_slant = -1;
client->current_width = client->current_point = client->current_resolution = -1;
font_box_set_family (family_menu_buttons [0], client, NULL);
return (EIF_POINTER) client;
}
void setup_gui_display()
{
Widget hsep, sm_sep, menu, menubut, but, fsep, seph;
Widget build_opt, build_menu, build4but, build5but, build6but;
Widget build7but, build8but;
Widget prod_file_button, im_prod_lb_button, db_select_title;
Widget all_packetbut;
Widget filter_label;
Widget label2, sep;
Widget disp_list_but, filter_list_but, label3, label5;
Widget prod_info_frame, prod_info_hdr_lbl;
Widget alt_src_frame, alt_src_form, alt_src_frame_label;
XmString *initlist;
Arg args[20];
int n=0;
int i=0;
XmString xmstr, labelstr, list_label_str;
static char* help1 = HELP_FILE_MAIN_WIN;
static char* help2 = HELP_FILE_DISPLAY_WIN;
static char* help3 = HELP_FILE_PROD_SPEC;
static char* help4 = HELP_FILE_SITE_SPEC;
static char *helpfile = HELP_FILE_PDLB_SELECT;
static int build4 = BUILD_4_AND_EARLIER;
static int build5 = BUILD_5;
static int build6 = BUILD_6;
static int build7 = BUILD_7;
static int build8 = BUILD_8; /* and later */
/* end declarations */
mainwin = XtVaCreateManagedWidget("mainwin",
xmMainWindowWidgetClass, shell,
NULL);
form = XtVaCreateManagedWidget("form", xmFormWidgetClass, mainwin,
NULL);
setup_gui_colors();
/* --- BEGIN MENU BAR --- */
/* NEW MENU */
/* Menu Bars must have homogeneous content, in order to add an option menu */
/* at the top, the manu bar should be a child of the form rather than the */
/* main window so it does not cross the complete top of the window */
/* // menubar = XmCreateMenuBar(mainwin, "menubar", NULL, 0); */
menubar = XmCreateMenuBar(form, "menubar", NULL, 0);
XtVaSetValues(menubar,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 0,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 0,
XmNrightAttachment, XmATTACH_NONE,
NULL);
XtVaSetValues(XtParent(menubar),
XmNallowShellResize, TRUE,
NULL);
/* create file menu */
menu = XmCreatePulldownMenu(menubar, "filemenu", NULL, 0);
menubut = XtVaCreateManagedWidget("File",xmCascadeButtonWidgetClass,menubar,
XmNsubMenuId, menu, NULL);
but = XtVaCreateManagedWidget("Preferences...",xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(but, XmNactivateCallback, pref_window_callback, NULL);
fsep = XtVaCreateManagedWidget("fsep2",xmSeparatorWidgetClass,menu,NULL);
but = XtVaCreateManagedWidget("Exit",xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(but, XmNactivateCallback, exit_callback, NULL);
/* create help menu */
menu = XmCreatePulldownMenu(menubar, "helpmenu", NULL, 0);
menubut = XtVaCreateManagedWidget("Help",xmCascadeButtonWidgetClass,menubar,
XmNsubMenuId, menu, NULL);
but = XtVaCreateManagedWidget("About CVG",xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(but, XmNactivateCallback, about_callback, NULL);
seph = XtVaCreateManagedWidget("seph1",xmSeparatorWidgetClass,menu,NULL);
but = XtVaCreateManagedWidget("Main Window",xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(but, XmNactivateCallback, help_window_callback, help1);
but = XtVaCreateManagedWidget("Display Window",xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(but, XmNactivateCallback, help_window_callback, help2);
but = XtVaCreateManagedWidget("Product Configuration",
xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(but, XmNactivateCallback, help_window_callback, help3);
but = XtVaCreateManagedWidget("Site Specific Information",
xmPushButtonWidgetClass,menu,NULL);
XtAddCallback(but, XmNactivateCallback, help_window_callback, help4);
XtVaSetValues(menubar, XmNmenuHelpWidget, menubut, NULL);
XtManageChild(menubar);
/* --- END MENUBAR --- */
/*****************************************************************/
labelstr = XmStringCreateLtoR("Product from ORPG ", XmFONTLIST_DEFAULT_TAG);
build_opt = XmCreateOptionMenu(form, "build_opt", NULL, 0);
build_menu = XmCreatePulldownMenu(form, "disp_menu", NULL, 0);
build4but = XtVaCreateManagedWidget("Build 4 -", xmPushButtonWidgetClass,
build_menu, NULL);
XtAddCallback(build4but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build4);
build5but = XtVaCreateManagedWidget("Build 5 ", xmPushButtonWidgetClass,
build_menu, NULL);
XtAddCallback(build5but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build5);
build6but = XtVaCreateManagedWidget("Build 6 ", xmPushButtonWidgetClass,
build_menu, NULL);
XtAddCallback(build6but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build6);
build7but = XtVaCreateManagedWidget("Build 7 ", xmPushButtonWidgetClass,
build_menu, NULL);
XtAddCallback(build7but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build7);
build8but = XtVaCreateManagedWidget("Build 8 +", xmPushButtonWidgetClass,
build_menu, NULL);
XtAddCallback(build8but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build8);
XtVaSetValues(build_opt,
XmNsubMenuId, build_menu,
XmNorientation, XmHORIZONTAL,
XmNspacing, 0,
XmNlabelString, labelstr,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 0,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 5,
XmNleftAttachment, XmATTACH_NONE,
NULL);
XmStringFree(labelstr);
if(orpg_build_i <= 4)
XtVaSetValues(build_opt, XmNmenuHistory, build4but, NULL);
else if(orpg_build_i == 5)
XtVaSetValues(build_opt, XmNmenuHistory, build5but, NULL);
else if(orpg_build_i == 6)
XtVaSetValues(build_opt, XmNmenuHistory, build6but, NULL);
else if(orpg_build_i == 7)
XtVaSetValues(build_opt, XmNmenuHistory, build7but, NULL);
else if(orpg_build_i >= 8)
XtVaSetValues(build_opt, XmNmenuHistory, build8but, NULL);
XtManageChild(build_opt);
/*******************************************************************************/
/* --- BEGIN RADIO BOX --- */
screen_radio_label = XtVaCreateManagedWidget("Screen:",
xmLabelWidgetClass, form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 45,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_NONE,
NULL);
screen_radiobox = XmCreateRadioBox(form, "radioselect", NULL, 0);
XtVaSetValues(screen_radiobox,
XmNorientation, XmHORIZONTAL,
XmNpacking, XmPACK_TIGHT,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 38,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, screen_radio_label,
XmNleftOffset, 0,
XmNrightAttachment, XmATTACH_NONE,
NULL);
XtManageChild(screen_radiobox);
/* create the toggle buttons within the radio box */
s1_radio = XtVaCreateManagedWidget("1", xmToggleButtonWidgetClass,
screen_radiobox, XmNset, TRUE, NULL);
XtAddCallback(s1_radio, XmNarmCallback, screen1_radio_callback, NULL);
s2_radio = XtCreateManagedWidget("2", xmToggleButtonWidgetClass,
screen_radiobox, NULL, 0);
XtAddCallback(s2_radio, XmNarmCallback, screen2_radio_callback, NULL);
s3_radio = XtCreateManagedWidget("Aux", xmToggleButtonWidgetClass,
screen_radiobox, NULL, 0);
XtAddCallback(s3_radio, XmNarmCallback, screen3_radio_callback, NULL);
/* the default settings: */
XtSetSensitive(s1_radio, True);
XtSetSensitive(s2_radio, False);
XtSetSensitive(s3_radio, True);
/* --- END RADIO BOX --- */
alt_src_frame = XtVaCreateManagedWidget ("alternatesrcframe",
xmFrameWidgetClass, form,
XmNwidth, 231,
XmNheight, 68,
XmNshadowType, XmSHADOW_ETCHED_IN,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 20,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, screen_radiobox,
XmNleftOffset, 2,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_NONE,
NULL);
alt_src_frame_label = XtVaCreateManagedWidget ("Alternate Data Source",
xmLabelGadgetClass, alt_src_frame,
XmNframeChildType, XmFRAME_TITLE_CHILD,
XmNchildVerticalAlignment, XmALIGNMENT_CENTER,
NULL);
alt_src_form = XtVaCreateManagedWidget("altform",
xmFormWidgetClass, alt_src_frame,
XmNwidth, 231,
XmNheight, 68,
NULL);
prod_file_button = XtVaCreateManagedWidget("Product Disk File",
xmPushButtonWidgetClass, alt_src_form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 2,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 6,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 8,
XmNrightAttachment, XmATTACH_NONE,
XmNwidth, bwidth-20,
XmNheight, bheight,
NULL);
XtAddCallback(prod_file_button,
XmNactivateCallback, diskfile_select_callback,
NULL);
im_prod_lb_button = XtVaCreateManagedWidget("Product LB",
xmPushButtonWidgetClass, alt_src_form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 2,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, prod_file_button,
XmNleftOffset, 4,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 8,
XmNbottomAttachment, XmATTACH_NONE,
XmNwidth, bwidth-55,
XmNheight, bheight,
NULL);
XtAddCallback(im_prod_lb_button, XmNactivateCallback, ilb_file_select_callback, NULL);
/* display all packets button, default is unset */
all_packetbut = XtVaCreateManagedWidget("Display All Packets",
xmToggleButtonWidgetClass, form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 27,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, alt_src_frame,
XmNleftOffset, 5,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_NONE,
NULL);
XtAddCallback(all_packetbut, XmNvalueChangedCallback, select_all_graphic_callback, NULL);
sm_sep = XtVaCreateManagedWidget("", xmSeparatorWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, build_opt,
XmNtopOffset, 6,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, all_packetbut,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 8,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
/* overlay button, only active if all packets are selected */
overlay_but = XtVaCreateManagedWidget("Overlay Packets ",
xmToggleButtonWidgetClass, form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 49,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, alt_src_frame,
XmNleftOffset, 23,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_NONE,
NULL);
/* may not be used. instead value for is_set is read by packet_selection_manu */
XtAddCallback(overlay_but, XmNvalueChangedCallback, overlayflag_callback, NULL);
packet_button = XtVaCreateManagedWidget("Select Packets",
xmPushButtonWidgetClass,form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 48,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, all_packetbut,
XmNleftOffset, 10,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_NONE,
XmNwidth, bwidth-33,
XmNheight, bheight,
NULL);
XtAddCallback(packet_button, XmNactivateCallback, display_packetselect_callback, NULL);
/* initial state of the all_packetbut, overlay_but and packet_button */
if(select_all_flag == TRUE) {
XtVaSetValues(all_packetbut,
XmNset, XmSET,
NULL);
XtVaSetValues(overlay_but,
XmNsensitive, True,
XmNset, XmSET,
NULL);
XtVaSetValues(packet_button,
XmNsensitive, False,
NULL);
} else {
XtVaSetValues(all_packetbut,
XmNset, XmUNSET,
NULL);
XtVaSetValues(overlay_but,
XmNsensitive, False,
XmNset, XmUNSET,
NULL);
XtVaSetValues(packet_button,
XmNsensitive, True,
NULL);
}
hsep = XtVaCreateManagedWidget("", xmSeparatorWidgetClass, form,
XmNseparatorType, XmSHADOW_ETCHED_IN,
XmNseparatorType, XmDOUBLE_LINE,
XmNmargin, 20,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 77,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
XmNwidth, 510,
XmNheight, 5,
NULL);
/* BEGIN GUI ELEMENTS FROM DB SELECT HERE */
db_select_title = XtVaCreateManagedWidget(" Product Database Selection Dialog ",
xmLabelWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, hsep,
XmNtopOffset, 5,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 5,
XmNalignment, XmALIGNMENT_CENTER,
XmNrecomputeSize, True,
NULL);
xmstr = XmStringCreateLtoR(" Product Database Selection Dialog ", "largefont");
XtVaSetValues(db_select_title, XmNlabelString, xmstr, NULL);
XmStringFree(xmstr);
/* the filter selection widgets here */
filter_label = XtVaCreateManagedWidget("PRODUCT LIST FILTER SELECTION",
xmLabelWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, db_select_title,
XmNtopOffset, 5,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 85,
NULL);
prodid_text = XtVaCreateManagedWidget("",
xmTextFieldWidgetClass, form,
XmNcolumns, 5,
XmNmaxLength, 4,
XmNmarginHeight, 2,
XmNmarginWidth, 2,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, filter_label,
XmNtopOffset, 5,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 290,
NULL);
vol_text = XtVaCreateManagedWidget("",
xmTextFieldWidgetClass, form,
XmNcolumns, 4,
XmNmaxLength, 3,
XmNmarginHeight, 2,
XmNmarginWidth, 2,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, prodid_text,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 40,
NULL);
/*-------------------*/
prod_filter_radiobox = XmCreateRadioBox(form, "filterselect", NULL, 0);
XtVaSetValues(prod_filter_radiobox,
XmNorientation, XmHORIZONTAL,
XmNpacking, XmPACK_TIGHT,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, filter_label,
XmNtopOffset, 2,
XmNbottomAttachment, XmATTACH_NONE,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, prodid_text,
XmNrightOffset, 0,
NULL);
XtManageChild(prod_filter_radiobox);
/* create the toggle buttons within the radio box */
prodid_radio = XtVaCreateManagedWidget("ProdID", xmToggleButtonWidgetClass,
prod_filter_radiobox, XmNset, TRUE, NULL);
XtAddCallback(prodid_radio, XmNvalueChangedCallback, prodid_filter_callback, NULL);
type_radio = XtCreateManagedWidget("Name:", xmToggleButtonWidgetClass,
prod_filter_radiobox, NULL, 0);
XtAddCallback(type_radio, XmNvalueChangedCallback, type_filter_callback, NULL);
pcode_radio = XtCreateManagedWidget("PCode:", xmToggleButtonWidgetClass,
prod_filter_radiobox, NULL, 0);
XtAddCallback(pcode_radio, XmNvalueChangedCallback, pcode_filter_callback, NULL);
/*-------------------*/
label2 = XtVaCreateManagedWidget("Vol:",
xmLabelWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, filter_label,
XmNtopOffset, 9,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, vol_text,
XmNrightOffset, 3,
NULL);
sep = XtVaCreateManagedWidget("", xmSeparatorWidgetClass, form,
XmNseparatorType, XmSHADOW_ETCHED_IN,
XmNorientation, XmVERTICAL,
XmNmargin, 10,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, db_select_title,
XmNtopOffset, 5,
XmNrightAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 345,
XmNbottomAttachment, XmATTACH_NONE,
XmNwidth, 4,
XmNheight, 60,
NULL);
/* end filter selection widgets */
/* display list widget */
disp_list_but = XtVaCreateManagedWidget("Update List & Filter",
xmPushButtonWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, db_select_title,
XmNtopOffset, 5,
XmNrightAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, sep,
XmNleftOffset, 15,
XmNwidth, 120,
XmNheight, 25,
NULL);
XtAddCallback(disp_list_but, XmNactivateCallback, build_list_Callback, NULL);
XtManageChild(disp_list_but);
/* Add capability to set text in disp_list_but label to red when there is */
/* a new database list to update Black - current, Red - new data available */
filter_list_but = XtVaCreateManagedWidget("Apply Filter Only",
xmPushButtonWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, db_select_title,
XmNtopOffset, 5,
XmNrightAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, sep,
XmNleftOffset, 145,
XmNwidth, 105,
XmNheight, 25,
NULL);
XtAddCallback(filter_list_but, XmNactivateCallback, filter_list_Callback, NULL);
XtManageChild(filter_list_but);
label3 = XtVaCreateManagedWidget("Products Available / Listed: ",
xmLabelWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, disp_list_but,
XmNtopOffset, 5,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, sep,
XmNleftOffset, 15,
XmNleftOffset, 10,
NULL);
/* Linux Issue - Red Hat sometimes has a problem initially rendering
label widgets if they are allowed to resize themselves
*/
num_prod_label = XtVaCreateManagedWidget("---",
xmLabelWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, disp_list_but,
XmNtopOffset, 5,
XmNrightAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label3,
XmNleftOffset, 1,
XmNbottomAttachment, XmATTACH_NONE,
XmNwidth, 35,
XmNrecomputeSize, False,
XmNalignment, XmALIGNMENT_END,
NULL);
label5 = XtVaCreateManagedWidget("/",
xmLabelWidgetClass, form,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, num_prod_label,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, num_prod_label,
XmNleftOffset, 1,
NULL);
list_size_label = XtVaCreateManagedWidget("---",
xmLabelWidgetClass, form,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, num_prod_label,
XmNrightAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label5,
XmNleftOffset, 1,
XmNbottomAttachment, XmATTACH_NONE,
XmNwidth, 35,
XmNrecomputeSize, False,
XmNalignment, XmALIGNMENT_END,
NULL);
prod_info_frame = XtVaCreateManagedWidget ("prodinfoframe",
xmFrameWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, list_size_label,
XmNtopOffset, 33,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 3,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
prod_info_label = XtVaCreateManagedWidget(" ",
xmLabelWidgetClass, prod_info_frame,
XmNalignment, XmALIGNMENT_BEGINNING,
XmNrecomputeSize, False,
XmNwidth, 598,
NULL);
prod_info_hdr_lbl = XtVaCreateManagedWidget( " ",
xmLabelWidgetClass, form,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, prod_info_frame,
XmNbottomOffset, 2,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, prod_info_frame,
XmNalignment, XmALIGNMENT_BEGINNING,
NULL);
/* CVG 9.0 - improve alignment of labels and list on some X-servers */
{
char *label_buf =
" msg Vol ProdID Param1 Param2 Param3 Param4 Param5 Param6 ";
labelstr = XmStringCreateLtoR(label_buf, "tabfont");
XtVaSetValues(prod_info_hdr_lbl, XmNlabelString, labelstr, NULL);
XmStringFree(labelstr);
}
/* --- DB PRODUCT SELECTION BOX --- */
/* an initial empty list */
initlist = (XmStringTable) XtMalloc(5 * sizeof (XmString));
initlist[0] = XmStringCreateLtoR (initstr[0], "tabfont");
initlist[1] = XmStringCreateLtoR (initstr[1], "tabfont");
initlist[2] = XmStringCreateLtoR (initstr[2], "tabfont");
initlist[3] = XmStringCreateLtoR (initstr[3], "tabfont");
initlist[4] = XmStringCreateLtoR (initstr[4], "tabfont");
/*****************BEGIN ORIGINAL SELECT DILOG***********************/
/* create dialog window */
n=0;
/* controls height of list area */
XtSetArg(args[n], XmNlistVisibleItemCount, NUM_VISIBLE); n++;
XtSetArg(args[n], XmNokLabelString,
XmStringCreateLtoR("Select Database Product", XmFONTLIST_DEFAULT_TAG)); n++;
XtSetArg(args[n], XmNhelpLabelString,
XmStringCreateLtoR("Database Dialog Help", XmFONTLIST_DEFAULT_TAG)); n++;
/* the following is critical if using selection box in application shell */
XtSetArg(args[n], XmNdialogStyle, XmDIALOG_MODELESS); n++;
/* the following keeps this window open */
XtSetArg(args[n], XmNautoUnmanage,False); n++;
/* this resource should keep list from getting wider, it doesn't */
/*XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); n++; */
/* this resource prevents change in size but dramatically slows list function if window too narrow */
/*XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++; */
db_dialog = XmCreateSelectionBox(form, "product_selectd", args, n);
XtVaSetValues(db_dialog,
XmNtopAttachment, XmATTACH_WIDGET,
XmNmarginHeight, 0,
XmNmarginWidth, 0,
XmNtopWidget, prod_info_frame,
XmNtopOffset, 0,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
NULL);
/* get rid of buttons 'n' stuff we don't want */
XtUnmanageChild(XmSelectionBoxGetChild(db_dialog, XmDIALOG_SELECTION_LABEL));
XtUnmanageChild(XmSelectionBoxGetChild(db_dialog, XmDIALOG_TEXT));
XtUnmanageChild(XmSelectionBoxGetChild(db_dialog, XmDIALOG_APPLY_BUTTON));
XtUnmanageChild(XmSelectionBoxGetChild(db_dialog, XmDIALOG_CANCEL_BUTTON));
/* CVG 9.0 - improve alignment of labels and list on some X-servers */
create_db_list_label(&list_label_str);
XtVaSetValues(db_dialog,
XmNlistLabelString, list_label_str,
NULL);
XmStringFree(list_label_str);
/* default select first item in list */
db_list = XmSelectionBoxGetChild(db_dialog, XmDIALOG_LIST);
XtVaSetValues(db_list,
/* ATTEMPT TO DELEAY CALLBACKS UNTIL BUTTON RELEASED */
/* XmNautomaticSelection, XmNO_AUTO_SELECT, */
XmNautomaticSelection, XmAUTO_SELECT,
XmNselectionPolicy, XmBROWSE_SELECT,
XmNitems, initlist,
XmNitemCount, 5,
XmNmatchBehavior, XmNONE, /* disables character match navigation */
XmNdoubleClickInterval, 250,
NULL);
/* FREE initlist; */
for(i=0; i<5; i++)
XmStringFree(initlist[i]);
XtFree((char *)initlist);
initlist=NULL;
XtAddCallback(db_list, XmNbrowseSelectionCallback, browse_select_Callback, NULL);
/* do not add defaultActionCallback for the db_list itself! disables double click */
/* XtAddCallback(db_list, XmNdefaultActionCallback, listselection_Callback, NULL); */
XtAddCallback(db_dialog, XmNokCallback, listselection_Callback, NULL);
XtAddCallback(db_dialog, XmNhelpCallback, help_window_callback, helpfile);
XtManageChild(db_dialog);
/*****************END ORIGINAL SELECT DIALOG***********************/
/* END GUI ELEMENTS FROM DB SELECT */
/* cleanup */
XtVaSetValues(mainwin,
XmNworkWindow, form,
NULL);
/* the top level shell has already been realized in cvg.c */
XtRealizeWidget(mainwin);
/* reset the colors */
XSetForeground(display, gc, white_color);
XSetBackground(display, gc, black_color);
} /* end setup_gui_display */
Widget *XbrMenu(Widget parent, char *title, int menu_type,
XbrMenuData menu_data[], int n)
{
XtAppContext app_context = XtWidgetToApplicationContext(parent);
Widget *widgets;
Boolean radio_behaviour = False;
int i, extras;
Arg args[10];
Cardinal num;
XmString string;
char name[256];
/* Number of extra widgets to create - for a popup this is just the popup
menu but for pulldowns there is the menu and the cascade button.
*/
if(menu_type == XbrMENU_POPUP)
extras = 1;
else
extras = 2;
/* Allocate memory for widgets */
if((widgets = (Widget *) malloc(sizeof(Widget) * (n+extras))) == NULL) {
XtAppError(app_context, "Error - out of memory!\n");
return(NULL);
}
/* Create menu */
switch(menu_type) {
case XbrMENU_POPUP:
sprintf(name, "%sPopup", title);
widgets[MENU] = XmCreatePopupMenu(parent, name, NULL, 0);
break;
case XbrMENU_OPTION:
sprintf(name, "%sPane", title);
widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
num = 0;
string = XmStringCreateLocalized(title);
XtSetArg(args[num], XmNsubMenuId, widgets[MENU]); num++;
XtSetArg(args[num], XmNlabelString, string); num++;
sprintf(name, "%sOption", title);
widgets[CASCADE] = XmCreateOptionMenu(parent, name, args, num);
XmStringFree(string);
XtManageChild(widgets[CASCADE]);
break;
case XbrMENU_PULLDOWN_RADIO:
radio_behaviour = True;
case XbrMENU_PULLDOWN:
sprintf(name, "%sPulldown", title);
widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
XtVaSetValues(widgets[MENU], XmNradioBehavior, radio_behaviour,
NULL);
/* Create menu title */
sprintf(name, "%sCascade", title);
widgets[CASCADE] = XtVaCreateManagedWidget(name,
xmCascadeButtonWidgetClass, parent,
XmNsubMenuId, widgets[MENU],
XtVaTypedArg, XmNlabelString, XmRString,
title, sizeof(char *),
NULL);
break;
default:
XtAppError(app_context, "Unknown menu type!\n");
}
/* Add desired widgets */
for(i = 0; i < n; i++) {
sprintf(name, "%s%d", title, i);
switch(menu_data[i].type) {
/* Label widget - easy */
case XbrLABEL:
string = XmStringCreateLocalized(menu_data[i].label);
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmLabelWidgetClass, widgets[MENU],
XmNlabelString, string,
NULL);
XmStringFree(string);
break;
/* Push button gadget - include activate callback & data */
case XbrPB:
string = XmStringCreateLocalized(menu_data[i].label);
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmPushButtonWidgetClass, widgets[MENU],
XmNlabelString, string,
NULL);
XmStringFree(string);
if(menu_data[i].callback)
XtAddCallback(widgets[i+extras], XmNactivateCallback,
menu_data[i].callback, menu_data[i].data);
if(menu_data[i].set && menu_type == XbrMENU_OPTION)
XtVaSetValues(widgets[CASCADE], XmNmenuHistory,
widgets[i+extras], NULL);
break;
/* Toggle button - include value changed callback & data */
case XbrTOGGLE:
num = 0;
string = XmStringCreateLocalized(menu_data[i].label);
XtSetArg(args[num], XmNlabelString, string); num++;
XtSetArg(args[num], XmNindicatorType, XmONE_OF_MANY); num++;
if(menu_data[i].set != XbrNOSET) {
XtSetArg(args[num], XmNset, menu_data[i].set); num++;
}
widgets[i+extras] = XmCreateToggleButton(widgets[MENU], name,
args, num);
XtManageChild(widgets[i+extras]);
XmStringFree(string);
if(menu_data[i].callback)
XtAddCallback(widgets[i+extras], XmNvalueChangedCallback,
menu_data[i].callback, menu_data[i].data);
break;
/* Separator to make menu look pretty! */
case XbrSEPARATOR:
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmSeparatorWidgetClass, widgets[MENU],
NULL);
break;
/* A sub menu */
case XbrSUBMENU:
widgets[i+extras] = (Widget)XbrMenu(widgets[MENU], menu_data[i].title, menu_data[i].stype,
menu_data[i].submenu, menu_data[i].n);
break;
default:
XtAppError(app_context, "Unknown menu item!\n");
break;
}
}
return(widgets);
}
int main(int argc, char **argv)
{
XtAppContext app;
Widget top, mb, form, fc, fp, quit, s, om, mp, w;
int i;
Arg arg;
XmString xms;
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app, "Label", NULL, 0,
&argc, argv, fallback, NULL);
form = XtVaCreateManagedWidget("form", xmFormWidgetClass, toplevel,
XmNwidth, 500,
XmNheight, 300,
XmNresizePolicy, XmRESIZE_NONE,
NULL);
mb = XtVaCreateManagedWidget("mb", xmRowColumnWidgetClass, form,
XmNrowColumnType, XmMENU_BAR,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
fp = XmCreatePulldownMenu(mb, "file pulldown", NULL, 0);
fc = XtVaCreateManagedWidget("File", xmCascadeButtonWidgetClass, mb,
XmNsubMenuId, fp,
NULL);
quit = XtVaCreateManagedWidget("Quit", xmPushButtonWidgetClass, fp,
NULL);
XtAddCallback(quit, XmNactivateCallback, Quit, NULL);
/* Panel of scales */
top = mb;
for (i=0; i<XtNumber(list); i++) {
xms = XmStringCreateSimple(list[i].name);
s = XtVaCreateManagedWidget(list[i].name, xmScaleWidgetClass, form,
XmNorientation, XmHORIZONTAL,
XmNminimum, list[i].min,
XmNmaximum, list[i].max,
XmNvalue, list[i].initial,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, top,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 25,
XmNbottomAttachment, XmATTACH_NONE,
XmNtitleString, xms,
XmNshowValue, True,
NULL);
XmStringFree(xms);
top = s;
XtAddCallback(s, XmNvalueChangedCallback, Change, (XtPointer)i);
}
/* Option menu for placement */
mp = XmCreatePulldownMenu(form, "option pane", NULL, 0);
xms = XmStringCreateSimple("Placement");
XtSetArg(arg, XmNlabelString, xms);
om = XmCreateOptionMenu(form, "option", &arg, 1);
XmStringFree(xms);
XtVaSetValues(om,
XmNsubMenuId, mp,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, top,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 25,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtManageChild(om);
w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
XtVaTypedArg, XmNlabelString, XmRString, "TOP_RIGHT", 10,
NULL);
XtAddCallback(w, XmNactivateCallback,
ChangePlacement, (XtPointer)XmTOP_RIGHT);
w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
XtVaTypedArg, XmNlabelString, XmRString, "BOTTOM_RIGHT", 12,
NULL);
XtAddCallback(w, XmNactivateCallback,
ChangePlacement, (XtPointer)XmBOTTOM_RIGHT);
XtVaSetValues(om, XmNmenuHistory, w, NULL);
w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
XtVaTypedArg, XmNlabelString, XmRString, "BOTTOM_LEFT", 11,
NULL);
XtAddCallback(w, XmNactivateCallback,
ChangePlacement, (XtPointer)XmBOTTOM_LEFT);
w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
XtVaTypedArg, XmNlabelString, XmRString, "TOP_LEFT", 9,
NULL);
XtAddCallback(w, XmNactivateCallback,
ChangePlacement, (XtPointer)XmTOP_LEFT);
/* Create the SW */
sw = XtVaCreateManagedWidget("sw", xmScrolledWindowWidgetClass, form,
XmNscrollingPolicy, XmAUTOMATIC,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, mb,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 25,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
XmNwidth, 100,
XmNheight, 100,
NULL);
ab = XtVaCreateManagedWidget("ab", xmArrowButtonWidgetClass, sw,
XmNwidth, 300,
XmNheight, 300,
NULL);
XtAddCallback(ab,XmNactivateCallback,cb,0);
XtRealizeWidget(toplevel);
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight , 508, 524, 500, 300, 0,0,0, /* form */
CWWidth | CWHeight | CWX | CWY, 0, 0, 500, 31, 0,0,0, /* mb */
CWWidth | CWHeight | CWX | CWY, 5, 5, 40, 21, 0,0,0, /* File */
CWWidth | CWHeight | CWX | CWY, 0, 31, 125, 56, 0,0,0, /* width */
CWWidth | CWHeight | CWX | CWY, 0, 35, 34, 17, 0,0,0, /* Title */
CWWidth | CWHeight | CWX | CWY, 0, 16, 125, 19, 0,0,0, /* Scrollbar */
CWWidth | CWHeight | CWX | CWY, 0, 87, 125, 56, 0,0,0, /* height */
CWWidth | CWHeight | CWX | CWY, 0, 35, 40, 17, 0,0,0, /* Title */
CWWidth | CWHeight | CWX | CWY, 0, 16, 125, 19, 0,0,0, /* Scrollbar */
CWWidth | CWHeight | CWX | CWY, 0, 143, 125, 56, 0,0,0, /* spacing */
CWWidth | CWHeight | CWX | CWY, 0, 35, 46, 17, 0,0,0, /* Title */
CWWidth | CWHeight | CWX | CWY, 0, 16, 125, 19, 0,0,0, /* Scrollbar */
CWWidth | CWHeight | CWX | CWY, 0, 199, 125, 56, 0,0,0, /* shadowThickness */
CWWidth | CWHeight | CWX | CWY, 0, 35, 94, 17, 0,0,0, /* Title */
CWWidth | CWHeight | CWX | CWY, 0, 16, 125, 19, 0,0,0, /* Scrollbar */
CWWidth | CWHeight | CWX | CWY, 0, 255, 125, 31, 0,0,0, /* option */
CWWidth | CWHeight | CWX | CWY, 3, 3, 58, 25, 0,0,0, /* OptionLabel */
CWWidth | CWHeight | CWX | CWY, 64, 3, 109, 25, 0,0,0, /* OptionButton */
CWWidth | CWHeight | CWX | CWY, 125, 31, 100, 100, 0,0,0, /* sw */
CWWidth | CWHeight | CWX | CWY, 4, 4, 69, 69, 0,0,0, /* ScrolledWindowClipWindow */
CWWidth | CWHeight | CWX | CWY, 0, 0, 300, 300, 0,0,0, /* ab */
CWWidth | CWHeight | CWX | CWY, 81, 0, 19, 77, 0,0,0, /* VertScrollBar */
CWWidth | CWHeight | CWX | CWY, 0, 81, 77, 19, 0,0,0, /* HorScrollBar */
};
PrintDetails(toplevel,Expected);
};
LessTifTestMainLoop(toplevel);
exit(0);
}
int main ( int argc, char *argv[] )
{
XtAppContext app_con ;
Widget toplevel ;
Widget menu_widget ;
Widget opt_widget ;
Widget button ;
Arg arg[5] ;
Cardinal arg_num ;
int i ;
int val[] = { 0, 1, 2, 3, 4, 5 } ;
int j = 0 ;
char buffer[10] ;
toplevel = XtVaAppInitialize( &app_con,
NULL,
NULL, 0,
&argc, argv,
NULL,
NULL );
menu_widget = XmCreatePulldownMenu(
toplevel, "pulldown", NULL, 0 );
#if 0
/*
* if this callback is added, all subsequent callbacks get called too
*/
XtAddCallback( menu_widget, XmNentryCallback, entry_cb, &val[j++] );
#endif
arg_num = 0 ;
XtSetArg( arg[arg_num], XmNsubMenuId, menu_widget ); arg_num++ ;
opt_widget = XmCreateOptionMenu(
toplevel, "options", arg, arg_num );
#if 0
/*
* if this callback is added, all subsequent callbacks get called too
*/
XtAddCallback( menu_widget, XmNentryCallback, entry_cb, &val[j++] );
#endif
for ( i = 0 ; i < 5 ; i++ )
{
sprintf( buffer, "item%d", i );
button = XmCreatePushButtonGadget(
menu_widget, buffer, NULL, 0 );
XtManageChild( button );
}
XtAddCallback( menu_widget, XmNentryCallback, entry_cb, &val[j++] );
#if 1
/*
* if this button is created, lesstif doesn't call the entry callback
* for item0 .. item4, but calls it for item5
*/
sprintf( buffer, "item%d", i );
button = XmCreatePushButtonGadget(
menu_widget, buffer, NULL, 0 );
XtManageChild( button );
#endif
XtManageChild( opt_widget );
XtAddCallback( menu_widget, XmNentryCallback, entry_cb, &val[j++] );
XtRealizeWidget( toplevel );
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight, 0, 0, 80, 35, 0,0,0,
CWWidth | CWHeight | CWX | CWY, 3, 3, 4, 29, 0,0,0,
CWWidth | CWHeight | CWX | CWY, 10, 3, 67, 29, 0,0,0,
};
PrintDetails(toplevel, Expected);
}
LessTifTestMainLoop(toplevel);
/*
XtAppMainLoop( app_con );
*/
return 0;
}
void mpcstw_projCreate ( Widget parent )
/************************************************************************
* mpcstw_projCreate *
* *
* This function creates proj area *
* *
* void mpcstw_projCreate(parent) *
* *
* Input parameters: *
* parent Widget parent form widget ID *
* *
* Output parameters: *
* NULL *
* *
* Return parameters: *
* NULL *
* *
** *
* Log: *
* C. Lin/EAI 04/96 *
* S. Wang/GSC 09/96 Add others selections *
* S. Wang/GSC 10/96 Add DEF selection and content *
* G. Krueger/EAI 10/97 NxmFrameLabel->NxmLabel_createFrameLbl *
***********************************************************************/
{
int nn;
long ii;
Widget frame, rc0, rc, pane_fr;
Widget menu, rowcol;
XmString xmstr ;
Arg args[5] ;
/*---------------------------------------------------------------------*/
frame = XtVaCreateWidget("mpcstw_projFrame",
xmFrameWidgetClass, parent,
NULL);
pane_fr = XtVaCreateManagedWidget("mpcstw_projFrame",
xmPanedWindowWidgetClass, frame,
XmNsashWidth, 1,
XmNsashHeight, 1,
NULL);
NxmLabel_createFrameLbl("Projection", pane_fr, frame);
/*
* create a parent row column widget for projection selection
* panel
*/
rc0 = XtVaCreateWidget("rc",
xmRowColumnWidgetClass, pane_fr,
XmNorientation, XmVERTICAL,
NULL);
/*
* create GEMPAK PROJ input string area
*/
rc = XtVaCreateWidget("mpcstw_projGEMPAKRc",
xmRowColumnWidgetClass, rc0,
XmNorientation, XmHORIZONTAL,
NULL);
XtVaCreateManagedWidget("PROJ",
xmLabelGadgetClass, rc,
NULL);
_projTextW = XtVaCreateManagedWidget("txt",
xmTextFieldWidgetClass, rc,
XmNcolumns, 35,
XmNmarginHeight, 0,
NULL);
XtAddCallback(_projTextW, XmNactivateCallback,
(XtCallbackProc)mpcstw_textCb, (XtPointer)1);
XtManageChild(rc);
rc = XtVaCreateWidget("mpcstw_projRc",
xmRowColumnWidgetClass, rc0,
XmNorientation, XmVERTICAL,
XmNradioBehavior, True,
XmNspacing, 0,
NULL);
/*
* create default projection button and label
*/
rowcol = XtVaCreateManagedWidget( "orc",
xmRowColumnWidgetClass, rc,
XmNorientation, XmHORIZONTAL,
XmNradioBehavior, True,
XmNspacing, 60,
NULL );
_defaultBt = XtVaCreateManagedWidget( _projItem[0].name,
xmToggleButtonWidgetClass, rowcol,
XmNradioBehavior, True,
NULL );
XtAddCallback( _defaultBt, XmNarmCallback,
(XtCallbackProc)mpcstw_projDefaultCb,
(XtPointer)0 );
/*
* create default projection show content button
*/
_defaultConFrame = XtVaCreateManagedWidget("mpcstw_defFrame",
xmFrameWidgetClass, rowcol,
XmNshadowType, XmSHADOW_OUT,
XmNshadowThickness, 2,
NULL);
xmstr = XmStringCreateLocalized(" DEF Content ");
_defaultConLabel = XtVaCreateManagedWidget( "mpcstw_defLabel",
xmLabelWidgetClass, _defaultConFrame,
XmNlabelString, xmstr,
XmNrecomputeSize, False,
XmNheight, 4,
XmNwidth, 85,
NULL);
XmStringFree(xmstr);
XtAddEventHandler( _defaultConLabel,
ButtonReleaseMask, FALSE,
(XtEventHandler)mpcstw_defConCb,
(XtPointer)0);
/*
* create commonly used projection radio button group
*/
for ( ii = 1; ii < NAMEPROJSHOW; ii++ ) {
_toggleBt[ii] = XtVaCreateManagedWidget( _projItem[ii].name,
xmToggleButtonWidgetClass, rc,
XmNmarginHeight, 0,
NULL );
XtAddCallback( _toggleBt[ii], XmNarmCallback,
(XtCallbackProc)mpcstw_projToggleCb,
(XtPointer)ii );
}
XtManageChild(rc);
rowcol = XtVaCreateManagedWidget("orc",
xmRowColumnWidgetClass, rc,
XmNorientation, XmHORIZONTAL,
XmNradioBehavior, TRUE,
XmNpacking, XmPACK_TIGHT,
NULL);
_othersBt = XtVaCreateManagedWidget("Others:",
xmToggleButtonWidgetClass, rowcol,
NULL );
XtAddCallback(_othersBt, XmNarmCallback,
(XtCallbackProc)mpcstw_projOthersCb,
(XtPointer)NAMEPROJSHOW);
/*
* create other projection option menu
*/
menu = XmCreatePulldownMenu(rowcol, "mpcstw_projOptMenu", NULL, 0);
nn = 0;
xmstr = XmStringCreateLocalized("");
XtSetArg(args[nn], XmNsubMenuId, menu); nn++;
XtSetArg(args[nn], XmNlabelString, xmstr); nn++;
_projOption = XmCreateOptionMenu(rowcol, "mpcstw_projOpt", args, nn);
XmStringFree(xmstr);
for (ii = NAMEPROJSHOW; ii < (long)XtNumber(_projItem); ii++) {
_optButton[ii] = XtVaCreateManagedWidget(_projItem[ii].name,
xmPushButtonGadgetClass, menu,
NULL );
XtAddCallback(_optButton[ii], XmNactivateCallback,
(XtCallbackProc)mpcstw_projOptionCb,
(XtPointer)ii);
}
_projOptInx = NAMEPROJSHOW;
XtManageChild(_projOption);
XtManageChild(rc0);
XtManageChild(frame);
}
bool wxChoice::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name)
{
if ( !CreateControl(parent, id, pos, size, style, validator, name) )
return false;
PreCreation();
Widget parentWidget = (Widget) parent->GetClientWidget();
m_formWidget = (WXWidget) XtVaCreateManagedWidget(name.c_str(),
xmRowColumnWidgetClass, parentWidget,
XmNmarginHeight, 0,
XmNmarginWidth, 0,
XmNpacking, XmPACK_TIGHT,
XmNorientation, XmHORIZONTAL,
XmNresizeWidth, False,
XmNresizeHeight, False,
NULL);
XtVaSetValues ((Widget) m_formWidget, XmNspacing, 0, NULL);
/*
* Create the popup menu
*/
m_menuWidget = (WXWidget) XmCreatePulldownMenu ((Widget) m_formWidget,
wxMOTIF_STR("choiceMenu"),
NULL, 0);
if (n > 0)
{
int i;
for (i = 0; i < n; i++)
Append (choices[i]);
}
/*
* Create button
*/
Arg args[10];
Cardinal argcnt = 0;
XtSetArg (args[argcnt], XmNsubMenuId, (Widget) m_menuWidget); ++argcnt;
XtSetArg (args[argcnt], XmNmarginWidth, 0); ++argcnt;
XtSetArg (args[argcnt], XmNmarginHeight, 0); ++argcnt;
XtSetArg (args[argcnt], XmNpacking, XmPACK_TIGHT); ++argcnt;
m_buttonWidget = (WXWidget) XmCreateOptionMenu ((Widget) m_formWidget,
wxMOTIF_STR("choiceButton"),
args, argcnt);
m_mainWidget = m_buttonWidget;
XtManageChild ((Widget) m_buttonWidget);
// New code from Roland Haenel ([email protected])
// Some time ago, I reported a problem with wxChoice-items under
// Linux and Motif 2.0 (they caused sporadic GPFs). Now it seems
// that I have found the code responsible for this behaviour.
#if XmVersion >= 1002
#if XmVersion < 2000
// JACS, 24/1/99: this seems to cause a malloc crash later on, e.g.
// in controls sample.
//
// Widget optionLabel = XmOptionLabelGadget ((Widget) m_buttonWidget);
// XtUnmanageChild (optionLabel);
#endif
#endif
wxSize bestSize = GetBestSize();
if( size.x > 0 ) bestSize.x = size.x;
if( size.y > 0 ) bestSize.y = size.y;
XtVaSetValues((Widget) m_formWidget, XmNresizePolicy, XmRESIZE_NONE, NULL);
PostCreation();
AttachWidget (parent, m_buttonWidget, m_formWidget,
pos.x, pos.y, bestSize.x, bestSize.y);
return true;
}
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);
}
/*
* Function: _DtPrintCreateHdrFtrFrame
*
* Creates a frame for specifying the contents of page headers and footers.
* The frame contains four option menus, one for each _DtPrintHdrFtrEnum.
* The pulldown menus for the option menu are constructed from the .string
* field in the array of _DtPrintHdrFtrSpec in "specs".
*
* _DtPrintCreateHdrFtrFrame copies the pointer to the array of
* _DtPrintHdrFtrSpec. IT DOES NOT COPY THE ELEMENTS OF THE ARRAY.
*
* parent - specifies the parent of the frame.
* nspecs - specifies the number of entries in the specs array.
* specs - array of header/footer specifiers. The .string
* field is used to construct labels in the GUI.
* The .data field is returned in calls to
* _DtPrintGetHdrFtrSpec.
*
* Returns the widget id for the frame.
*/
Widget
_DtPrintCreateHdrFtrFrame(
Widget parent,
int nspecs,
char **spec_strings,
void **spec_data
)
{
DtpoHdrFtrFrame *info;
Arg args[16];
int n;
int i;
XmString xms;
info = (DtpoHdrFtrFrame *) XtMalloc( sizeof(DtpoHdrFtrFrame) );
info->nspecs = nspecs;
info->specs = (DtpoHdrFtrSpec *) XtMalloc(nspecs*sizeof(DtpoHdrFtrSpec));
for (i=0; i<nspecs; i++)
{
info->specs[i].string = spec_strings[i];
if (spec_data != (void*) NULL)
info->specs[i].data = spec_data[i];
else
info->specs[i].data = (void*) NULL;
info->specs[i].button = (Widget) NULL;
}
/*
* Create the frame and attach add a destroyCallback to clean up
* memory allocated for this object.
*/
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, "HdrFtrFrame", args, n);
XtAddCallback(
info->frame,
XmNdestroyCallback,
_DtPrintDestroyHdrFtrFrameCB,
(XtPointer) info
);
/*
* Create a label child for the frame
*/
xms = XmStringCreateLocalized(DTPO_HEADERFOOTER_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, "HdrFtrLabel", args, n);
XtManageChild(info->label);
XmStringFree(xms);
/*
* Create a form work area child which will be populated by the
* OptionMenu's.
*/
n = 0;
XtSetArg(args[n], XmNallowOverlap, False); n++;
XtSetArg(args[n], XmNfractionBase, 2); n++;
info->form = XmCreateForm(info->frame, "HdrFtrForm", args, n);
/*
* Create the pulldown menu for the option menus.
* Store the button index in the userData resource of each button.
*/
info->menu = XmCreatePulldownMenu(parent, "HdrFtrMenu", NULL, 0);
for (i=0; i<info->nspecs; i++)
{
static char button_label[32];
sprintf(button_label, "Button%d", i);
xms = XmStringCreateLocalized(info->specs[i].string);
n = 0;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNuserData, i); n++;
info->specs[i].button =
XmCreatePushButtonGadget(info->menu, button_label, args, n);
XmStringFree(xms);
XtManageChild(info->specs[i].button);
}
/*
* Create the option menus using the menu created above.
*/
xms = XmStringCreateLocalized(DTPO_HEADERFOOTER_FRAME_TOP_LEFT_LABEL);
n=0;
XtSetArg(args[n], XmNsubMenuId, info->menu); n++;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNuserData, info); n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
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_left = XmCreateOptionMenu(
info->form,
"PageHeaderLeftOM",
args, n
);
XmStringFree(xms);
XtManageChild(info->top_left);
xms = XmStringCreateLocalized(DTPO_HEADERFOOTER_FRAME_TOP_RIGHT_LABEL);
n=0;
XtSetArg(args[n], XmNsubMenuId, info->menu); n++;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNuserData, info); n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->top_left); n++;
XtSetArg(args[n], XmNtopOffset, 0); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
info->top_right = XmCreateOptionMenu(
info->form,
"PageHeaderRightOM",
args, n
);
XmStringFree(xms);
XtManageChild(info->top_right);
xms = XmStringCreateLocalized(DTPO_HEADERFOOTER_FRAME_BOTTOM_LEFT_LABEL);
n=0;
XtSetArg(args[n], XmNsubMenuId, info->menu); n++;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNuserData, info); n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->top_left); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, info->top_left); n++;
XtSetArg(args[n], XmNrightOffset, 0); n++;
info->bottom_left = XmCreateOptionMenu(
info->form,
"PageFooterLeftOM",
args, n
);
XmStringFree(xms);
XtManageChild(info->bottom_left);
xms = XmStringCreateLocalized(DTPO_HEADERFOOTER_FRAME_BOTTOM_RIGHT_LABEL);
n=0;
XtSetArg(args[n], XmNsubMenuId, info->menu); n++;
XtSetArg(args[n], XmNlabelString, xms); n++;
XtSetArg(args[n], XmNuserData, info); n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, info->bottom_left); 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->top_right); n++;
XtSetArg(args[n], XmNrightOffset, 0); n++;
info->bottom_right = XmCreateOptionMenu(
info->form,
"PageFooterRightOM",
args, n
);
XmStringFree(xms);
XtManageChild(info->bottom_right);
XtManageChild(info->form);
return info->frame;
}
Widget
CreateSpinBoxResourceControls( Widget parent, Widget top_widget,
Widget left_widget, Widget right_widget )
{
XmString string;
Widget SBResLabel, RowColumn;
Widget ArrowLayoutLabel, ArrowLayoutPulldown,
ArrowLayoutOptions,
ArrowLayoutPB[NUM_ARROW_LAYOUT_BTNS];
Widget ArrowSizeLabel, ArrowSizePulldown, ArrowSizeOptions,
ArrowSizePB[NUM_ARROW_SIZE_BTNS];
Widget DefArrowSensitiveLabel, DefArrowSensitivePulldown,
DefArrowSensitiveOptions,
DefArrowSensitivePB[NUM_DEF_ARROW_SENS_BTNS];
Widget InitialDelayLabel, InitialDelayTF;
Widget RepeatDelayLabel, RepeatDelayTF;
int i;
char buffer[30];
n = 0;
XtSetArg( args[n], XmNtopAttachment, XmATTACH_WIDGET ); n++;
XtSetArg( args[n], XmNtopWidget, top_widget ); n++;
XtSetArg( args[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
XtSetArg( args[n], XmNleftWidget, left_widget ); n++;
XtSetArg( args[n], XmNrightAttachment, XmATTACH_WIDGET ); n++;
XtSetArg( args[n], XmNrightWidget, right_widget ); n++;
XtSetArg(args[n], XmNnumColumns, 5); n++;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg(args[n], XmNpacking, XmPACK_COLUMN); n++;
RowColumn = XmCreateRowColumn( parent, "RowColumn", args, n );
XtManageChild( RowColumn );
/*
* Create label and option menu for XmNarrowLayout resource.
*/
string = XmStringCreateLtoR("Arrow Layout",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ArrowLayoutLabel = XmCreateLabel( RowColumn, "ArrowLayoutLabel",
args, n );
XtManageChild( ArrowLayoutLabel );
XmStringFree( string );
n = 0;
ArrowLayoutPulldown = XmCreatePulldownMenu(RowColumn,
"ArrowLayoutPulldown",
args, n);
for ( i = 0; i < NUM_ARROW_LAYOUT_BTNS; i++ )
{
string = XmStringCreateLtoR( arrow_layout_strings[i],
XmFONTLIST_DEFAULT_TAG );
sprintf( buffer, "ArrowLayoutPB%d", i );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ArrowLayoutPB[i] =
XmCreatePushButton( ArrowLayoutPulldown, buffer, args, n );
XmStringFree( string );
XtAddCallback( ArrowLayoutPB[i], XmNactivateCallback,
ArrowLayoutCB, (XtPointer)&arrow_layout[i] );
}
XtManageChildren( ArrowLayoutPB, NUM_ARROW_LAYOUT_BTNS );
n = 0;
XtSetArg( args[n], XmNmenuHistory,
ArrowLayoutPB[NUM_ARROW_LAYOUT_BTNS - 1] ); n++;
XtSetArg( args[n], XmNsubMenuId, ArrowLayoutPulldown ); n++;
ArrowLayoutOptions =
XmCreateOptionMenu( RowColumn, "ArrowLayoutOptions", args, n );
XtManageChild( ArrowLayoutOptions );
/*
* Create label and option menu for XmNarrowSize resource.
*/
string = XmStringCreateLtoR("Arrow Size",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ArrowSizeLabel = XmCreateLabel( RowColumn, "ArrowSizeLabel",
args, n );
XtManageChild( ArrowSizeLabel );
XmStringFree( string );
n = 0;
ArrowSizePulldown = XmCreatePulldownMenu(RowColumn,
"ArrowSizePulldown",
args, n);
for ( i = 0; i < NUM_ARROW_SIZE_BTNS; i++ )
{
string = XmStringCreateLtoR( arrow_size_strings[i],
XmFONTLIST_DEFAULT_TAG );
sprintf( buffer, "ArrowSizePB%d", i );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
ArrowSizePB[i] =
XmCreatePushButton( ArrowSizePulldown, buffer, args, n );
XmStringFree( string );
XtAddCallback( ArrowSizePB[i], XmNactivateCallback,
ArrowSizeCB, (XtPointer)arrow_size_strings[i] );
}
XtManageChildren( ArrowSizePB, NUM_ARROW_SIZE_BTNS );
n = 0;
XtSetArg( args[n], XmNmenuHistory, ArrowSizePB[0] ); n++;
XtSetArg( args[n], XmNsubMenuId, ArrowSizePulldown ); n++;
ArrowSizeOptions =
XmCreateOptionMenu( RowColumn, "ArrowSizeOptions", args, n );
XtManageChild( ArrowSizeOptions );
/*
* Create label and option menu for XmNdefaultArrowSensitivity resource.
*/
string = XmStringCreateLtoR("Default Arrow Sensitivity",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
DefArrowSensitiveLabel =
XmCreateLabel( RowColumn, "DefArrowSensitiveLabel", args, n );
XtManageChild( DefArrowSensitiveLabel );
XmStringFree( string );
n = 0;
DefArrowSensitivePulldown =
XmCreatePulldownMenu(RowColumn, "DefArrowSensitivePulldown",
args, n);
for ( i = 0; i < NUM_DEF_ARROW_SENS_BTNS; i++ )
{
string = XmStringCreateLtoR( def_arrow_sens_strings[i],
XmFONTLIST_DEFAULT_TAG );
sprintf( buffer, "DefArrowSensitivePB%d", i );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
DefArrowSensitivePB[i] =
XmCreatePushButton( DefArrowSensitivePulldown, buffer, args, n );
XmStringFree( string );
XtAddCallback( DefArrowSensitivePB[i], XmNactivateCallback,
DefArrowSensitiveCB, (XtPointer)&def_arrow_sens[i] );
}
XtManageChildren( DefArrowSensitivePB, NUM_DEF_ARROW_SENS_BTNS );
n = 0;
XtSetArg( args[n], XmNmenuHistory, DefArrowSensitivePB[0] ); n++;
XtSetArg( args[n], XmNsubMenuId, DefArrowSensitivePulldown ); n++;
DefArrowSensitiveOptions =
XmCreateOptionMenu( RowColumn, "DefArrowSensitiveOptions", args, n );
XtManageChild( DefArrowSensitiveOptions );
/*
* Create label and text field for XmNinitialDelay resource.
*/
string = XmStringCreateLtoR("Initial Delay",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
InitialDelayLabel =
XmCreateLabel( RowColumn, "InitialDelayLabel", args, n );
XtManageChild( InitialDelayLabel );
XmStringFree( string );
n = 0;
XtSetArg( args[n], XmNvalue, "250" ); n++;
InitialDelayTF =
XmCreateTextField( RowColumn, "InitialDelayTF", args, n );
XtManageChild( InitialDelayTF );
XtAddCallback( InitialDelayTF, XmNactivateCallback,
InitialDelayCB, (XtPointer)0 );
/*
* Create label and text field for XmNinitialDelay resource.
*/
string = XmStringCreateLtoR("Repeat Delay",
XmFONTLIST_DEFAULT_TAG );
n = 0;
XtSetArg( args[n], XmNlabelString, string ); n++;
RepeatDelayLabel =
XmCreateLabel( RowColumn, "RepeatDelayLabel", args, n );
XtManageChild( RepeatDelayLabel );
XmStringFree( string );
n = 0;
XtSetArg( args[n], XmNvalue, "200" ); n++;
RepeatDelayTF =
XmCreateTextField( RowColumn, "RepeatDelayTF", args, n );
XtManageChild( RepeatDelayTF );
XtAddCallback( RepeatDelayTF, XmNactivateCallback,
RepeatDelayCB, (XtPointer)0 );
return( RowColumn );
}
int
main(int argc, char **argv)
{
XtAppContext theApp;
Widget toplevel, rc;
Widget pane1;
Widget button1, button2;
Arg args[10];
int n;
toplevel = XtVaAppInitialize(&theApp, "rc-test7", NULL, 0,
&argc, argv, NULL,
XmNwidth, 120,
NULL);
pane1 = XmCreatePulldownMenu(toplevel,
"pulldown",
NULL, 0);
button1 = XtVaCreateManagedWidget("button1",
xmPushButtonWidgetClass,
pane1,
NULL);
button2 = XtVaCreateManagedWidget("button2",
xmPushButtonWidgetClass,
pane1,
NULL);
n = 0;
XtSetArg(args[n], XmNsubMenuId, pane1); n++;
XtSetArg(args[n], XmNlabelString, XmStringCreateLocalized("Option:")); n++;
rc = XmCreateOptionMenu(toplevel,
"option",
args, n);
XtAddCallback(button1, XmNactivateCallback, pb_activate_callback, NULL);
XtAddCallback(button2, XmNactivateCallback, pb_activate_callback, NULL);
XtAddCallback(button1, XmNarmCallback, pb_arm_callback, NULL);
XtAddCallback(button2, XmNarmCallback, pb_arm_callback, NULL);
XtManageChild(rc);
XtRealizeWidget(toplevel);
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight, 0, 0, 134, 35, 0,0,0,
CWWidth | CWHeight | CWX | CWY, 3, 3, 46, 29, 0,0,0,
CWWidth | CWHeight | CWX | CWY, 52, 3, 79, 29, 0,0,0,
};
PrintDetails(toplevel, Expected);
}
LessTifTestMainLoop(toplevel);
/*
XtAppMainLoop(theApp);
*/
exit(0);
}
Widget XNavMotif::build_menu( Widget Parent,
int MenuType,
const char *MenuTitle,
void *MenuUserData,
void (*Callback)( Widget, XNav *, XmAnyCallbackStruct *),
void *CallbackData,
xmenu_sMenuItem *Items,
int *idx)
{
Widget Menu, Cascade, W;
int i;
unsigned int Level;
XmString Str;
WidgetClass Class;
Arg ArgList[5];
XmFontList fontlist;
XFontStruct *font;
XmFontListEntry fontentry;
// Set default fontlist
font = XLoadQueryFont( flow_Display(Parent),
"-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
fontlist = XmFontListAppendEntry( NULL, fontentry);
XtFree( (char *)fontentry);
i = 0;
XtSetArg(ArgList[i], XmNuserData, MenuUserData); i++;
XtSetArg(ArgList[i], XmNbuttonFontList, fontlist); i++;
XtSetArg(ArgList[i], XmNlabelFontList, fontlist); i++;
if (MenuType == MENU_PULLDOWN || MenuType == MENU_OPTION)
Menu = XmCreatePulldownMenu(Parent, (char*) "_pulldown", ArgList, i);
else if (MenuType == MENU_POPUP)
Menu = XmCreatePopupMenu(Parent, (char*) "_popup", ArgList, i);
else {
XtWarning("Invalid menu type passed to BuildMenu().");
return NULL;
}
if (MenuType == MENU_PULLDOWN) {
Str = XmStringCreateSimple((char*) MenuTitle);
Cascade = XtVaCreateManagedWidget(MenuTitle,
xmCascadeButtonGadgetClass, Parent,
XmNsubMenuId, Menu,
XmNlabelString, Str,
NULL);
XmStringFree(Str);
}
else if (MenuType == MENU_OPTION) {
Str = XmStringCreateSimple((char*) MenuTitle);
XtSetArg(ArgList[0], XmNsubMenuId, Menu);
XtSetArg(ArgList[1], XmNlabelString, Str);
Cascade = XmCreateOptionMenu(Parent, (char*) MenuTitle, ArgList, 2);
XmStringFree(Str);
}
XmFontListFree( fontlist);
Level = Items[*idx].Level;
for (; Items[*idx].Level != 0 && Items[*idx].Level >= Level; (*idx)++) {
if (Items[*idx].Item == xmenu_eMenuItem_Cascade ||
Items[*idx].Item == xmenu_eMenuItem_Ref) {
if (MenuType == MENU_OPTION) {
XtWarning("You can't have submenus from option menu items.");
return NULL;
}
else {
i = *idx;
(*idx)++;
build_menu(Menu, MENU_PULLDOWN,
Lng::translate( Items[i].Name), MenuUserData,
Callback, CallbackData, Items, idx);
(*idx)--;
}
}
else {
if (Items[*idx].Item == xmenu_eMenuItem_Separator)
Class = xmSeparatorGadgetClass;
else
Class = xmPushButtonGadgetClass;
W = XtVaCreateManagedWidget(Lng::translate( Items[*idx].Name),
Class, Menu,
XmNuserData, *idx,
XmNsensitive, (Boolean)(Items[*idx].Flags.f.Sensitive == 1),
NULL);
if (Callback && Class == xmPushButtonGadgetClass)
XtAddCallback(W, XmNactivateCallback, (XtCallbackProc) Callback,
(XtPointer) CallbackData);
}
}
return MenuType == MENU_POPUP ? Menu : Cascade;
}
/*
* Returns pointer to an ASCII character string that contains the name of the
* selected font (in X format for naming fonts); it is the users responsibility
* to free the space allocated to this string.
*/
char_u *
gui_xm_select_font(char_u *current)
{
static SharedFontSelData _data;
Widget parent;
Widget form;
Widget separator;
Widget sub_form;
Widget size_toggle;
Widget name;
Widget disp_frame;
Widget frame;
Arg args[64];
int n;
XmString str;
char big_font[MAX_FONT_NAME_LEN];
SharedFontSelData *data;
data = &_data;
parent = vimShell;
data->names = XListFonts(XtDisplay(parent), "-*-*-*-*-*-*-*-*-*-*-*-*-*-*",
MAX_FONTS, &data->num);
/*
* Find the name of the biggest font less than the given limit
* MAX_DISPLAY_SIZE used to set up the initial height of the display
* widget.
*/
{
int i;
int max;
int index = 0;
int size;
char str[128];
for (i = 0, max = 0; i < data->num; i++)
{
get_part(fn(data, i), 7, str);
size = atoi(str);
if ((size > max) && (size < MAX_DISPLAY_SIZE))
{
index = i;
max = size;
}
}
strcpy(big_font, fn(data, index));
}
data->old = XLoadQueryFont(XtDisplay(parent), big_font);
data->old_list = gui_motif_create_fontlist(data->old);
/* Set the title of the Dialog window. */
data->dialog = XmCreateDialogShell(parent, "fontSelector", NULL, 0);
str = XmStringCreateLocalized(_("Vim - Font Selector"));
/* Create form popup dialog widget. */
form = XtVaCreateWidget("form",
xmFormWidgetClass, data->dialog,
XmNdialogTitle, str,
XmNautoUnmanage, False,
XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL,
NULL);
XmStringFree(str);
sub_form = XtVaCreateManagedWidget("subForm",
xmFormWidgetClass, form,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 4,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 4,
XmNorientation, XmVERTICAL,
NULL);
data->ok = XtVaCreateManagedWidget(_("OK"),
xmPushButtonGadgetClass, sub_form,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 4,
NULL);
apply_fontlist(data->ok);
data->cancel = XtVaCreateManagedWidget(_("Cancel"),
xmPushButtonGadgetClass, sub_form,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, data->ok,
XmNtopOffset, 4,
XmNshowAsDefault, True,
NULL);
apply_fontlist(data->cancel);
/* Create the separator for beauty. */
n = 0;
XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNrightWidget, sub_form); n++;
XtSetArg(args[n], XmNrightOffset, 4); n++;
separator = XmCreateSeparatorGadget(form, "separator", args, n);
XtManageChild(separator);
/* Create font name text widget and the corresponding label. */
data->name = XtVaCreateManagedWidget("fontName",
xmTextWidgetClass, form,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 4,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, separator,
XmNrightOffset, 4,
XmNeditable, False,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNmaxLength, MAX_FONT_NAME_LEN,
XmNcolumns, 60,
NULL);
str = XmStringCreateLocalized(_("Name:"));
name = XtVaCreateManagedWidget("fontNameLabel",
xmLabelGadgetClass, form,
XmNlabelString, str,
XmNuserData, data->name,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, data->name,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, data->name,
XmNtopOffset, 1,
NULL);
XmStringFree(str);
apply_fontlist(name);
/* create sample display label widget */
disp_frame = XtVaCreateManagedWidget("sampleFrame",
xmFrameWidgetClass, form,
XmNshadowType, XmSHADOW_ETCHED_IN,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 4,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, name,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, separator,
XmNrightOffset, 4,
XmNalignment, XmALIGNMENT_BEGINNING,
NULL);
data->sample = XtVaCreateManagedWidget("sampleLabel",
xmLabelWidgetClass, disp_frame,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNalignment, XmALIGNMENT_BEGINNING,
XmNrecomputeSize, False,
XmNfontList, data->old_list,
NULL);
/* create toggle button */
str = XmStringCreateLocalized(_("Show size in Points"));
size_toggle = XtVaCreateManagedWidget("sizeToggle",
xmToggleButtonGadgetClass, form,
XmNlabelString, str,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 4,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, disp_frame,
XmNbottomOffset, 4,
NULL);
XmStringFree(str);
apply_fontlist(size_toggle);
XtManageChild(size_toggle);
/* Encoding pulldown menu.
*/
data->encoding_pulldown = XmCreatePulldownMenu(form,
"encodingPulldown", NULL, 0);
str = XmStringCreateLocalized(_("Encoding:"));
n = 0;
XtSetArg(args[n], XmNsubMenuId, data->encoding_pulldown); ++n;
XtSetArg(args[n], XmNlabelString, str); ++n;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); ++n;
XtSetArg(args[n], XmNleftOffset, 4); ++n;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); ++n;
XtSetArg(args[n], XmNbottomWidget, size_toggle); ++n;
XtSetArg(args[n], XmNbottomOffset, 4); ++n;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); ++n;
XtSetArg(args[n], XmNrightWidget, separator); ++n;
XtSetArg(args[n], XmNrightOffset, 4); ++n;
data->encoding_menu = XmCreateOptionMenu(form, "encodingMenu", args, n);
XmStringFree(str);
XmAddTabGroup(data->encoding_menu);
/*
* Create scroll list widgets in a separate subform used to manage the
* different sizes of the lists.
*/
sub_form = XtVaCreateManagedWidget("subForm",
xmFormWidgetClass, form,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, data->encoding_menu,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 4,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, separator,
XmNrightOffset, 4,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 2,
XmNorientation, XmVERTICAL,
NULL);
/* font list */
frame = XtVaCreateManagedWidget("frame", xmFrameWidgetClass, sub_form,
XmNshadowThickness, 0,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 50,
NULL);
str = XmStringCreateLocalized(_("Font:"));
name = XtVaCreateManagedWidget("nameListLabel", xmLabelGadgetClass, frame,
XmNchildType, XmFRAME_TITLE_CHILD,
XmNchildVerticalAlignment, XmALIGNMENT_CENTER,
XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING,
XmNlabelString, str,
NULL);
XmStringFree(str);
apply_fontlist(name);
n = 0;
XtSetArg(args[n], XmNvisibleItemCount, 8); ++n;
XtSetArg(args[n], XmNresizable, True); ++n;
XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); ++n;
XtSetArg(args[n], XmNvisualPolicy, XmVARIABLE); ++n;
#ifdef LESSTIF_VERSION
XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC); ++n;
#endif
data->list[NAME] = XmCreateScrolledList(frame, "fontList", args, n);
XtVaSetValues(name, XmNuserData, data->list[NAME], NULL);
/* style list */
frame = XtVaCreateManagedWidget("frame", xmFrameWidgetClass, sub_form,
XmNshadowThickness, 0,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 50,
XmNleftOffset, 4,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 80,
NULL);
str = XmStringCreateLocalized(_("Style:"));
name = XtVaCreateManagedWidget("styleListLabel", xmLabelWidgetClass, frame,
XmNchildType, XmFRAME_TITLE_CHILD,
XmNchildVerticalAlignment, XmALIGNMENT_CENTER,
XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING,
XmNlabelString, str,
NULL);
XmStringFree(str);
apply_fontlist(name);
n = 0;
XtSetArg(args[n], XmNvisibleItemCount, 8); ++n;
XtSetArg(args[n], XmNresizable, True); ++n;
XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); ++n;
XtSetArg(args[n], XmNvisualPolicy, XmVARIABLE); ++n;
#ifdef LESSTIF_VERSION
XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC); ++n;
#endif
data->list[STYLE] = XmCreateScrolledList(frame, "styleList", args, n);
XtVaSetValues(name, XmNuserData, data->list[STYLE], NULL);
/* size list */
frame = XtVaCreateManagedWidget("frame", xmFrameWidgetClass, sub_form,
XmNshadowThickness, 0,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 80,
XmNleftOffset, 4,
XmNrightAttachment, XmATTACH_FORM,
NULL);
str = XmStringCreateLocalized(_("Size:"));
name = XtVaCreateManagedWidget("sizeListLabel", xmLabelGadgetClass, frame,
XmNchildType, XmFRAME_TITLE_CHILD,
XmNchildVerticalAlignment, XmALIGNMENT_CENTER,
XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING,
XmNlabelString, str,
NULL);
XmStringFree(str);
apply_fontlist(name);
n = 0;
XtSetArg(args[n], XmNvisibleItemCount, 8); ++n;
XtSetArg(args[n], XmNresizable, True); ++n;
XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); ++n;
XtSetArg(args[n], XmNvisualPolicy, XmVARIABLE); ++n;
#ifdef LESSTIF_VERSION
XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC); ++n;
#endif
data->list[SIZE] = XmCreateScrolledList(frame, "sizeList", args, n);
XtVaSetValues(name, XmNuserData, data->list[SIZE], NULL);
/* update form widgets cancel button */
XtVaSetValues(form, XmNcancelButton, data->cancel, NULL);
XtAddCallback(size_toggle, XmNvalueChangedCallback,
(XtCallbackProc)stoggle_callback, (XtPointer)data);
XtAddCallback(data->list[NAME], XmNbrowseSelectionCallback,
(XtCallbackProc)name_callback, (XtPointer)data);
XtAddCallback(data->list[STYLE], XmNbrowseSelectionCallback,
(XtCallbackProc)style_callback, (XtPointer)data);
XtAddCallback(data->list[SIZE], XmNbrowseSelectionCallback,
(XtCallbackProc)size_callback, (XtPointer)data);
XtAddCallback(data->ok, XmNactivateCallback,
(XtCallbackProc)ok_callback, (XtPointer)data);
XtAddCallback(data->cancel, XmNactivateCallback,
(XtCallbackProc)cancel_callback, (XtPointer)data);
XmProcessTraversal(data->list[NAME], XmTRAVERSE_CURRENT);
/* setup tabgroups */
XmAddTabGroup(data->list[NAME]);
XmAddTabGroup(data->list[STYLE]);
XmAddTabGroup(data->list[SIZE]);
XmAddTabGroup(size_toggle);
XmAddTabGroup(data->name);
XmAddTabGroup(data->ok);
XmAddTabGroup(data->cancel);
add_cancel_action(data->dialog, (XtCallbackProc)cancel_callback, data);
/* Preset selection data. */
data->exit = False;
data->in_pixels= True;
data->sel[ENCODING] = NULL;
data->sel[NAME] = NULL;
data->sel[STYLE] = NULL;
data->sel[SIZE] = NULL;
data->font_name = NULL;
/* set up current font parameters */
if (current && current[0] != '\0')
{
int i;
char **names;
names = XListFonts(XtDisplay(form), (char *) current, 1, &i);
if (i != 0)
{
char name[TEMP_BUF_SIZE];
char style[TEMP_BUF_SIZE];
char size[TEMP_BUF_SIZE];
char encoding[TEMP_BUF_SIZE];
char *found;
found = names[0];
name_part(found, name);
style_part(found, style);
size_part(found, size, data->in_pixels);
encoding_part(found, encoding);
if (strlen(name) > 0
&& strlen(style) > 0
&& strlen(size) > 0
&& strlen(encoding) > 0)
{
data->sel[NAME] = XtNewString(name);
data->sel[STYLE] = XtNewString(style);
data->sel[SIZE] = XtNewString(size);
data->sel[ENCODING] = XtNewString(encoding);
data->font_name = XtNewString(names[0]);
display_sample(data);
XmTextSetString(data->name, data->font_name);
}
else
{
/* We can't preset a symbolic name, which isn't a full font
* description. Therefore we just behave the same way as if the
* user didn't have selected anything thus far.
*
* Unfortunately there is no known way to expand an abbreviated
* font name.
*/
data->font_name = NULL;
}
}
XFreeFontNames(names);
}
fill_lists(NONE, data);
/* Unfortunately LessTif doesn't align the list widget's properly. I don't
* have currently any idea how to fix this problem.
*/
XtManageChild(data->list[NAME]);
XtManageChild(data->list[STYLE]);
XtManageChild(data->list[SIZE]);
XtManageChild(data->encoding_menu);
manage_centered(form);
/* modal event loop */
while (!data->exit)
XtAppProcessEvent(XtWidgetToApplicationContext(data->dialog),
(XtInputMask)XtIMAll);
XtDestroyWidget(data->dialog);
if (data->old)
{
XFreeFont(XtDisplay(data->dialog), data->old);
XmFontListFree(data->old_list);
}
gui_motif_synch_fonts();
return (char_u *) data->font_name;
}
void scrnInitX(void)
{
Widget toplevel, control;
Widget mb, fileMenu, viewMenu, confMenu, helpMenu;
Widget procFrame = NULL, bboxFrame = NULL;
#ifdef ICON_DEFINED
Pixmap icon;
#endif
XmString s;
Arg args[10];
unsigned i, n;
int argc = 0;
addRegwRsrcOpts();
addDatwRsrcOpts();
toplevel = XtAppInitialize(&app_context, "XSki",
options, topopts, &argc, NULL,
NULL, NULL, 0);
top_level = toplevel; /* XXX - temporary for Platform only */
XtGetApplicationResources(toplevel, &app_data,
resources, toprsrc, NULL, 0);
XtAppAddActions(app_context, actions, XtNumber(actions));
dpy = XtDisplay(toplevel);
#ifdef ICON_DEFINED
/* set default icon */
icon = XCreateBitmapFromData(dpy, RootWindowOfScreen(XtScreen(toplevel)),
icon_bits, icon_width, icon_height);
XtSetArg(args[0], XmNiconPixmap, icon);
XtSetValues(toplevel, args, 1);
#endif
#if 0
XSynchronize(dpy, True);
#endif
/* create control window manager */
control = XmCreateForm(toplevel, "control", NULL, 0);
XtManageChild(control);
/* Control window menubar */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
mb = XmCreateMenuBar(control, "mb", args, n);
XtManageChild(mb);
fileMenu = createMBitem(mb, "File");
viewMenu = createMBitem(mb, "View");
confMenu = createMBitem(mb, "Configure");
helpMenu = createMBitem(mb, "Help");
#if 0
createSubmenuItem(fileMenu, "load", loadCallback);
#else
createSubmenuItem(fileMenu, "load", 0);
#endif
createSubmenuItem(fileMenu, "save", 0);
createSubmenuItem(fileMenu, "trace", 0);
createSubmenuItem(fileMenu, "traceOn", 0);
createSubmenuItem(fileMenu, "traceOff", 0);
createSubmenuItem(fileMenu, "read", 0);
XtManageChild(XmCreateSeparatorGadget(fileMenu, "", NULL, 0));
createSubmenuItem(fileMenu, "quit", simCmdCallback);
createSubmenuItem(viewMenu, "program", programCallback);
createSubmenuItem(viewMenu, "data", dataCallback);
createSubmenuItem(viewMenu, "registers", regCallback);
createSubmenuItem(viewMenu, "cache", 0);
createSubmenuItem(viewMenu, "tlb", sdtCallback);
XtManageChild(XmCreateSeparatorGadget(viewMenu, "", NULL, 0));
createSubmenuItem(viewMenu, "callstack", cstCallback);
createSubmenuItem(viewMenu, "statistics", 0);
createSubmenuItem(viewMenu, "breakpoints", blistCallback);
createSubmenuItem(viewMenu, "branches", 0);
createSubmenuItem(viewMenu, "symbols", symlistCallback);
createSubmenuItem(viewMenu, "macros", 0);
#if 0
/* No support for window format yet */
createSubmenuItem(confMenu, "program", prgFmtCallback);
#else
createSubmenuItem(confMenu, "program", 0);
#endif
createSubmenuItem(confMenu, "data", 0);
#if 0
/* No support for window format yet */
createSubmenuItem(confMenu, "registers", regFmtCallback);
#else
createSubmenuItem(confMenu, "registers", 0);
#endif
createSubmenuItem(helpMenu, "context", 0);
createSubmenuItem(helpMenu, "overview", 0);
createSubmenuItem(helpMenu, "commands", cmdHelpCallback);
createSubmenuItem(helpMenu, "product", prodInfoCallback);
/* Control window processor option menu */
if (nproc > 1) {
Widget procMenu, proc[NPROC];
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
procFrame = XmCreateFrame(control, "", args, n);
XtManageChild(procFrame);
procMenu = XmCreatePulldownMenu(procFrame, "", NULL, 0);
for (i = 0; i < nproc; i++) {
char name[4];
(void)sprintf(name, "p%d", i);
proc[i] = XmCreatePushButton(procMenu, name, NULL, 0);
XtAddCallback(proc[i], XmNactivateCallback,
changeCprocCallback, (XtPointer)i);
}
XtManageChildren(proc, nproc);
n = 0;
XtSetArg(args[n], XmNsubMenuId, procMenu); n++;
XtManageChild(XmCreateOptionMenu(procFrame, "procOption", args, n));
}
/* Control window button box */
if (app_data.numButtons) {
Widget bbox, btns[20];
/* create button box manager */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, procFrame ? procFrame : mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
bboxFrame = XmCreateFrame(control, "", args, n);
XtManageChild(bboxFrame);
/* create button box window */
bbox = XmCreateRowColumn(bboxFrame, "bbox", NULL, 0);
XtManageChild(bbox);
/* create each button */
for (i = 0; i < app_data.numButtons; i++) {
char name[8];
(void)sprintf(name, "bb%d", i);
btns[i] = XmCreatePushButton(bbox, name, NULL, 0);
}
XtManageChildren(btns, app_data.numButtons);
}
/* Control window command area */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget,
bboxFrame ? bboxFrame : procFrame ? procFrame : mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
cmd = XmCreateCommand(control, "cmd", args, n);
XtManageChild(cmd);
XtAddCallback(cmd, XmNcommandEnteredCallback, simCmdCallback, 0);
/* command history box */
n = 0;
XtSetArg(args[0], XmNinitialFocus, cmd); n++;
XtSetValues(control, args, n);
cmdHist = XmCommandGetChild(cmd, XmDIALOG_HISTORY_LIST);
/* message window */
msgs = XmCreateScrolledText(control, "msgs", NULL, 0);
XtManageChild(msgs);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, cmd); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetValues(XtParent(msgs), args, n);
/* create stop simulation dialog */
/* Consider changing this to a button. This would allow other
functionality to still be active when simulation is going on.
For example, Help, Quit, opening and closing windows, etc. */
stopsim = XmCreateWorkingDialog(control, "stopsim", NULL, 0);
n = 0;
XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
s = XmStringCreateLocalized("Running...");
XtSetArg(args[n], XmNdialogTitle, s); n++;
s = XmStringCreateLocalized(" icnt: 0 ");
XtSetArg(args[n], XmNmessageString, s); n++;
s = XmStringCreateLocalized("Stop");
XtSetArg(args[n], XmNcancelLabelString, s); n++;
XtSetValues(stopsim, args, n);
XtAddCallback(stopsim, XmNcancelCallback, stop_execLoopXCB, NULL);
XtUnmanageChild(XmMessageBoxGetChild(stopsim, XmDIALOG_OK_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(stopsim, XmDIALOG_HELP_BUTTON));
XmStringFree(s);
/* XXX - This should probably be inside regwInit */
for (i = 0; i < topregw; i++)
regwtbl[i].show = app_data.showRs[i];
/* XXX - This should probably be inside datwInit */
for (i = 0; i < topdatw; i++)
datwtbl[i].show = app_data.viewDw[i];
prgwInit();
datwInit();
regwInit();
if (app_data.viewProg)
prgwDrawX();
datwDrawX();
if (app_data.viewRegs)
regwDrawX();
noscreen = NO;
XtRealizeWidget(toplevel);
}
Widget CreateMenu ( MenuType menuType,
char *name,
Widget parent,
MenuDescription *desc,
XtPointer defaultClientData )
{
Widget w;
/*
* Create the basic menu widget, based on the type of
* menu requested. Do any special setup required
* and then call CreateMenuChildren() to populate the menu.
*/
switch ( menuType )
{
case POPUP:
/*
* Popups must have an event handler registered with the
* parent to display the menu when button 3 is pressed.
*/
w = XmCreatePopupMenu ( parent, name, NULL, 0 );
AttachPopup ( parent, w );
CreateMenuChildren ( w, desc, defaultClientData );
return ( w );
case MENUBAR:
/*
* For menu bars, just create the menu bar, and then
* add children. All direct children are expected
* to be pulldown menus.
*/
w = XmCreateMenuBar ( parent, name, NULL, 0 );
CreateMenuChildren ( w, desc, defaultClientData );
XtManageChild ( w );
return ( w );
case OPTION:
{
/*
* All option menus have a pulldown, but it is nicer to hide
* this, allowing the programmer to just specify the contents
* of the pane. So, create the option menu, create and attach
* a pulldown pane, and then call CreateMenuChildren() to
* populate the pulldown menu pane.
*/
Widget option = XmCreateOptionMenu ( parent, name, NULL, 0 );
w = XmCreatePulldownMenu ( parent, name, NULL, 0 );
XtVaSetValues ( option, XmNsubMenuId, w, NULL );
CreateMenuChildren ( w, desc, defaultClientData );
XtManageChild ( option );
return ( option );
}
default:
XtError ( "Invalid Menu Type" );
return ( NULL );
}
}
Widget XmCreateOptionMenu_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateOptionMenu(parent, name, arglist, argcount);}
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);
}
