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); }