static Widget CreateMainWindowWithMenuBar(Widget toplevel) { Widget main_window, menu_bar, menu_pane, cascade, button ; Arg args[20]; Cardinal n; /* Create MainWindow. */ n = 0; main_window = XmCreateMainWindow (toplevel, "main_window", args, n); XtManageChild (main_window); /* Create MenuBar in MainWindow. */ n = 0; menu_bar = XmCreateMenuBar (main_window, "menu_bar", args, n); XtManageChild (menu_bar); /* Create "File" PulldownMenu. */ n = 0; menu_pane = XmCreatePulldownMenu (menu_bar, "menu_pane", args, n); n = 0; button = XmCreatePushButton (menu_pane, "Exit", args, n); XtManageChild (button); XtAddCallback (button, XmNactivateCallback, QuitCB, NULL); n = 0; XtSetArg (args[n], XmNsubMenuId, menu_pane); n++; cascade = XmCreateCascadeButton (menu_bar, "File", args, n); XtManageChild (cascade); /* Create "Help" PulldownMenu. */ n = 0; menu_pane = XmCreatePulldownMenu (menu_bar, "menu_pane3", args, n); n = 0; button = XmCreatePushButton (menu_pane, "Overview", args, n); XtManageChild (button); XtAddCallback (button, XmNactivateCallback, HelpCB, NULL); n = 0; XtSetArg (args[n], XmNsubMenuId, menu_pane); n++; cascade = XmCreateCascadeButton (menu_bar, "Help", args, n); XtManageChild (cascade); n = 0; XtSetArg (args[n], XmNmenuHelpWidget, cascade); n++; XtSetValues (menu_bar, args, n); return main_window ; }
/** * Create the mb3dsdg_mainWindow hierarchy of widgets. */ Widget Createmb3dsdg_mainWindow(Widget parent) { Cardinal ac = 0; Arg args[256]; Cardinal cdc = 0; Boolean argok = False; Widget mb3dsdg_mainWindow; Widget mb3dsdg_dialogShell; static Mb3dsdgData mb3dsdg; /** * Register the converters for the widgets. */ RegisterBxConverters(XtWidgetToApplicationContext(parent)); XtInitializeWidgetClass((WidgetClass)xmMainWindowWidgetClass); XtInitializeWidgetClass((WidgetClass)xmDialogShellWidgetClass); XtInitializeWidgetClass((WidgetClass)xmFormWidgetClass); ac = 0; XtSetArg(args[ac], XmNx, 747); ac++; XtSetArg(args[ac], XmNy, 78); ac++; XtSetArg(args[ac], XmNwidth, 197); ac++; XtSetArg(args[ac], XmNheight, 104); ac++; mb3dsdg_mainWindow = XmCreateMainWindow(parent, (char *)"mb3dsdg_mainWindow", args, ac); XtAddCallback(mb3dsdg_mainWindow, XmNdestroyCallback, BxExitCB, (XtPointer)0); ac = 0; XtSetArg(args[ac], XmNwidth, 1011); ac++; XtSetArg(args[ac], XmNheight, 660); ac++; XtSetArg(args[ac], XmNdeleteResponse, XmDO_NOTHING); ac++; mb3dsdg_dialogShell = XmCreateDialogShell(mb3dsdg_mainWindow, (char *)"mb3dsdg_dialogShell", args, ac); Mb3dsdgCreate(&(mb3dsdg), mb3dsdg_dialogShell, "mb3dsdg", args, ac); ac = 0; XtSetArg(args[ac], XmNx, 0); ac++; XtSetArg(args[ac], XmNy, 1007); ac++; XtSetArg(args[ac], XmNwidth, 1011); ac++; XtSetArg(args[ac], XmNheight, 660); ac++; XtSetValues(mb3dsdg.Mb3dsdg, args, ac); /* Begin user code block <end_Createmb3dsdg_mainWindow> */ /* End user code block <end_Createmb3dsdg_mainWindow> */ return( mb3dsdg_mainWindow ); }
/** * Create the mbpingedit_window hierarchy of widgets. */ Widget Creatembpingedit_window(Widget parent) { Cardinal ac = 0; Arg args[256]; Cardinal cdc = 0; Boolean argok = False; Widget mbpingedit_dialogShell; static MBpeditData mBpedit; /** * Register the converters for the widgets. */ RegisterBxConverters(XtWidgetToApplicationContext(parent)); XtInitializeWidgetClass((WidgetClass)xmMainWindowWidgetClass); XtInitializeWidgetClass((WidgetClass)xmDialogShellWidgetClass); XtInitializeWidgetClass((WidgetClass)xmFormWidgetClass); ac = 0; XtSetArg(args[ac], XmNx, 135); ac++; XtSetArg(args[ac], XmNy, 180); ac++; XtSetArg(args[ac], XmNwidth, 143); ac++; XtSetArg(args[ac], XmNheight, 52); ac++; mbpingedit_window = XmCreateMainWindow(parent, (char *)"mbpingedit_window", args, ac); ac = 0; XtSetArg(args[ac], XmNtitle, "MBeditviz Swath View"); ac++; XtSetArg(args[ac], XmNwidth, 1004); ac++; XtSetArg(args[ac], XmNheight, 694); ac++; XtSetArg(args[ac], XmNdeleteResponse, XmDO_NOTHING); ac++; mbpingedit_dialogShell = XmCreateDialogShell(mbpingedit_window, (char *)"mbpingedit_dialogShell", args, ac); MBpeditCreate(&(mBpedit), mbpingedit_dialogShell, "mBpedit", args, ac); ac = 0; XtSetArg(args[ac], XmNx, 518); ac++; XtSetArg(args[ac], XmNy, 310); ac++; XtSetArg(args[ac], XmNwidth, 1004); ac++; XtSetArg(args[ac], XmNheight, 694); ac++; XtSetValues(mBpedit.MBpedit, args, ac); /* Begin user code block <end_Creatembpingedit_window> */ /* End user code block <end_Creatembpingedit_window> */ return( mbpingedit_window ); }
static void CreateAnotherContainer() { Widget PopupShell; Widget MainW2, menubar2, pulldown2, menu_btn2; Widget CutPB2, CopyPB2, CopyLinkPB2, PastePB2, PasteLinkPB2; Widget OtherContainer4; Widget IconGad6, IconGad7, IconGad8, IconGad9, IconGad10; Cardinal n; XmString Label; Arg args[MAX_ARGS]; /* * Create a Dialog Shell */ n = 0; XtSetArg(args[n], XtNgeometry, "=375x375+400+300"); n++; XtSetArg(args[n], XtNallowShellResize, True); n++; PopupShell = XtCreatePopupShell("OtherContainer", topLevelShellWidgetClass, Shell1, args, n); /* * Create a main window */ n = 0; XtSetArg(args[n], XmNborderWidth, 2); n++; MainW2 = XmCreateMainWindow(PopupShell, "MainW2", args, n); XtManageChild(MainW2); /* * Create a menu bar with a pulldown menu for interacting with the * clipboard */ n = 0; menubar2 = XmCreateMenuBar(MainW2, "menubar2", args, n); XtManageChild(menubar2); n = 0; pulldown2 = XmCreatePulldownMenu(menubar2, "pulldown2", args, n); Label = XmStringCreate("Edit", XmSTRING_DEFAULT_CHARSET); n = 0; XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNsubMenuId, pulldown2); n++; menu_btn2 = XmCreateCascadeButton(menubar2, "menu_btn2", args, n); XtManageChild(menu_btn2); XmStringFree(Label); n = 0; Label = XmStringCreate("Cut", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; CutPB2 = XmCreatePushButtonGadget(pulldown2, "CutPB2", args, n); XtManageChild(CutPB2); XmStringFree(Label); n = 0; Label = XmStringCreate("Copy", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; CopyPB2 = XmCreatePushButtonGadget(pulldown2, "CopyPB2", args, n); XtManageChild(CopyPB2); XmStringFree(Label); n = 0; Label = XmStringCreate("Copy Link", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; CopyLinkPB2 = XmCreatePushButtonGadget(pulldown2, "CopyLinkPB2", args, n); XtManageChild(CopyLinkPB2); XmStringFree(Label); n = 0; Label = XmStringCreate("Paste", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; PastePB2 = XmCreatePushButtonGadget(pulldown2, "PastePB2", args, n); XtManageChild(PastePB2); XmStringFree(Label); n = 0; Label = XmStringCreate("Paste Link", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; PasteLinkPB2= XmCreatePushButtonGadget(pulldown2, "PasteLinkPB2", args, n); XtManageChild(PasteLinkPB2); XmStringFree(Label); /* * Create the container */ n = 0; XtSetArg(args[n], XmNwidth, 450); n++; XtSetArg(args[n], XmNheight, 450); n++; XtSetArg(args[n], XmNentryViewType, XmANY_ICON); n++; XtSetArg(args[n], XmNlayoutType, XmSPATIAL); n++; XtSetArg(args[n], XmNspatialStyle, XmNONE); n++; XtSetArg(args[n], XmNautomaticSelection, XmNO_AUTO_SELECT); n++; OtherContainer4 = XmCreateContainer(MainW2, "OtherContainer", args, n); XtManageChild(OtherContainer4); XtAddCallback(OtherContainer4, XmNconvertCallback, ConvertCB, NULL); XtAddCallback(OtherContainer4, XmNdestinationCallback, DestinationCB, NULL); XtAddCallback(CutPB2, XmNactivateCallback, CutCB, (XtPointer) OtherContainer4); XtAddCallback(CopyPB2, XmNactivateCallback, CopyCB, (XtPointer) OtherContainer4); XtAddCallback(CopyLinkPB2, XmNactivateCallback, CopyLinkCB, (XtPointer) OtherContainer4); XtAddCallback(PastePB2, XmNactivateCallback, PasteCB, (XtPointer) OtherContainer4); XtAddCallback(PasteLinkPB2, XmNactivateCallback, PasteLinkCB, (XtPointer) OtherContainer4); n = 0; XtSetArg(args[n], XmNx, 50); n++; XtSetArg(args[n], XmNy, 50); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; IconGad6 = XmCreateIconGadget(OtherContainer4, "IconGad6", args, n); XtManageChild(IconGad6); n = 0; XtSetArg(args[n], XmNx, 150); n++; XtSetArg(args[n], XmNy, 150); n++; XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++; IconGad7 = XmCreateIconGadget(OtherContainer4, "IconGad7", args, n); XtManageChild(IconGad7); n = 0; XtSetArg(args[n], XmNx, 50); n++; XtSetArg(args[n], XmNy, 300); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; IconGad8 = XmCreateIconGadget(OtherContainer4, "IconGad8", args, n); XtManageChild(IconGad8); n = 0; XtSetArg(args[n], XmNx, 300); n++; XtSetArg(args[n], XmNy, 300); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; IconGad9 = XmCreateIconGadget(OtherContainer4, "IconGad9", args, n); XtManageChild(IconGad9); n = 0; XtSetArg(args[n], XmNx, 200); n++; XtSetArg(args[n], XmNy, 50); n++; XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++; IconGad10 = XmCreateIconGadget(OtherContainer4, "IconGad10", args, n); XtManageChild(IconGad10); XmMainWindowSetAreas(MainW2, menubar2, NULL, NULL, NULL, OtherContainer4); XtPopup(PopupShell, XtGrabNone); }
void main(int argc, char **argv) { int i,j; Cardinal n; XmString Label; Arg args[MAX_ARGS]; int test_num; char test_char; char ContainerName[NAME_LEN + 1]; ContainerName[0] = '\0'; test_num = 0; test_char = '\0'; CommonTestInit(argc, argv); if (UserData != NULL) { if (strcmp(UserData, "a") == 0) test_num = 1; else if (strcmp(UserData, "b") == 0) test_num = 2; else if (strcmp(UserData, "c") == 0) test_num = 3; else if (strcmp(UserData, "d") == 0) test_num = 4; test_char = *UserData; free(UserData); } sprintf(ContainerName, "Container4%c", test_char); /* * Create a main window */ n = 0; XtSetArg(args[n], XmNborderWidth, 2); n++; MainW1 = XmCreateMainWindow(Shell1, "MainW1", args, n); XtManageChild(MainW1); /* * Create a menu bar with a pulldown menu for interacting with the * clipboard */ n = 0; menubar1 = XmCreateMenuBar(MainW1, "menubar1", args, n); XtManageChild(menubar1); n = 0; pulldown1 = XmCreatePulldownMenu(menubar1, "pulldown1", args, n); Label = XmStringCreate("Edit", XmSTRING_DEFAULT_CHARSET); n = 0; XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNsubMenuId, pulldown1); n++; menu_btn1 = XmCreateCascadeButton(menubar1, "menu_btn1", args, n); XtManageChild(menu_btn1); XmStringFree(Label); n = 0; Label = XmStringCreate("Cut", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; CutPB1 = XmCreatePushButtonGadget(pulldown1, "CutPB1", args, n); XtManageChild(CutPB1); XmStringFree(Label); n = 0; Label = XmStringCreate("Copy", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; CopyPB1 = XmCreatePushButtonGadget(pulldown1, "CopyPB1", args, n); XtManageChild(CopyPB1); XmStringFree(Label); n = 0; Label = XmStringCreate("Copy Link", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; CopyLinkPB1 = XmCreatePushButtonGadget(pulldown1, "CopyLinkPB1", args, n); XtManageChild(CopyLinkPB1); XmStringFree(Label); n = 0; Label = XmStringCreate("Paste", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; PastePB1 = XmCreatePushButtonGadget(pulldown1, "PastePB1", args, n); XtManageChild(PastePB1); XmStringFree(Label); n = 0; Label = XmStringCreate("Paste Link", XmSTRING_DEFAULT_CHARSET); XtSetArg(args[n], XmNlabelString, Label); n++; XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++; PasteLinkPB1= XmCreatePushButtonGadget(pulldown1, "PasteLinkPB1", args, n); XtManageChild(PasteLinkPB1); XmStringFree(Label); /* * Create the container */ ColumnHeadings = (XmStringTable) XtMalloc(NUM_COL * sizeof(XmString)); for (i = 0; i < NUM_COL; i++) ColumnHeadings[i] = XmStringGenerate(ColumnHeadingText[i], NULL, XmCHARSET_TEXT, NULL); n = 0; XtSetArg(args[n], XmNdetailColumnHeading, ColumnHeadings); n++; XtSetArg(args[n], XmNdetailColumnHeadingCount, NUM_COL); n++; XtSetArg(args[n], XmNdetailOrderCount, NUM_COL-1); n++; Container4 = XmCreateContainer(MainW1, ContainerName, args, n); XtManageChild(Container4); XtAddCallback(Container4, XmNdefaultActionCallback, PrintChildrenCB, NULL); XtAddCallback(Container4, XmNconvertCallback, ConvertCB, NULL); XtAddCallback(Container4, XmNdestinationCallback, DestinationCB, NULL); XtAddCallback(CutPB1, XmNactivateCallback, CutCB, (XtPointer) Container4); XtAddCallback(CopyPB1, XmNactivateCallback, CopyCB, (XtPointer)Container4); XtAddCallback(CopyLinkPB1, XmNactivateCallback, CopyLinkCB, (XtPointer) Container4); XtAddCallback(PastePB1, XmNactivateCallback, PasteCB, (XtPointer) Container4); XtAddCallback(PasteLinkPB1, XmNactivateCallback, PasteLinkCB, (XtPointer) Container4); for (i=0; i<NUM_COL; i++) XmStringFree(ColumnHeadings[i]); XtFree((XtPointer) ColumnHeadings); EntryDetails = (XmStringTable *) XtMalloc(NUM_OBJ * sizeof(XmStringTable)); for (i = 0; i < NUM_OBJ; i++) { ColumnHeadings = (XmStringTable)XtMalloc((NUM_COL-1) * sizeof(XmString)); ColumnHeadings[0] = XmStringGenerate(FullTitleText[i], NULL, XmCHARSET_TEXT, NULL); ColumnHeadings[1] = XmStringGenerate(FlavorText[i], NULL, XmCHARSET_TEXT, NULL); ColumnHeadings[2] = XmStringGenerate(AgeText[i], NULL, XmCHARSET_TEXT, NULL); EntryDetails[i] = ColumnHeadings; } n = 0; XtSetArg(args[n], XmNx, 100); n++; XtSetArg(args[n], XmNy, 100); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[0]); n++; IconGad1 = XmCreateIconGadget(Container4, "IconGad1", args, n); XtManageChild(IconGad1); n = 0; XtSetArg(args[n], XmNx, 200); n++; XtSetArg(args[n], XmNy, 200); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[1]); n++; IconGad2 = XmCreateIconGadget(Container4, "IconGad2", args, n); XtManageChild(IconGad2); n = 0; XtSetArg(args[n], XmNx, 300); n++; XtSetArg(args[n], XmNy, 100); n++; XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[2]); n++; IconGad3 = XmCreateIconGadget(Container4, "IconGad3", args, n); XtManageChild(IconGad3); n = 0; XtSetArg(args[n], XmNx, 50); n++; XtSetArg(args[n], XmNy, 400); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[3]); n++; IconGad4 = XmCreateIconGadget(Container4, "IconGad4", args, n); XtManageChild(IconGad4); n = 0; XtSetArg(args[n], XmNentryParent, IconGad3); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetail, EntryDetails[4]); n++; IconGad31 = XmCreateIconGadget(Container4, "IconGad31", args, n); XtManageChild(IconGad31); n = 0; XtSetArg(args[n], XmNentryParent, IconGad3); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[5]); n++; IconGad32 = XmCreateIconGadget(Container4, "IconGad32", args, n); XtManageChild(IconGad32); n = 0; XtSetArg(args[n], XmNentryParent, IconGad32); n++; XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[6]); n++; IconGad321 = XmCreateIconGadget(Container4, "IconGad321", args, n); XtManageChild(IconGad321); n = 0; XtSetArg(args[n], XmNentryParent, IconGad321); n++; XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[7]); n++; IconGad3211 = XmCreateIconGadget(Container4, "IconGad3211", args, n); XtManageChild(IconGad3211); n = 0; XtSetArg(args[n], XmNentryParent, IconGad3); n++; XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[8]); n++; IconGad33 = XmCreateIconGadget(Container4, "IconGad33", args, n); XtManageChild(IconGad33); n = 0; XtSetArg(args[n], XmNx, 70); n++; XtSetArg(args[n], XmNy, 420); n++; XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[9]); n++; IconGad5 = XmCreateIconGadget(Container4, "IconGad5", args, n); XtManageChild(IconGad5); XmMainWindowSetAreas(MainW1, menubar1, NULL, NULL, NULL, Container4); for (i = 0; i < NUM_OBJ; i++) { ColumnHeadings = EntryDetails[i]; for (j = 0; j < NUM_COL-1; j++) XmStringFree(ColumnHeadings[j]); XtFree((XtPointer)ColumnHeadings); } XtFree((XtPointer)EntryDetails); XtRealizeWidget(Shell1); CommonPause(); CommonPause(); XmContainerRelayout(Container4); CommonPause(); if ((test_num == 1) || (test_num == 2)) { TestContainerReorder(); CommonPause(); } /* * Create another Container for UTM testing */ CreateAnotherContainer(); CommonPause(); CommonPause(); CommonPause(); CommonPause(); CommonPause(); CommonPause(); CommonPause(); CommonPause(); XtAppMainLoop(app_context); }
static PlotWindowInfo *new_decoration(const string& name) { PlotWindowInfo *plot = 0; // Check whether we can reuse an existing decoration for (int i = 0; i < plot_infos.size(); i++) { PlotWindowInfo *info = (PlotWindowInfo *)plot_infos[i]; if (info->plotter == 0) { // Shell is unused - use this one plot = info; break; } } if (plot == 0) { plot = new PlotWindowInfo; // Create decoration windows Arg args[10]; Cardinal arg = 0; XtSetArg(args[arg], XmNallowShellResize, True); arg++; XtSetArg(args[arg], XmNdeleteResponse, XmDO_NOTHING); arg++; // Mark shell as `used' XtSetArg(args[arg], XmNuserData, XtPointer(True)); arg++; plot->shell = verify(XtCreateWidget("plot", topLevelShellWidgetClass, find_shell(), args, arg)); AddDeleteWindowCallback(plot->shell, CancelPlotCB, XtPointer(plot)); arg = 0; Widget main_window = XmCreateMainWindow(plot->shell, XMST("main_window"), args, arg); XtManageChild(main_window); MMcreateMenuBar(main_window, "menubar", menubar); MMaddCallbacks(file_menu, XtPointer(plot)); MMaddCallbacks(simple_edit_menu); MMaddCallbacks(view_menu, XtPointer(plot)); MMaddCallbacks(plot_menu, XtPointer(plot)); MMaddCallbacks(scale_menu, XtPointer(plot)); MMaddCallbacks(contour_menu, XtPointer(plot)); MMaddCallbacks(simple_help_menu); MMaddHelpCallback(menubar, ImmediateHelpCB); arg = 0; XtSetArg(args[arg], XmNscrollingPolicy, XmAPPLICATION_DEFINED); arg++; XtSetArg(args[arg], XmNvisualPolicy, XmVARIABLE); arg++; Widget scroll = XmCreateScrolledWindow(main_window, XMST("scroll"), args, arg); XtManageChild(scroll); // Create work window Widget work; string plot_term_type = downcase(app_data.plot_term_type); if (plot_term_type.contains("xlib", 0)) { // xlib type - create plot area to draw plot commands arg = 0; work = XmCreateDrawingArea(scroll, XMST(PLOT_AREA_NAME), args, arg); XtManageChild(work); plot->area = new PlotArea(work, make_font(app_data, FixedWidthDDDFont)); XtVaSetValues(work, XmNuserData, XtPointer(plot->area), XtPointer(0)); } else if (plot_term_type.contains("x11", 0)) { // x11 type - swallow Gnuplot window arg = 0; work = plot->swallower = XtCreateManagedWidget(SWALLOWER_NAME, swallowerWidgetClass, scroll, args, arg); } else { // Unknown terminal type post_error("Unknown plot terminal type " + quote(app_data.plot_term_type), "unknown_plot_term_type_error"); return 0; } // Create scroll bars const int slider_size = 20; arg = 0; XtSetArg(args[arg], XmNorientation, XmHORIZONTAL); arg++; XtSetArg(args[arg], XmNminimum, 0); arg++; XtSetArg(args[arg], XmNmaximum, 360 + slider_size); arg++; plot->hsb = XmCreateScrollBar(scroll, XMST("hsb"), args, arg); XtManageChild(plot->hsb); arg = 0; XtSetArg(args[arg], XmNorientation, XmVERTICAL); arg++; XtSetArg(args[arg], XmNminimum, 0); arg++; XtSetArg(args[arg], XmNmaximum, 180 + slider_size); arg++; plot->vsb = XmCreateScrollBar(scroll, XMST("vsb"), args, arg); XtManageChild(plot->vsb); XtAddCallback(plot->hsb, XmNvalueChangedCallback, SetViewCB, XtPointer(plot)); XtAddCallback(plot->vsb, XmNvalueChangedCallback, SetViewCB, XtPointer(plot)); #if 0 XtAddCallback(plot->hsb, XmNdragCallback, SetViewCB, XtPointer(plot)); XtAddCallback(plot->vsb, XmNdragCallback, SetViewCB, XtPointer(plot)); #endif XmScrolledWindowSetAreas(scroll, plot->hsb, plot->vsb, work); Delay::register_shell(plot->shell); InstallButtonTips(plot->shell); plot_infos += plot; } string title = DDD_NAME ": " + name; XtVaSetValues(plot->shell, XmNtitle, title.chars(), XmNiconName, title.chars(), XtPointer(0)); if (plot->swallower != 0) { XtRemoveAllCallbacks(plot->swallower, XtNwindowCreatedCallback); XtAddCallback(plot->swallower, XtNwindowCreatedCallback, SwallowCB, XtPointer(plot)); XtRemoveAllCallbacks(plot->swallower, XtNwindowGoneCallback); XtAddCallback(plot->swallower, XtNwindowGoneCallback, SwallowAgainCB, XtPointer(plot)); if (plot->swallow_timer != 0) XtRemoveTimeOut(plot->swallow_timer); plot->swallow_timer = XtAppAddTimeOut(XtWidgetToApplicationContext(plot->swallower), app_data.plot_window_delay, SwallowTimeOutCB, XtPointer(plot)); } plot->active = false; return plot; }
/*+++++++++++++++++++++++++++++++++++++++++++++*/ static void build_mainWindow( Widget shell ) { int count, n, n2; Arg args[MAX_ARGS]; Widget WidgList[10]; Widget frame; Widget mainMenu; Widget mainRC; Widget filePulldown; Widget helpPulldown; Widget exitBtn; char *mnemonic; char *tmpStr; Pixmap pixmap; XmString labelString; Pixmap ditherPix; XmPixelSet pixelSet[XmCO_NUM_COLORS]; Pixel bg; short a,i,p,s; /* saveRestore * Note that save.poscnt has been initialized elsewhere. * save.posArgs may contain information from restoreAudio().*/ XtSetArg(save.posArgs[save.poscnt], XmNnoResize, True); save.poscnt++; XtSetArg(save.posArgs[save.poscnt], XmNresizePolicy, XmRESIZE_NONE); save.poscnt++; style.mainWindow= XmCreateMainWindow(shell,"mainWindow", save.posArgs, save.poscnt); XtAddCallback(style.mainWindow, XmNhelpCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_MAIN_WINDOW); n = 0; tmpStr = (char *)XtMalloc(strlen(GETMESSAGE(4, 1, "Style Manager"))+1); sprintf(tmpStr, GETMESSAGE(4, 1, "Style Manager")); XtSetArg(args[n], XmNtitle, tmpStr); n++; XtSetArg(args[n], XmNiconName, (char *)GETMESSAGE(4, 37, "Style")); n++; XtSetValues(XtParent(style.mainWindow), args, n); XtFree(tmpStr); n = 0; mainMenu= XmCreateMenuBar(style.mainWindow,"mainMenu", args, n); XtAddCallback(mainMenu, XmNhelpCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_MENUBAR); XtManageChild(mainMenu); /* create the pulldown widgets */ n = 0; filePulldown= XmCreatePulldownMenu(mainMenu,"fileMenu", args, n ); XtAddCallback(filePulldown, XmNhelpCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_FILE_MENU); n = 0; helpPulldown= XmCreatePulldownMenu(mainMenu, "helpMenu" , args, n ); XtAddCallback(helpPulldown, XmNhelpCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_HELP_MENU); /* create the cascade butons */ count = 0; n = 0; mnemonic = ((char *)GETMESSAGE(4, 2, "F")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 3, "File")); XtSetArg(args[n], XmNlabelString, labelString); n++; XtSetArg(args[n], XmNsubMenuId, filePulldown); n++; XtSetArg (args[n], XmNmarginWidth, LB_MARGIN_WIDTH); n++; WidgList[count++]= XmCreateCascadeButton(mainMenu, "fileCascadeButton", args, n ); XtAddCallback(WidgList[count-1], XmNhelpCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_FILE_MENU); XmStringFree(labelString); n = 0; mnemonic = ((char *)GETMESSAGE(4, 4, "H")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 5, "Help")); XtSetArg(args[n], XmNlabelString, labelString); n++; XtSetArg(args[n], XmNsubMenuId, helpPulldown); n++; XtSetArg (args[n], XmNmarginWidth, 6); n++; WidgList[count++]= XmCreateCascadeButton(mainMenu, "helpCascadeButton", args, n ); XtAddCallback(WidgList[count-1], XmNhelpCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_HELP_MENU); XmStringFree(labelString); n = 0; XtSetArg(args[n], XmNmenuHelpWidget, WidgList[count-1]); n++; XtSetValues (mainMenu, args, n); XtManageChildren (WidgList, count); /* create the File menu pane's buttons */ n = 0; mnemonic = ((char *)GETMESSAGE(4, 53, "x")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 7, "Exit")); XtSetArg(args[n], XmNlabelString, labelString); n++; exitBtn= XmCreatePushButton(filePulldown, "exit", args, n ); XtAddCallback(exitBtn, XmNactivateCallback, activateCB_exitBtn, NULL); XtAddCallback(exitBtn, XmNhelpCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_EXIT); XtManageChild(exitBtn); XmStringFree(labelString); /* create the Help menu pane's buttons */ count =0; n = 0; mnemonic = ((char *)GETMESSAGE(4, 54, "v")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 55, "Overview")); XtSetArg(args[n], XmNlabelString, labelString); n++; WidgList[count++]= XmCreatePushButton(helpPulldown, "overview", args, n ); XtAddCallback(WidgList[count-1], XmNactivateCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_INTRODUCTION); XmStringFree(labelString); n = 0; WidgList[count++]= XmCreateSeparatorGadget(helpPulldown,"separator",args,n); n = 0; mnemonic = ((char *)GETMESSAGE(4, 43, "T")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 56, "Tasks")); XtSetArg(args[n], XmNlabelString, labelString); n++; WidgList[count++]= XmCreatePushButton(helpPulldown, "tasks", args, n ); XtAddCallback(WidgList[count-1], XmNactivateCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TASKS); XmStringFree(labelString); n = 0; mnemonic = ((char *)GETMESSAGE(4, 45, "R")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 57, "Reference")); XtSetArg(args[n], XmNlabelString, labelString); n++; WidgList[count++]= XmCreatePushButton(helpPulldown, "reference", args, n ); XtAddCallback(WidgList[count-1], XmNactivateCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_REFERENCE); XmStringFree(labelString); n = 0; mnemonic = ((char *)GETMESSAGE(4, 47, "O")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 48, "On Item")); XtSetArg(args[n], XmNlabelString, labelString); n++; WidgList[count++]= XmCreatePushButton(helpPulldown, "onItem", args, n ); XtAddCallback(WidgList[count-1], XmNactivateCallback, (XtCallbackProc)HelpModeCB, (XtPointer)NULL); XmStringFree(labelString); n = 0; WidgList[count++] = XmCreateSeparatorGadget(helpPulldown,"separator",args,n); n = 0; mnemonic = ((char *)GETMESSAGE(4, 49, "U")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 58, "Using Help")); XtSetArg(args[n], XmNlabelString, labelString); n++; WidgList[count++]= XmCreatePushButton(helpPulldown, "usingHelp", args, n ); XtAddCallback(WidgList[count-1], XmNactivateCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_USING); XmStringFree(labelString); n = 0; WidgList[count++] = XmCreateSeparatorGadget(helpPulldown,"separator",args,n); n = 0; mnemonic = ((char *)GETMESSAGE(4, 59, "A")); XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++; labelString = CMPSTR((char *)GETMESSAGE(4, 60, "About Style Manager")); XtSetArg(args[n], XmNlabelString, labelString); n++; WidgList[count++]= XmCreatePushButton(helpPulldown, "stylemanager", args, n ); XtAddCallback(WidgList[count-1], XmNactivateCallback, (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_VERSION); XmStringFree(labelString); XtManageChildren(WidgList, count); /* create frame and row column for icon gadgets */ n = 0; XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++; XtSetArg(args[n], XmNshadowType, XmSHADOW_OUT); n++; XtSetArg(args[n], XmNshadowThickness, 1); n++; frame = XmCreateFrame(style.mainWindow, "frame", args, n); XtManageChild(frame); /* Save pixels for later use */ /* primary top/bottom shadow -> fg/bg for pixmaps in primary areas */ /* secondary top/bottom shadow -> fg/bg for pixmaps in secondary areas */ /* secondary select color -> backgrounds of editable text areas */ /* secondary foreground -> fill color on toggle indicators */ /* Get the primary colors to be used later */ n = 0; XtSetArg(args[n], XmNbackground, &bg); n++; XtGetValues(style.mainWindow, args, n); XmGetColors (style.screen, style.colormap, bg, NULL, &style.primTSCol, &style.primBSCol, NULL); /* Get the secondary colors to be used later */ n = 0; XtSetArg(args[n], XmNbackground, &style.secBgCol); n++; XtGetValues(exitBtn, args, n); XmGetColors (style.screen, style.colormap, style.secBgCol, &style.tgSelectColor, &style.secTSCol, &style.secBSCol, &style.secSelectColor); if ((style.secTSCol == style.secBSCol) || /* B_W or shadowPixmaps==True */ (!style.useMultiColorIcons)) /* multiColorIcons turned off */ { /* force TS = White, BS = Black */ style.secTSCol = style.primTSCol = WhitePixelOfScreen(style.screen); style.secBSCol = style.primBSCol = BlackPixelOfScreen(style.screen); } XmeGetPixelData(style.screenNum, &colorUse, pixelSet, &a, &i, &p, &s); n = 0; if (colorUse == XmCO_BLACK_WHITE) { ditherPix = XmGetPixmap (style.screen, "50_foreground", style.primBSCol,style.primTSCol); XtSetArg(args[n], XmNbackgroundPixmap, ditherPix); n++; } XtSetArg(args[n], XmNallowOverlap, False); n++; XtSetArg(args[n], XmNadjustLast, False); n++; XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++; XtSetArg(args[n], XmNspacing, style.horizontalSpacing); n++; mainRC = XmCreateRowColumn(frame, "mainRC", args, n); XtManageChild(mainRC); n = 0; XtSetArg(args[n], XmNmenuBar, mainMenu); n++; XtSetArg(args[n], XmNcommandWindow, NULL); n++; XtSetArg(args[n], XmNworkWindow, frame); n++; XtSetValues (style.mainWindow, args, n); ProcessComponentList (shell, mainRC); }
main(int argc, char *argv[]) { int i; exename= argv[0]; if (argc>1) { /* Check for command line arguments */ i= 1; while ((--argc > 0) && (argv[i][0]=='-')) { int c= argv[i][1]; switch (c) { case 'a': automanage= 1; fprintf(stderr,"%s: Windows will be automanaged.\n",argv[0]); break; default: fprintf(stderr,"%s: illegal option %c\n",argv[0],c); fprintf(stderr,"usage: %s [-a]\n",argv[0]); argc= 0; break; } i++; } } if (!automanage) { Arg args[16]; Widget toplevel, main_window, menu_bar, menu_pane, button; Widget draw_form; XmString title_string; int width=300, height=300; i = 0; toplevel = XtInitialize("p3d", "xpainter", NULL, 0, &i, NULL); i= 0; main_window= XmCreateMainWindow(toplevel, "main_window", args, i); i= 0; menu_bar= XmCreateMenuBar(main_window, "menu_bar", args, i); XtManageChild(menu_bar); i= 0; menu_pane= XmCreatePulldownMenu(menu_bar, "menu_pane", args, i); title_string= XmStringCreateSimple("File"); i= 0; XtSetArg(args[i], XmNsubMenuId, menu_pane); i++; XtSetArg(args[i], XmNlabelString, title_string); i++; button= XmCreateCascadeButton(menu_bar,"file",args,i); if (title_string) XmStringFree(title_string); XtManageChild(button); title_string= XmStringCreateSimple("Show"); i= 0; XtSetArg(args[i], XmNlabelString, title_string); i++; button= XmCreatePushButtonGadget(menu_pane,"show",args,i); XtAddCallback(button,XmNactivateCallback,show_cb,NULL); if (title_string) XmStringFree(title_string); XtManageChild(button); title_string= XmStringCreateSimple("Exit"); i= 0; XtSetArg(args[i], XmNlabelString, title_string); i++; button= XmCreatePushButtonGadget(menu_pane,"exit",args,i); XtAddCallback(button,XmNactivateCallback,exit_cb,NULL); if (title_string) XmStringFree(title_string); XtManageChild(button); i= 0; draw_form= XmCreateForm(main_window,"draw_form", args, i); XtManageChild(draw_form); i = 0; XtSetArg(args[i], XtNwidth, width); i++; XtSetArg(args[i], XtNheight, height); i++; XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM); i++; XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM); i++; XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM); i++; #ifdef USE_OPENGL XtSetArg(args[i], GLwNrgba, TRUE); i++; XtSetArg(args[i], GLwNdoublebuffer, TRUE); i++; XtSetArg(args[i], GLwNdepthSize, 16); i++; XtSetArg(args[i], GLwNallocateBackground, TRUE); i++; XtSetArg(args[i], GLwNinstallBackground, TRUE); i++; drawa= GLwCreateMDrawingArea(draw_form, "spina", args, i); #else XtSetArg(args[i], GlxNglxConfig, glxconfig); i++; drawa= GlxCreateMDraw(draw_form, "spina", args, i); #endif XtManageChild(drawa); i = 0; XtSetArg(args[i], XtNwidth, width); i++; XtSetArg(args[i], XtNheight, height); i++; XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM); i++; XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM); i++; XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET); i++; XtSetArg(args[i], XmNleftWidget, drawa); i++; XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM); i++; #ifdef USE_OPENGL XtSetArg(args[i], GLwNrgba, TRUE); i++; XtSetArg(args[i], GLwNdoublebuffer, TRUE); i++; XtSetArg(args[i], GLwNdepthSize, 16); i++; XtSetArg(args[i], GLwNallocateBackground, TRUE); i++; XtSetArg(args[i], GLwNinstallBackground, TRUE); i++; drawb= GLwCreateMDrawingArea(draw_form, "spinb", args, i); #else XtSetArg(args[i], GlxNglxConfig, glxconfig); i++; drawb= GlxCreateMDraw(draw_form, "spinb", args, i); #endif XtManageChild(drawb); XtManageChild(main_window); XtRealizeWidget(toplevel); } else { /* automanage renderers */ dp_init_ren("myrena", "gl","", "title=\"Ren A\",size=\"256x256+200+200\""); dp_init_ren("myrenb", "gl","", "title=\"Ren B\",size=\"300x400+500+500\""); fprintf(stderr, "%s: renderer initialized\n",exename); dp_print_ren("myrena"); dp_print_ren("myrenb"); rens_initialized= 1; build_geom(); } if (!automanage) { XtMainLoop(); } else { fprintf(stderr, "%s: about to render\n",exename); for (i=0; i<180; i++) make_new_snaps(); finish_and_shutdown(); } }
void main(int argc, char *argv[]) { int i; #ifdef IRIX_5_1_MOTIF_BUG_WORKAROUND /* * XXX Unfortunately a bug in the IRIX 5.1 Motif shared library * causes a BadMatch X protocol error if the SGI look&feel * is enabled for this program. If we detect we are on an * IRIX 5.1 system, skip the first two fallback resources which * specify using the SGI look&feel. */ struct utsname versionInfo; if(uname(&versionInfo) >= 0) { if(!strcmp(versionInfo.sysname, "IRIX") && !strncmp(versionInfo.release, "5.1", 3)) { toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv, &fallbackResources[2], NULL, 0); } } if(toplevel == NULL) { toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv, fallbackResources, NULL, 0); } #else toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv, fallbackResources, NULL, 0); #endif dpy = XtDisplay(toplevel); /* find an OpenGL-capable RGB visual with depth buffer */ vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf); if (vi == NULL) { vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf); if (vi == NULL) XtAppError(app, "no RGB visual with depth buffer"); doubleBuffer = GL_FALSE; } for (i = 0; i < NUM_FONT_ENTRIES; i++) { fontEntry[i].xfont = XLoadQueryFont(dpy, fontEntry[i].xlfd); if (i == 0 && !fontEntry[i].xfont) XtAppError(app, "could not get basic font"); } fontEntry[0].fontinfo = SuckGlyphsFromServer(dpy, fontEntry[0].xfont->fid); if (!fontEntry[0].fontinfo) XtAppError(app, "could not get font glyphs"); /* create an OpenGL rendering context */ cx = glXCreateContext(dpy, vi, /* no display list sharing */ None, /* favor direct */ GL_TRUE); if (cx == NULL) XtAppError(app, "could not create rendering context"); /* create an X colormap since probably not using default visual */ cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), vi->visual, AllocNone); XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth, XtNcolormap, cmap, NULL); XtAddEventHandler(toplevel, StructureNotifyMask, False, map_state_changed, NULL); mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0); XtManageChild(mainw); /* create menu bar */ menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0); XtManageChild(menubar); /* hack around Xt's ignorance of visuals */ XtSetArg(menuPaneArgs[0], XmNdepth, DefaultDepthOfScreen(XtScreen(mainw))); XtSetArg(menuPaneArgs[1], XmNcolormap, DefaultColormapOfScreen(XtScreen(mainw))); /* create File pulldown menu: Quit */ menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 2); btn = XmCreatePushButton(menupane, "Quit", NULL, 0); XtAddCallback(btn, XmNactivateCallback, quit, NULL); XtManageChild(btn); XtSetArg(args[0], XmNsubMenuId, menupane); cascade = XmCreateCascadeButton(menubar, "File", args, 1); XtManageChild(cascade); /* create Options pulldown menu: Motion, Dolly, Rotate, Wobble */ menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 2); btn = XmCreateToggleButton(menupane, "Motion", NULL, 0); XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) toggle, NULL); XtManageChild(btn); btn = XmCreateToggleButton(menupane, "Dolly", NULL, 0); XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) dolly, NULL); XtVaSetValues(btn, XmNset, True, NULL); XtManageChild(btn); btn = XmCreateToggleButton(menupane, "Rotate", NULL, 0); XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) rotate, NULL); XtManageChild(btn); btn = XmCreateToggleButton(menupane, "Wobble", NULL, 0); XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) wobble, NULL); XtManageChild(btn); XtSetArg(args[0], XmNsubMenuId, menupane); cascade = XmCreateCascadeButton(menubar, "Options", args, 1); XtManageChild(cascade); XtSetArg(menuPaneArgs[2], XmNradioBehavior, True); XtSetArg(menuPaneArgs[3], XmNradioAlwaysOne, True); menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 4); XtAddCallback(menupane, XmNentryCallback, (XtCallbackProc) fontSelect, NULL); for (i = 0; i < NUM_FONT_ENTRIES; i++) { btn = XmCreateToggleButton(menupane, fontEntry[i].name, NULL, 0); XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) neverCalled, &fontEntry[i]); if (i == 0) XtVaSetValues(btn, XmNset, True, NULL); if (!fontEntry[i].xfont) XtSetSensitive(btn, False); XtManageChild(btn); } XtSetArg(args[0], XmNsubMenuId, menupane); cascade = XmCreateCascadeButton(menubar, "Font", args, 1); XtManageChild(cascade); /* create framed drawing area for OpenGL rendering */ frame = XmCreateFrame(mainw, "frame", NULL, 0); XtManageChild(frame); glxarea = XtCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass, frame, NULL, 0); XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc) draw, NULL); XtAddCallback(glxarea, XmNresizeCallback, resize, NULL); XtAddCallback(glxarea, XmNinputCallback, input, NULL); /* set up application's window layout */ XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame); XtRealizeWidget(toplevel); /* * Once widget is realized (ie, associated with a created X window), we * can bind the OpenGL rendering context to the window. */ glXMakeCurrent(dpy, XtWindow(glxarea), cx); made_current = GL_TRUE; /* setup OpenGL state */ glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glClearDepth(1.0); glMatrixMode(GL_PROJECTION); glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 80); glMatrixMode(GL_MODELVIEW); MakeCube(); if (argv[1] != NULL) { numMessages = argc - 1; messages = &argv[1]; } else { numMessages = NUM_DEFAULT_MESSAGES; messages = defaultMessage; } base = glGenLists(numMessages + 1); SetupMessageDisplayList(&fontEntry[0], numMessages, messages); tick(); /* start event processing */ XtAppMainLoop(app); }
void *CoWowMotif::CreateList( const char *title, const char *texts, int textsize, void (action_cb)( void *, char *), void (cancel_cb)( void *), void *parent_ctx, int show_apply_button) { Arg args[15]; XmString cstr; Widget mainwindow; Widget ok_button; Widget cancel_button; Widget form; char *name_p; int i; wow_tListCtx ctx; XmFontList fontlist; XFontStruct *font; XmFontListEntry fontentry; ctx = (wow_tListCtx) calloc( 1, sizeof(*ctx)); ctx->action_cb = action_cb; ctx->cancel_cb = cancel_cb; ctx->parent_ctx = parent_ctx; i=0; XtSetArg( args[i], XmNiconName, title); i++; ctx->toplevel = XtCreatePopupShell ( title, topLevelShellWidgetClass, m_parent, args, i); // Set default fontlist font = XLoadQueryFont( XtDisplay(ctx->toplevel), "-*-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( args[i], XmNbuttonFontList, fontlist); i++; XtSetArg( args[i], XtNallowShellResize, TRUE); i++; XtSetValues( ctx->toplevel, args, i); mainwindow = XmCreateMainWindow( ctx->toplevel, (char*) "mainWindow", NULL, 0); XtManageChild( mainwindow); i=0; XtSetArg(args[i],XmNwidth, 200);i++; XtSetArg(args[i],XmNheight, 400);i++; XtSetArg(args[i],XmNresizePolicy,XmRESIZE_NONE); i++; form = XmCreateForm( mainwindow, (char*) "form", args, i); XtManageChild( form); cstr = XmStringCreateLtoR( (char*) "Ok", XmSTRING_DEFAULT_CHARSET); i=0; XtSetArg( args[i], XmNbottomAttachment, XmATTACH_FORM); i++; XtSetArg( args[i], XmNbottomOffset, 20); i++; XtSetArg( args[i], XmNleftAttachment, XmATTACH_FORM); i++; XtSetArg( args[i], XmNleftOffset, 20); i++; XtSetArg( args[i], XmNwidth, 50); i++; XtSetArg( args[i], XmNlabelString, cstr); i++; ok_button = XmCreatePushButton( form, (char*) "okButton", args, i); XtAddCallback( ok_button, XmNactivateCallback, (XtCallbackProc) list_ok_cb, ctx); XtManageChild( ok_button); XmStringFree( cstr); cstr = XmStringCreateLtoR( (char*) "Cancel", XmSTRING_DEFAULT_CHARSET); i=0; XtSetArg( args[i], XmNbottomAttachment, XmATTACH_FORM); i++; XtSetArg( args[i], XmNbottomOffset, 20); i++; XtSetArg( args[i], XmNrightAttachment, XmATTACH_FORM); i++; XtSetArg( args[i], XmNrightOffset, 20); i++; XtSetArg( args[i], XmNwidth, 50); i++; XtSetArg( args[i], XmNlabelString, cstr); i++; cancel_button = XmCreatePushButton( form, (char*) "okButton", args, i); XtAddCallback( cancel_button, XmNactivateCallback, (XtCallbackProc) list_cancel_cb, ctx); XtManageChild( cancel_button); XmStringFree( cstr); i = 0; XtSetArg( args[i], XmNdefaultButton, ok_button); i++; XtSetArg( args[i], XmNcancelButton, cancel_button); i++; XtSetValues( form, args, i); i=0; XtSetArg( args[i], XmNbottomAttachment, XmATTACH_WIDGET); i++; XtSetArg( args[i], XmNbottomWidget, ok_button); i++; XtSetArg( args[i], XmNbottomOffset, 15); i++; XtSetArg( args[i], XmNrightAttachment, XmATTACH_FORM); i++; XtSetArg( args[i], XmNrightOffset, 15); i++; XtSetArg( args[i], XmNtopAttachment, XmATTACH_FORM); i++; XtSetArg( args[i], XmNtopOffset, 15); i++; XtSetArg( args[i], XmNleftAttachment, XmATTACH_FORM); i++; XtSetArg( args[i], XmNleftOffset, 15); i++; XtSetArg( args[i], XmNselectionPolicy, XmSINGLE_SELECT); i++; XtSetArg( args[i], XmNfontList, fontlist); i++; ctx->list = XmCreateScrolledList( form, (char*) "scrolledList", args, i); XtAddCallback( ctx->list, XmNdefaultActionCallback, (XtCallbackProc) list_action_cb, ctx); XmFontListFree( fontlist); XtManageChild( ctx->list); name_p = (char *)texts; i = 0; while ( strcmp( name_p, "") != 0) { cstr = XmStringCreateSimple( name_p); XmListAddItemUnselected( ctx->list, cstr, 0); XmStringFree(cstr); name_p += textsize; i++; } ctx->texts = (char *) calloc( i+1, textsize); ctx->textsize = textsize; memcpy( ctx->texts, texts, (i+1) * textsize); XtPopup( ctx->toplevel, XtGrabNone); // Set input focus to the scrolled list widget XmProcessTraversal( ctx->list, XmTRAVERSE_CURRENT); return ctx; }
int main(int argc, char **argv) { XtAppContext theApp; Widget shell, toplevel, menubar, filepane; Widget button, button1, button2, sep; Widget saveAsPane, button3, button4, button5; Widget button6, button7, editpane; Widget one, two, three; Widget mb; XmString xmstr; shell = XtVaAppInitialize(&theApp, "mainW", NULL, 0, &argc, argv, NULL, NULL); toplevel = XmCreateMainWindow(shell, "MainWindow", NULL, 0); XtManageChild(toplevel); menubar = XmCreateMenuBar(toplevel, "menuBar", NULL,0); XtManageChild(menubar); filepane = XmCreatePulldownMenu(menubar, "pane", NULL,0); xmstr = XmStringCreateSimple("File"); button = XtVaCreateManagedWidget("File", xmCascadeButtonWidgetClass, menubar, XmNsubMenuId, filepane, XmNlabelString, xmstr, NULL); editpane = XmCreatePulldownMenu(menubar, "pane2", NULL, 0); button6 = XtVaCreateManagedWidget("Edit", xmCascadeButtonGadgetClass, menubar, XmNsubMenuId, editpane, NULL); button7 = XtVaCreateManagedWidget("Cut", xmPushButtonGadgetClass, editpane, NULL); button1 = XtVaCreateManagedWidget("Open", xmPushButtonGadgetClass, filepane, NULL); sep = XtVaCreateManagedWidget("sep", xmSeparatorGadgetClass, filepane, NULL); button2 = XtVaCreateManagedWidget("Close", xmPushButtonWidgetClass, filepane, NULL); saveAsPane = XmCreatePulldownMenu(filepane, "save_as", NULL, 0); button3 = XtVaCreateManagedWidget("Save As", xmCascadeButtonWidgetClass, filepane, XmNsubMenuId, saveAsPane, NULL); button4 = XtVaCreateManagedWidget("MS Word", xmPushButtonWidgetClass, saveAsPane, NULL); button5 = XtVaCreateManagedWidget("LaTeX", xmPushButtonWidgetClass, saveAsPane, NULL); mb = XtVaCreateManagedWidget("mb", xmMessageBoxWidgetClass, toplevel, NULL); XtVaSetValues(toplevel, XmNmessageWindow, mb, NULL); one = XtVaCreateManagedWidget("form", xmFormWidgetClass, toplevel, NULL); two = XtVaCreateManagedWidget("two", xmPushButtonWidgetClass, one, XmNtopAttachment, XmATTACH_FORM, XmNbottomAttachment, XmATTACH_FORM, XmNleftAttachment, XmATTACH_NONE, XmNrightAttachment, XmATTACH_FORM, NULL); three = XtVaCreateManagedWidget("three", xmPushButtonWidgetClass, one, XmNtopAttachment, XmATTACH_FORM, XmNbottomAttachment, XmATTACH_FORM, XmNleftAttachment, XmATTACH_FORM, XmNrightAttachment, XmATTACH_WIDGET, XmNrightWidget, two, NULL); XmMainWindowSetAreas(toplevel, menubar, NULL, NULL, NULL, one); XtRealizeWidget(shell); { static XtWidgetGeometry Expected[] = { CWWidth | CWHeight , 56, 72, 212, 143, 0,0,0, /* MainWindow */ CWWidth | CWHeight | CWX | CWY, 0, 0, 212, 31, 0,0,0, /* menuBar */ CWWidth | CWHeight | CWX | CWY, 5, 5, 40, 21, 0,0,0, /* File */ CWWidth | CWHeight | CWX | CWY, 45, 5, 40, 21, 0,0,0, /* Edit */ CWWidth | CWHeight | CWX | CWY, 0, 56, 212, 87, 0,0,0, /* mb */ CWWidth | CWHeight | CWX | CWY, 0, 0, 4, 4, 0,0,0, /* Symbol */ CWWidth | CWHeight | CWX | CWY, 10, 10, 192, 4, 0,0,0, /* Message */ CWWidth | CWHeight | CWX | CWY, 0, 24, 212, 2, 0,0,0, /* Separator */ CWWidth | CWHeight | CWX | CWY, 10, 36, 64, 41, 0,0,0, /* OK */ CWWidth | CWHeight | CWX | CWY, 74, 36, 64, 41, 0,0,0, /* Cancel */ CWWidth | CWHeight | CWX | CWY, 138, 36, 64, 41, 0,0,0, /* Help */ CWWidth | CWHeight | CWX | CWY, 0, 31, 212, 25, 0,0,0, /* form */ CWWidth | CWHeight | CWX | CWY, 182, 0, 30, 25, 0,0,0, /* two */ CWWidth | CWHeight | CWX | CWY, 0, 0, 182, 25, 0,0,0, /* three */ }; /* toplevel should be replaced with to correct applicationShell */ PrintDetails(toplevel, Expected); } LessTifTestMainLoop(shell); exit(0); }
/************************************************************** * DaCreateGui: **************************************************************/ Widget DaCreateGui(char * name, char * aclass, int argc, char ** argv, Display * display) { Arg args[15]; Widget widget_array[10]; int n; /***************** object of type : ApplicationShell *****************/ n = 0; /* Setup argc & argv attribute */ XtSetArg(args[n], XtNargc, argc); n++; XtSetArg(args[n], XtNargv, argv); n++; widget_array[WI_DAINPUT] = XtAppCreateShell(name, aclass, applicationShellWidgetClass, display, args, n); /***************** mainWindow : XmMainWindow *****************/ widget_array[WI_MAINWINDOW] = XmCreateMainWindow(widget_array[WI_DAINPUT], "mainWindow", NULL, 0); /***************** menuBar : XmMenuBar *****************/ widget_array[WI_MENUBAR] = XmCreateMenuBar(widget_array[WI_MAINWINDOW], "menuBar", NULL, 0); /***************** File : XmCascadeButton *****************/ widget_array[WI_FILE] = XmCreateCascadeButton(widget_array[WI_MENUBAR], "File", NULL, 0); /***************** fileMenu : XmPulldownMenu *****************/ widget_array[WI_FILEMENU] = XmCreatePulldownMenu(widget_array[WI_MENUBAR], "fileMenu", NULL, 0); { Arg args[1]; XtSetArg(args[0], XmNsubMenuId, widget_array[WI_FILEMENU]); XtSetValues(widget_array[WI_FILE], args, 1); } /***************** Exit : XmPushButton *****************/ widget_array[WI_EXIT] = XmCreatePushButton(widget_array[WI_FILEMENU], "Exit", NULL, 0); XtAddCallback(widget_array[WI_EXIT], XmNactivateCallback, DaExit, NULL); /***************** Help : XmCascadeButton *****************/ widget_array[WI_HELP] = XmCreateCascadeButton(widget_array[WI_MENUBAR], "Help", NULL, 0); /***************** helpMenu : XmPulldownMenu *****************/ widget_array[WI_HELPMENU] = XmCreatePulldownMenu(widget_array[WI_MENUBAR], "helpMenu", NULL, 0); { Arg args[1]; XtSetArg(args[0], XmNsubMenuId, widget_array[WI_HELPMENU]); XtSetValues(widget_array[WI_HELP], args, 1); } /***************** Overview : XmPushButton *****************/ widget_array[WI_OVERVIEW] = XmCreatePushButton(widget_array[WI_HELPMENU], "Overview", NULL, 0); XtAddCallback(widget_array[WI_OVERVIEW], XmNactivateCallback, DaOverView, NULL); /***************** workArea : XmDrawingArea *****************/ n = 0; XtSetArg(args[n], XmNwidth, 300); n++; XtSetArg(args[n], XmNheight, 35); n++; widget_array[WI_WORKAREA] = XmCreateDrawingArea(widget_array[WI_MAINWINDOW], "workArea", args, n); /* * Register drawing area for input method support and set input * context values. */ XmImRegister(widget_array[WI_WORKAREA], 0); { Pixel bg, fg; Pixmap bg_pixmap; n = 0; XtSetArg(args[n], XmNbackground, &bg); n++; XtSetArg(args[n], XmNforeground, &fg); n++; XtSetArg(args[n], XmNbackgroundPixmap, &bg_pixmap);n++; XtGetValues(widget_array[WI_WORKAREA], args, n); n = 0; XtSetArg(args[n], XmNbackground, bg); n++; XtSetArg(args[n], XmNforeground, fg); n++; XtSetArg(args[n], XmNbackgroundPixmap, bg_pixmap);n++; XmImSetValues(widget_array[WI_WORKAREA], args, n); } /* * Add event handler for focus events. This is needed for the * input method to correctly display the input area. */ XtAddEventHandler(widget_array[WI_WORKAREA], EnterWindowMask|LeaveWindowMask|FocusChangeMask, False, DaFocusHandler, NULL); XtAddCallback(widget_array[WI_WORKAREA], XmNexposeCallback, DaRedrawText, NULL); XtAddCallback(widget_array[WI_WORKAREA], XmNinputCallback, DaInputText, NULL); XtAddCallback(widget_array[WI_WORKAREA], XmNresizeCallback, DaResizedText, NULL); /***************** menuBar : XmMenuBar *****************/ n = 0; XtSetArg(args[n], XmNmenuHelpWidget, widget_array[WI_HELP]); n++; XtSetValues(widget_array[WI_MENUBAR], args, n); XtManageChild(widget_array[WI_EXIT]); XtManageChild(widget_array[WI_FILE]); XtManageChild(widget_array[WI_OVERVIEW]); XtManageChild(widget_array[WI_HELP]); XtManageChild(widget_array[WI_MENUBAR]); XtManageChild(widget_array[WI_WORKAREA]); XtManageChild(widget_array[WI_MAINWINDOW]); /* * Return the first created widget. */ return widget_array[WI_DAINPUT]; }
/* ** Create a new event display window */ SpaceWindow *CreatePanelSp(Display *display, int setsEventNum, int canOpenFiles, int canExit, char *windowTitle, char *eventSelectorText) { Widget appShell, main, menuBar, form; SpaceWindow *window; static Atom wmpAtom, dwAtom = NULL; Arg al[20]; int type, ac; XGCValues values; /* Allocate some memory for the new window data structure */ window = (SpaceWindow *)XtMalloc(sizeof(SpaceWindow)); /* Create an toplevel shell to hold the window */ ac = 0; XtSetArg(al[ac], XmNtitle, windowTitle); ac++; XtSetArg(al[ac], XmNdeleteResponse, XmDO_NOTHING); ac++; XtSetArg(al[ac], XmNiconName, windowTitle); ac++; /* Keep the phase name here, to same valid XDefaults.. */ appShell = XtAppCreateShell ("phase", "Space", applicationShellWidgetClass, display, al, ac); /* ** create a main window holding a menu bar and a form with the rest of ** the window contents. */ main = XmCreateMainWindow(appShell, "main", NULL, 0); XtManageChild(main); type = STDHEP_SPACE; menuBar = CreateMenuBar(main, (StdHepWindow *) window, canOpenFiles, canExit, type); XtManageChild(menuBar); form = createContents(main, window, setsEventNum, eventSelectorText); XtManageChild(form); /* add the window to the global window list */ AddToWindowList((StdHepWindow *) window); /* realize all of the widgets in the new window */ XtRealizeWidget(appShell); /* set up closeCB to be called when the user selects close from the window menu. The close menu item usually activates f.kill which sends a WM_DELETE_WINDOW protocol request for the window. */ if (dwAtom == NULL) { wmpAtom = XmInternAtom(display, "WM_PROTOCOLS", TRUE); dwAtom = XmInternAtom(display, "WM_DELETE_WINDOW", TRUE); } XmAddProtocolCallback(appShell, wmpAtom, dwAtom, closeCB, window); /* initialize window structure, including a read-only graphics contexts for drawing in scale area and highlighting in spin widget */ window->shell = appShell; window->selectedTrack = NO_TRACK; window->trackWindowShell = NULL; window->btnRotationPanel = NULL; window->absRotationPanel = NULL; window->buttonRotateDegrees = INITIAL_ROT_INCR; window->event.nParticles = 0; window->event.particles = NULL; window->colorcode.nParticles = 0; window->colorcode.particles = NULL; window->nDetectorSegments = 0; window->detectorSegments = NULL; ac = 0; XtSetArg(al[ac], XmNbackground, &values.background); ac++; XtSetArg(al[ac], XmNforeground, &values.foreground); ac++; XtGetValues(window->scaleArea, al, ac); window->scaleGC = XtGetGC(window->scaleArea, GCForeground|GCBackground, &values); window->highlightGC = SpinCopyGC(window->spin); XSetLineAttributes(display, window->highlightGC, 5, LineSolid, CapRound, JoinMiter); return window; }
int main(int argc, char *argv[]) { #define MAIN_CHILDREN 3 #define FORM_CHILDREN 3 #define PLANE_CHILDREN 6 #define TRAFFIC_CHILDREN 3 #define SetMenuEntry(k,l,p,d) labels[k]=l;procs[k]=p;private[k]=d; Pixmap flying; Pixmap parked; Pixmap mask; Widget theWidgetRoot; Widget main_tab[MAIN_CHILDREN]; Widget from_tab[PLANE_CHILDREN]; Widget to_tab[TRAFFIC_CHILDREN]; Widget form_tab[FORM_CHILDREN]; Widget framed[2]; Widget entry; static char myClass[] = "XmdAirport"; Arg args[10]; int n ; String labels[4]; XtCallbackProc procs[4]; XtPointer private[4]; XGCValues gcv; Airport this; /* * Initialize */ this = (Airport) XtCalloc(sizeof(AirportRec), 1); XtSetLanguageProc(NULL, (XtLanguageProc) NULL, NULL); theWidgetRoot = XtVaOpenApplication( &this->context, myClass, NULL, 0, &argc, argv, NULL, sessionShellWidgetClass, XmNallowShellResize, True, NULL); this->display = XtDisplay(theWidgetRoot); FlightAtom = XmInternAtom(this->display, "FLIGHT", False); DeleteAtom = XmInternAtom(this->display, "DELETE", False); XtGetApplicationResources(theWidgetRoot, &AirportResources, AirportResourcesSpecs, XtNumber(AirportResourcesSpecs), (ArgList) NULL, 0); /* * Create the Main Window, the menubar and the pulldown menus */ n = 0; this->main = XmCreateMainWindow(theWidgetRoot, "main", args, n); n = 0; main_tab[0] = XmCreateMenuBar(this->main, "menubar", args, n); n = 0; SetMenuEntry(n, "Exit", (XtCallbackProc) ExitCallback, (XtPointer) this ); n++; entry = MenuBarEntry(main_tab[0], "File", labels, procs, private, n); n = 0; SetMenuEntry(0, "Tutorial", (XtCallbackProc) HelpCallback, (XtPointer) this); n++; entry = MenuBarEntry(main_tab[0], "Help", labels, procs, private, n); n = 0; XtSetArg(args[n], XmNmenuHelpWidget, entry); n++; XtSetValues(main_tab[0], args, n); /* * Create the Airport widget structure. * Two framed radio boxes show state. * A drawing area in the middle show track and planes */ n = 0; this->screen_width = WidthOfScreen(XtScreenOfObject(this->main)); this->screen_height = HeightOfScreen(XtScreenOfObject(this->main)); XtSetArg(args[n], XmNwidth, this->screen_width*3/7); n++; XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++; main_tab[1] = XmCreateForm(this->main, "airport", args, n); n = 0; XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++; XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++; XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM) ; n++; form_tab[0] = XmCreateFrame(main_tab[1], "flight", args, n); n = 0; XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++; framed[0] = XmCreateLabel(form_tab[0], "title", args, n); n = 0; XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++; XtSetArg(args[n], XmNresizePolicy, XmRESIZE_GROW); n++; XtSetArg(args[n], XmNradioBehavior, True); n++; framed[1] = XmCreateRadioBox(form_tab[0], "panel", args, n); n = 0; XtSetArg(args[n], XmNset, True); n++; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->from.departure = from_tab[0] = XmCreateToggleButton(framed[1], "departure", args, n); n = 0; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->from.over_ocean = from_tab[1] = XmCreateToggleButton(framed[1], "over_ocean", args, n); n = 0; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->from.over_land = from_tab[2] = XmCreateToggleButton(framed[1], "over_land", args, n); n = 0; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->from.over_site = from_tab[3] = XmCreateToggleButton(framed[1], "radar", args, n); n = 0; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->from.landing = from_tab[4] = XmCreateToggleButton(framed[1], "landing", args, n); n = 0; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->from.landed = from_tab[5] = XmCreateToggleButton(framed[1], "landed", args, n); XtManageChildren(from_tab, PLANE_CHILDREN); XtManageChildren(framed, 2); /* * Create the Airport Traffic control state */ n = 0; XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++; XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++; XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM) ; n++; form_tab[1] = XmCreateFrame(main_tab[1], "traffic", args, n); n = 0; XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++; framed[0] = XmCreateLabel(form_tab[1], "title", args, n); n = 0; XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++; XtSetArg(args[n], XmNradioBehavior, True); n++; framed[1] = XmCreateRadioBox(form_tab[1], "traffic_box", args, n); n = 0; XtSetArg(args[n], XmNset, True); n++; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->to.leave = to_tab[1] = XmCreateToggleButton(framed[1], "no_traffic", args, n); n = 0; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->to.enter = to_tab[0] = XmCreateToggleButton(framed[1], "radar_echo", args, n); n = 0; XtSetArg(args[n], XmNvisibleWhenOff, False); n++; this->to.landing = to_tab[2] = XmCreateToggleButton(framed[1], "landing", args, n); XtManageChildren(to_tab, TRAFFIC_CHILDREN); XtManageChildren(framed, 2); /* * Create the Airport picture */ n = 0; XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++; XtSetArg(args[n], XmNbottomAttachment,XmATTACH_FORM); n++; XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET) ; n++; XtSetArg(args[n], XmNleftWidget, form_tab[0]) ; n++; XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET) ; n++; XtSetArg(args[n], XmNrightWidget, form_tab[1]) ; n++; this->airport = form_tab[2] = XmCreateDrawingArea(main_tab[1], "da", args, n); XtAddCallback(this->airport, XmNexposeCallback, (XtCallbackProc) ShowAirport, (XtPointer) this); XtAddCallback(this->airport, XmNresizeCallback, (XtCallbackProc) ResizeAirport, (XtPointer) this); XtAddCallback(this->airport, XmNinputCallback, (XtCallbackProc) AirportInput, (XtPointer) this); /* * Create the Airport Message area */ n = 0; main_tab[2] = XmCreateFrame(this->main, "message", args, n); n = 0; XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++; framed[0] = XmCreateLabel(main_tab[2], "title", args, n); n = 0; XtSetArg(args[n], XmNchildType, XmFRAME_WORKAREA_CHILD); n++; XtSetArg(args[n], XmNvisibleItemCount, 4); n++; this->msg_area = XmCreateScrolledList(main_tab[2], "msg_list", args, n); XtManageChild(this->msg_area); framed[1] = XtParent(this->msg_area); XtManageChildren(framed, 2); n = 0; XtSetArg(args[n], XmNmenuBar, main_tab[0]); n++; XtSetArg(args[n], XmNworkWindow, main_tab[1]); n++; XtSetArg(args[n], XmNmessageWindow, main_tab[2]); n++; XtSetValues(this->main, args, n); XtManageChildren(form_tab, FORM_CHILDREN); XtManageChildren(main_tab, MAIN_CHILDREN); XtManageChild(this->main); XtRealizeWidget(theWidgetRoot); /* * Create the drag icon */ parked = XCreateBitmapFromData(this->display, XtWindow(this->main), (char*)plane_bits, plane_width, plane_height); flying = XCreateBitmapFromData(this->display, XtWindow(this->main), (char*)flying_bits, flying_icon_width, flying_icon_height); mask = XCreateBitmapFromData(this->display, XtWindow(this->main), (char*)flying_mask_bits, flying_mask_width, flying_mask_height); n = 0; XtSetArg(args[n], XmNpixmap, flying); n++; XtSetArg(args[n], XmNdepth, 1); n++; XtSetArg(args[n], XmNmask, mask); n++; XtSetArg(args[n], XmNwidth, flying_icon_width); n++; XtSetArg(args[n], XmNheight, flying_icon_height) ; n++; this->dragIcon = XmCreateDragIcon(form_tab[2], "drag", args, n); if (this->dragIcon == NULL) { printf("cannot create drag icon\n"); exit(0); } /* Create GC for drawing planes */ gcv.function = GXcopy; gcv.fill_style = FillOpaqueStippled; gcv.stipple = parked; gcv.foreground = AirportResources.spot_foreground; gcv.background = AirportResources.spot_background; this->park.gc = XCreateGC(this->display, XtWindow(this->main), GCFunction|GCStipple|GCFillStyle |GCForeground|GCBackground, &gcv); gcv.line_style = LineDoubleDash; gcv.line_width = AirportResources.track_border_width; gcv.fill_style = FillSolid; gcv.foreground = AirportResources.track_foreground; gcv.background = AirportResources.track_background; this->track.gc = XCreateGC(this->display, XtWindow(this->main), GCFunction|GCLineWidth|GCLineStyle |GCFillStyle|GCForeground|GCBackground, &gcv); XtAppMainLoop(this->context); return 0; /* make compiler happy */ }
void create_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); }
void createColor() { Widget paletteRC; XmString buttons[N_MAX_MENU_ELES]; KeySym keySyms[N_MAX_MENU_ELES]; XmButtonType buttonType[N_MAX_MENU_ELES]; Widget colorMB; Widget colorHelpPDM; Widget menuHelpWidget; Pixel fg, bg; int i, n, childCount; Arg args[10]; /* * create a main window in a dialog, and then the palette radio box */ n = 0; XtSetArg(args[n],XtNiconName,"Colors"); n++; XtSetArg(args[n],XtNtitle,"Color Palette"); n++; XtSetArg(args[n],XtNallowShellResize,TRUE); n++; XtSetArg(args[n],XmNkeyboardFocusPolicy,XmEXPLICIT); n++; /* map window manager menu Close function to application close... */ XtSetArg(args[n],XmNdeleteResponse,XmDO_NOTHING); n++; XtSetArg(args[n],XmNmwmDecorations,MWM_DECOR_ALL|MWM_DECOR_RESIZEH); n++; colorS = XtCreatePopupShell("colorS",topLevelShellWidgetClass, mainShell,args,n); XmAddWMProtocolCallback(colorS,WM_DELETE_WINDOW, (XtCallbackProc)wmCloseCallback, (XtPointer)OTHER_SHELL); colorMW = XmCreateMainWindow(colorS,"colorMW",NULL,0); /* * create the menu bar */ buttons[0] = XmStringCreateSimple("File"); buttons[1] = XmStringCreateSimple("Help"); #if 0 keySyms[0] = 'F'; keySyms[1] = 'H'; n = 0; XtSetArg(args[n],XmNbuttonCount,N_MAIN_MENU_ELES); n++; XtSetArg(args[n],XmNbuttons,buttons); n++; XtSetArg(args[n],XmNbuttonMnemonics,keySyms); n++; XtSetArg(args[n],XmNforeground,defaultForeground); n++; XtSetArg(args[n],XmNbackground,defaultBackground); n++; colorMB = XmCreateSimpleMenuBar(colorMW, "colorMB",args,n); #endif colorMB = XmVaCreateSimpleMenuBar(colorMW, "colorMB", XmVaCASCADEBUTTON, buttons[0], 'F', XmVaCASCADEBUTTON, buttons[1], 'H', NULL); /* color colorMB properly (force so VUE doesn't interfere) */ colorMenuBar(colorMB,defaultForeground,defaultBackground); /* set the Help cascade button in the menu bar */ menuHelpWidget = XtNameToWidget(colorMB,"*button_1"); XtVaSetValues(colorMB,XmNmenuHelpWidget,menuHelpWidget, NULL); for (i = 0; i < N_MAIN_MENU_ELES; i++) XmStringFree(buttons[i]); /* * create the file pulldown menu pane */ buttons[0] = XmStringCreateSimple("Close"); keySyms[0] = 'C'; buttonType[0] = XmPUSHBUTTON; n = 0; XtSetArg(args[n],XmNbuttonCount,N_FILE_MENU_ELES); n++; XtSetArg(args[n],XmNbuttons,buttons); n++; XtSetArg(args[n],XmNbuttonType,buttonType); n++; XtSetArg(args[n],XmNbuttonMnemonics,keySyms); n++; XtSetArg(args[n],XmNpostFromButton,FILE_BTN_POSN); n++; XtSetArg(args[n],XmNsimpleCallback,fileMenuSimpleCallback); n++; XmCreateSimplePulldownMenu(colorMB,"colorFilePDM", args,n); for (i = 0; i < N_FILE_MENU_ELES; i++) XmStringFree(buttons[i]); /* * create the help pulldown menu pane */ buttons[0] = XmStringCreateSimple("On Color Palette..."); keySyms[0] = 'C'; buttonType[0] = XmPUSHBUTTON; n = 0; XtSetArg(args[n],XmNbuttonCount,N_HELP_MENU_ELES); n++; XtSetArg(args[n],XmNbuttons,buttons); n++; XtSetArg(args[n],XmNbuttonType,buttonType); n++; XtSetArg(args[n],XmNbuttonMnemonics,keySyms); n++; XtSetArg(args[n],XmNpostFromButton,HELP_BTN_POSN); n++; colorHelpPDM = XmCreateSimplePulldownMenu(colorMB, "colorHelpPDM",args,n); XmStringFree(buttons[0]); /* (MDA) for now, disable this menu */ XtSetSensitive(colorHelpPDM,False); /* * Add the Palette Radio Box for the drawing color toggle buttons * */ n = 0; XtSetArg(args[n],XmNadjustLast,False); n++; XtSetArg(args[n],XmNadjustLast,False); n++; XtSetArg(args[n],XmNpacking,XmPACK_COLUMN); n++; XtSetArg(args[n],XmNorientation,XmVERTICAL); n++; XtSetArg(args[n],XmNnumColumns,(short)(DL_MAX_COLORS/DL_COLORS_COLUMN_SIZE)); n++; XtSetArg(args[n],XmNspacing,0); n++; paletteRC = XmCreateRowColumn(colorMW,"paletteRC",args,n); XtVaGetValues(paletteRC,XmNforeground,&fg,XmNbackground,&bg,NULL); /* * create the (maximum number of) color buttons */ n = 0; XtSetArg(args[n],XmNlabelType,XmPIXMAP); n++; XtSetArg(args[n],XmNrecomputeSize,False); n++; for (childCount = 0; childCount < DL_MAX_COLORS; childCount++) { /* use values in default colormap if in valid area of colormap */ globalColorPalettePB[childCount] = XmCreatePushButton(paletteRC,"colorPB", args,n); XtAddCallback(globalColorPalettePB[childCount],XmNactivateCallback, colorPaletteActivateCallback, (XtPointer)childCount); } /* want to keep same shadow colors... but different background */ for (childCount = 0; childCount < DL_MAX_COLORS; childCount++) { XtSetArg(args[0],XmNbackground,(Pixel)defaultColormap[childCount]); XtSetValues(globalColorPalettePB[childCount],args,1); } XmMainWindowSetAreas(colorMW,colorMB,NULL,NULL,NULL,paletteRC); /* * manage the composites */ XtManageChild(colorMB); XtManageChildren(globalColorPalettePB,childCount); XtManageChild(paletteRC); XtManageChild(colorMW); }
Widget XmCreateMainWindow_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateMainWindow(parent, name, arglist, argcount);}
int main(int argc, char **argv) { XtAppContext AppCtx; Widget TopLevel, Main, Menu, Form, Text, PullDownMenu; Widget Cascade, Butt1, Butt3, Butt4, Butt5; Widget Frame, Label, RowCol, w; Arg args[10]; TopLevel = XtVaAppInitialize(&AppCtx, "Demo", NULL, 0, &argc, argv, Fallbacks, NULL); Main = XmCreateMainWindow(TopLevel, "main", NULL, 0); XtManageChild(Main); Menu = XmCreateMenuBar(Main, "menu", NULL, 0); XtManageChild(Menu); XtSetArg(args[0], XmNmnemonic, XK_F); Cascade = XmCreateCascadeButton(Menu, "File", args, 1); XtManageChild(Cascade); PullDownMenu = XmCreatePulldownMenu(Cascade, "filemenu", NULL, 0); w = XmCreateToggleButtonPlus(PullDownMenu, "Enjoy it!", NULL, 0); XtVaSetValues(w, XmNmnemonic, XK_j, NULL); XtManageChild(w); XtVaCreateManagedWidget( "sepp1", xmSeparatorWidgetClass, PullDownMenu, NULL); w = XmCreateToggleButtonPlus(PullDownMenu, "One", NULL, 0); XtVaSetValues(w, XmNmnemonic, XK_O, XmNindicatorType, XmONE_OF_MANY, NULL); XtManageChild(w); w = XmCreateToggleButtonPlus(PullDownMenu, "Two", NULL, 0); XtVaSetValues(w, XmNmnemonic, XK_T, XmNindicatorType, XmONE_OF_MANY, NULL); XtManageChild(w); w = XmCreateToggleButtonPlus(PullDownMenu, "Fourtytwo", NULL, 0); XtVaSetValues(w, XmNmnemonic, XK_F, XmNindicatorType, XmONE_OF_MANY, NULL); XtManageChild(w); XtVaCreateManagedWidget( "sepp2", xmSeparatorWidgetClass, PullDownMenu, NULL); Butt1 = XtVaCreateManagedWidget( "Exit", xmPushButtonWidgetClass, PullDownMenu, XmNmnemonic, XK_E, NULL); XtAddCallback(Butt1, XmNactivateCallback, (XtCallbackProc) DummyCallback, NULL); XtVaSetValues(Cascade, XmNsubMenuId, PullDownMenu, NULL); Form = XtVaCreateManagedWidget("form", xmFormWidgetClass, Main, NULL); Label = XtVaCreateManagedWidget( "XmN_OF_MANY", xmLabelWidgetClass, Form, XmNleftAttachment, XmATTACH_FORM, XmNleftOffset, 24, XmNtopAttachment, XmATTACH_FORM, XmNtopOffset, 8, NULL); Frame = XtVaCreateManagedWidget( "frame1", xmFrameWidgetClass, Form, XmNleftAttachment, XmATTACH_FORM, XmNleftOffset, 20, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget, Label, XmNrightAttachment, XmATTACH_POSITION, XmNrightPosition, 50, XmNrightOffset, 4, NULL); RowCol = XtVaCreateManagedWidget( "RowCol", xmRowColumnWidgetClass, Frame, NULL); Butt3 = XmCreateToggleButtonPlus(RowCol, "I like the OSF", NULL, 0); XtVaSetValues(Butt3, XmNsensitive, False, NULL); XtManageChild(Butt3); Butt4 = XmCreateToggleButtonPlus(RowCol, "Support Freeware!", NULL, 0); XtVaSetValues(Butt4, XmNset, True, NULL); XtManageChild(Butt4); Butt5 = XmCreateToggleButtonPlus(RowCol, "New Widgets", NULL, 0); XtManageChild(Butt5); Label = XtVaCreateManagedWidget( "XmONE_OF_MANY", xmLabelWidgetClass, Form, XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 50, XmNleftOffset, 4, XmNtopAttachment, XmATTACH_FORM, XmNtopOffset, 8, NULL); Frame = XtVaCreateManagedWidget( "frame2", xmFrameWidgetClass, Form, XmNleftAttachment, XmATTACH_POSITION, XmNleftPosition, 50, XmNleftOffset, 4, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget, Label, XmNrightAttachment, XmATTACH_FORM, XmNrightOffset, 20, NULL); RowCol = XtVaCreateManagedWidget( "RowCol", xmRowColumnWidgetClass, Frame, XmNradioBehavior, True, XmNradioAlwaysOne, True, NULL); Butt3 = XmCreateToggleButtonPlus(RowCol, "Athena", NULL, 0); XtVaSetValues(Butt3, XmNindicatorType, XmONE_OF_MANY, NULL); XtManageChild(Butt3); Butt4 = XmCreateToggleButtonPlus(RowCol, "OSF/Motif(=Hades)", NULL, 0); XtVaSetValues(Butt4, XmNindicatorType, XmONE_OF_MANY, NULL); XtManageChild(Butt4); Butt5 = XmCreateToggleButtonPlus(RowCol, "Harry's Motif Widgets", NULL, 0); XtVaSetValues(Butt5, XmNindicatorType, XmONE_OF_MANY, XmNset, True, NULL); XtManageChild(Butt5); /* Label = XtVaCreateManagedWidget( "XmNtriState = True", xmLabelWidgetClass, Form, XmNleftAttachment, XmATTACH_FORM, XmNleftOffset, 20, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget, Frame, XmNtopOffset, 8, NULL); Frame = XtVaCreateManagedWidget( "frame3", xmFrameWidgetClass, Form, XmNleftAttachment, XmATTACH_FORM, XmNleftOffset, 20, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget, Label, XmNrightAttachment, XmATTACH_FORM, XmNrightOffset, 20, NULL); RowCol = XtVaCreateManagedWidget( "RowCol", xmRowColumnWidgetClass, Frame, NULL); Butt3 = XtVaCreateManagedWidget( "Click on me several times.", xmToggleButtonWidgetClass, RowCol, XmNtriState, True, XmNset, XmTOGGLE_DONTKNOW, NULL); */ Text = XtVaCreateManagedWidget( "The new xmToggleButtonWidgetClass", xmLabelWidgetClass, Form, XmNleftAttachment, XmATTACH_FORM, XmNleftOffset, 20, XmNrightAttachment, XmATTACH_FORM, XmNrightOffset, 20, XmNtopAttachment, XmATTACH_WIDGET, XmNtopWidget, Frame, XmNtopOffset, 20, XmNbottomAttachment, XmATTACH_FORM, XmNbottomOffset, 20, NULL); XmMainWindowSetAreas(Main, Menu, NULL, NULL, NULL, Form); XtRealizeWidget(TopLevel); { static XtWidgetGeometry Expected[] = { CWWidth | CWHeight , 0, 0, 370, 204, 0,0,0, /* main */ CWWidth | CWHeight | CWX | CWY, 0, 0, 370, 31, 0,0,0, /* menu */ CWWidth | CWHeight | CWX | CWY, 5, 5, 40, 21, 0,0,0, /* File */ CWWidth | CWHeight | CWX | CWY, 0, 31, 370, 173, 0,0,0, /* form */ CWWidth | CWHeight | CWX | CWY, 24, 8, 70, 17, 0,0,0, /* XmN_OF_MANY */ CWWidth | CWHeight | CWX | CWY, 20, 25, 161, 91, 0,0,0, /* frame1 */ CWWidth | CWHeight | CWX | CWY, 2, 2, 157, 87, 0,0,0, /* RowCol */ CWWidth | CWHeight | CWX | CWY, 3, 3, 151, 25, 0,0,0, /* I like the OSF */ CWWidth | CWHeight | CWX | CWY, 3, 31, 151, 25, 0,0,0, /* Support Freeware! */ CWWidth | CWHeight | CWX | CWY, 3, 59, 151, 25, 0,0,0, /* New Widgets */ CWWidth | CWHeight | CWX | CWY, 189, 8, 82, 17, 0,0,0, /* XmONE_OF_MANY */ CWWidth | CWHeight | CWX | CWY, 189, 25, 161, 91, 0,0,0, /* frame2 */ CWWidth | CWHeight | CWX | CWY, 2, 2, 157, 87, 0,0,0, /* RowCol */ CWWidth | CWHeight | CWX | CWY, 3, 3, 151, 25, 0,0,0, /* Athena */ CWWidth | CWHeight | CWX | CWY, 3, 31, 151, 25, 0,0,0, /* OSF/Motif(=Hades) */ CWWidth | CWHeight | CWX | CWY, 3, 59, 151, 25, 0,0,0, /* Harry's Motif Widgets */ CWWidth | CWHeight | CWX | CWY, 20, 136, 330, 17, 0,0,0, /* The new xmToggleButtonWidgetClass */ }; PrintDetails( TopLevel ,Expected); }; LessTifTestMainLoop( TopLevel ); return 0; } /* main */
main(int argc, char *argv[]) { toplevel = XtAppInitialize(&app, "Paperplane", NULL, 0, &argc, argv, fallbackResources, NULL, 0); dpy = XtDisplay(toplevel); /* find an OpenGL-capable RGB visual with depth buffer */ vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf); if (vi == NULL) { vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf); if (vi == NULL) XtAppError(app, "no RGB visual with depth buffer"); doubleBuffer = GL_FALSE; } /* create an OpenGL rendering context */ cx = glXCreateContext(dpy, vi, /* no display list sharing */ None, /* favor direct */ GL_TRUE); if (cx == NULL) XtAppError(app, "could not create rendering context"); /* create an X colormap since probably not using default visual */ #ifdef noGLwidget cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), vi->visual, AllocNone); /* * Establish the visual, depth, and colormap of the toplevel * widget _before_ the widget is realized. */ XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth, XtNcolormap, cmap, NULL); #endif XtAddEventHandler(toplevel, StructureNotifyMask, False, map_state_changed, NULL); mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0); XtManageChild(mainw); /* create menu bar */ menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0); XtManageChild(menubar); #ifdef noGLwidget /* Hack around Xt's unfortunate default visual inheritance. */ XtSetArg(menuPaneArgs[0], XmNvisual, vi->visual); menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1); #else menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0); #endif btn = XmCreatePushButton(menupane, "Quit", NULL, 0); XtAddCallback(btn, XmNactivateCallback, quit, NULL); XtManageChild(btn); XtSetArg(args[0], XmNsubMenuId, menupane); cascade = XmCreateCascadeButton(menubar, "File", args, 1); XtManageChild(cascade); #ifdef noGLwidget menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1); #else menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0); #endif btn = XmCreateToggleButton(menupane, "Motion", NULL, 0); XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc)toggle, NULL); XtManageChild(btn); btn = XmCreatePushButton(menupane, "Add plane", NULL, 0); XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)add_plane, NULL); XtManageChild(btn); btn = XmCreatePushButton(menupane, "Remove plane", NULL, 0); XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)remove_plane, NULL); XtManageChild(btn); XtSetArg(args[0], XmNsubMenuId, menupane); cascade = XmCreateCascadeButton(menubar, "Planes", args, 1); XtManageChild(cascade); /* create framed drawing area for OpenGL rendering */ frame = XmCreateFrame(mainw, "frame", NULL, 0); XtManageChild(frame); #ifdef noGLwidget glxarea = XtVaCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass, frame, NULL); #else #ifdef noMotifGLwidget /* notice glwDrawingAreaWidgetClass lacks an 'M' */ glxarea = XtVaCreateManagedWidget("glxarea", glwDrawingAreaWidgetClass, #else glxarea = XtVaCreateManagedWidget("glxarea", glwMDrawingAreaWidgetClass, #endif frame, GLwNvisualInfo, vi, NULL); #endif XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc)draw, NULL); XtAddCallback(glxarea, XmNresizeCallback, resize, NULL); XtAddCallback(glxarea, XmNinputCallback, input, NULL); /* set up application's window layout */ XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame); XtRealizeWidget(toplevel); /* * Once widget is realized (ie, associated with a created X window), we * can bind the OpenGL rendering context to the window. */ glXMakeCurrent(dpy, XtWindow(glxarea), cx); made_current = GL_TRUE; /* setup OpenGL state */ glClearDepth(1.0); glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 20); glMatrixMode(GL_MODELVIEW); /* add three initial random planes */ srandom(getpid()); add_plane(); add_plane(); add_plane(); add_plane(); add_plane(); /* start event processing */ toggle(); XtAppMainLoop(app); }