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