Beispiel #1
0
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 mb, com;
    Widget one, two, three;
    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);

    com = XtVaCreateManagedWidget("com", xmCommandWidgetClass, toplevel, 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, com, NULL, NULL, one);

    XtRealizeWidget(shell);

/* toplevel should be replaced with to correct applicationShell */

{
    static XtWidgetGeometry Expected[] = {
   CWWidth | CWHeight            ,  508,  524,  212,  356, 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,  269,  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,  213, 0,0,0, /* com */
   CWWidth | CWHeight | CWX | CWY,   10,   10,  192,  135, 0,0,0, /* ItemsListSW */
   CWWidth | CWHeight | CWX | CWY,    0,    0,  192,  135, 0,0,0, /* ItemsList */
   CWWidth | CWHeight | CWX | CWY,   10,  155,  192,   17, 0,0,0, /* Selection */
   CWWidth | CWHeight | CWX | CWY,   10,  172,  192,   31, 0,0,0, /* Text */
   CWWidth | CWHeight | CWX | CWY,    0,  244,  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 */ 
    };
    PrintDetails(shell,Expected);
};
  LessTifTestMainLoop(shell);

    exit(0);
}
Beispiel #2
0
Datei: menu.c Projekt: yhsesq/yhs
void create_file_menu(Widget parent)
{
    Widget file_menu_pane, file_menu_button, open_butto, open_pane, 
           open_button, view_button, file_sep_1, save_as_button, 
           file_sep_2, print_button, file_sep_3, exit_button,print_pane,
           print_menu_button;

    /* Create the menu pane for the menu */
    file_menu_pane = XmCreatePulldownMenu(parent, "file menu pane", NULL, 0);
    print_pane = XmCreatePulldownMenu(parent, "Print menu pane", NULL, 0);
    /* Populate the menu pane */
    /* Open button */
    open_pane = XmCreatePulldownMenu(file_menu_pane, "open menu pane", NULL, 0);
    open_button = XmCreatePushButton(open_pane, "Open a study of 10 images", NULL, 0);
    XtManageChild(open_button); 
    view_button = XmCreatePushButton(open_pane, "Open a single RAW file", NULL, 0);
    XtManageChild(view_button);

      /* Create the submenus for open.     */
     argcount = 0;
     XtSetArg(args[argcount], XmNsubMenuId, open_pane); argcount++;
     open_butto = XmCreateCascadeButton(file_menu_pane, "Open", args, argcount);
     XtManageChild(open_butto);

    /* Create the open file dialog and add the activation function as
       the open button's activate callback */
    create_open_dialog(parent);
    XtAddCallback(open_button, XmNactivateCallback,
		(XtCallbackProc) activate_open_dialog, (XtPointer) NULL);

     create_view_dialog(parent);
     XtAddCallback(view_button, XmNactivateCallback,
                (XtCallbackProc) activate_view_dialog, (XtPointer) NULL);

    /* Separator 1 */
    file_sep_1 = XmCreateSeparator(file_menu_pane, "file sep 1", NULL, 0);
    XtManageChild(file_sep_1);

    /* Save As button */
    save_as_button = XmCreatePushButton(file_menu_pane, "Save As ...", NULL, 0);
    XtManageChild(save_as_button);

    /* Create the save_as dialog and add the activation function as
       the save_as button's activate callback */
    create_save_as_interface(parent);
    XtAddCallback(save_as_button, XmNactivateCallback,
		(XtCallbackProc) save_as_callback, (XtPointer) NULL);

    /* Separator 3 */
    file_sep_3 = XmCreateSeparator(file_menu_pane, "file sep 3", NULL, 0);
    XtManageChild(file_sep_3);

    /* Print button */
    print_button = XmCreatePushButton(print_pane, "Print f1 => f1.PS", NULL, 0);
    XtManageChild(print_button);
    XtAddCallback(print_button, XmNactivateCallback,
		(XtCallbackProc) print_callback, (XtPointer) NULL);

    /* Separator 2 */
    file_sep_2 = XmCreateSeparator(file_menu_pane, "file sep 2", NULL, 0);
    XtManageChild(file_sep_2);

    /* Exit button */
    exit_button = XmCreatePushButton(file_menu_pane, "Exit ...", NULL, 0);
    XtManageChild(exit_button);

    /* Create the exit dialog and add the activation function as the exit
       button's activate callback */
    create_exit_dialog(parent);
    XtAddCallback(exit_button, XmNactivateCallback,
		(XtCallbackProc) activate_exit_dialog, (XtPointer) NULL);

    /* Create the file cascade button on the menu bar and attach the *
     * file menu pane to it.                                         */
    argcount = 0;
    XtSetArg(args[argcount], XmNsubMenuId, file_menu_pane); argcount++;
    file_menu_button = XmCreateCascadeButton(parent, "File ", 
						args, argcount);
    XtManageChild(file_menu_button);
    argcount = 0;
    XtSetArg(args[argcount], XmNsubMenuId, print_pane); argcount++;
    print_menu_button = XmCreateCascadeButton(parent, "Print ", 
						args, argcount);
    XtManageChild(print_menu_button);
}
Beispiel #3
0
Datei: menu.c Projekt: yhsesq/yhs
void create_preprocessing_menu(Widget parent)
{
    Widget preprocessing_menu_pane, preprocessing_menu_button, histogram_button, preprocessing_sep_1,
	   histo_eq_button, preprocessing_sep_2, threshold_button, preprocessing_sep_3,
	   filter_button, filter_pane, mean_filter_button,
	   median_filter_button, smooth_t_button, smooth_mask1_button,
	   smooth_mask2_button, median_vf_button;

    /* Create the menu pane for the menu */
    preprocessing_menu_pane = XmCreatePulldownMenu(parent, "preprocessing menu pane", NULL, 0);

    /* Populate the menu pane */
    /* Histogram button */
    histogram_button = XmCreatePushButton(preprocessing_menu_pane, "Histogram", NULL, 0);
    XtManageChild(histogram_button);

    XtAddCallback(histogram_button, XmNactivateCallback,
		(XtCallbackProc) histogram_callback, (XtPointer) NULL);

    /* Separator 1 */
    preprocessing_sep_1 = XmCreateSeparator(preprocessing_menu_pane,
					"preprocessing sep 1", NULL, 0);
    XtManageChild(preprocessing_sep_1);

    /* Histogram equalization button */
    histo_eq_button = XmCreatePushButton(preprocessing_menu_pane,
					"Histogram Equalization", NULL, 0);
    XtManageChild(histo_eq_button);

    XtAddCallback(histo_eq_button, XmNactivateCallback,
		(XtCallbackProc) histo_eq_callback, (XtPointer) NULL);

    /* Separator 2 */
    preprocessing_sep_2 = XmCreateSeparator(preprocessing_menu_pane,
					"preprocessing sep 2", NULL, 0);
    XtManageChild(preprocessing_sep_2);

    /* Threshold button */
    threshold_button = XmCreatePushButton(preprocessing_menu_pane,
					"Threshold", NULL, 0);
    XtManageChild(threshold_button);

    /* Create the threshold dialog and add the activation function as the
       threshold button's activate callback */
    create_threshold_dialog(parent);
    XtAddCallback(threshold_button, XmNactivateCallback,
		(XtCallbackProc) activate_threshold_dialog, (XtPointer) NULL);

    /* Separator 3 */
    preprocessing_sep_3 = XmCreateSeparator(preprocessing_menu_pane,
					"preprocessing sep 3", NULL, 0);
    XtManageChild(preprocessing_sep_3);

    /* Filter button */
    filter_pane = XmCreatePulldownMenu(preprocessing_menu_pane,
					"filter pane", NULL, 0);

    mean_filter_button = XmCreatePushButton(filter_pane, "Mean Filter", NULL, 0);
    XtManageChild(mean_filter_button);
    XtAddCallback(mean_filter_button, XmNactivateCallback,
		(XtCallbackProc) mean_filter_callback, (XtPointer) NULL);

    median_filter_button = XmCreatePushButton(filter_pane,
					"Median Filter", NULL, 0);
    XtManageChild(median_filter_button);
    XtAddCallback(median_filter_button, XmNactivateCallback,
		(XtCallbackProc) median_filter_callback, (XtPointer) NULL);


    smooth_t_button = XmCreatePushButton(filter_pane, "Smooth T", NULL, 0);
    XtManageChild(smooth_t_button);
    create_smooth_t_dialog(parent);   /* Dialogo */
    XtAddCallback(smooth_t_button, XmNactivateCallback,
		(XtCallbackProc) activate_smooth_t_dialog, (XtPointer) NULL);

    smooth_mask1_button = XmCreatePushButton(filter_pane,
					"Smooth .. Mask1", NULL, 0);
    XtManageChild(smooth_mask1_button);
    XtAddCallback(smooth_mask1_button, XmNactivateCallback,
		(XtCallbackProc) smooth_mask1_callback, (XtPointer) NULL);

    smooth_mask2_button = XmCreatePushButton(filter_pane,
					"Smooth .. Mask2", NULL, 0);
    XtManageChild(smooth_mask2_button);
    XtAddCallback(smooth_mask2_button, XmNactivateCallback,
		(XtCallbackProc) smooth_mask2_callback, (XtPointer) NULL);

    median_vf_button = XmCreatePushButton(filter_pane,
					"Median VF", NULL, 0);
    XtManageChild(median_vf_button);
    XtAddCallback(median_vf_button, XmNactivateCallback,
		(XtCallbackProc) median_vf_callback, (XtPointer) NULL);

    /* Submenus del Filter */
    argcount = 0;
    XtSetArg(args[argcount], XmNsubMenuId, filter_pane); argcount++;
    filter_button = XmCreateCascadeButton(preprocessing_menu_pane,
					"Filter ", args, argcount );
    XtManageChild(filter_button);


   /* Create the preprocessing cascade button on the menu bar and attach the *
    * preprocessing menu pane to it.                                         */
    argcount = 0;
    XtSetArg(args[argcount], XmNsubMenuId, preprocessing_menu_pane); argcount++;
    preprocessing_menu_button = XmCreateCascadeButton(parent,
				"Pre-processing ", args, argcount);
/*    XtManageChild(preprocessing_menu_button); */
}
Beispiel #4
0
int UISymbolEdit (DBObjTable *symbols,int symbolType)

	{
	int symNum;
	static int changed, save;
	static Widget dShell = NULL;
	XmString string;
	UISymbol **editSymbols;
	DBObjRecord *symRecord;

	if (dShell == NULL)
		{
		char symString [20];
		int depth;
		Pixel foreground, background;
		XGCValues xgcv;
		GC gc;
		Widget mainForm, scrolledW, list, label, button, text, foreMenu, backMenu, rowCol, symMenu;
		Pixmap markerPixmap, labelPixmap;

		dShell = UIDialogForm ((char *) "Symbol Edit");
		mainForm = UIDialogFormGetMainForm (dShell);
		scrolledW = XtVaCreateManagedWidget ("UISymScrolledWindow",xmScrolledWindowWidgetClass,mainForm,
													XmNtopAttachment,		XmATTACH_FORM,
													XmNleftAttachment,	XmATTACH_FORM,
													XmNrightAttachment,	XmATTACH_FORM,
													NULL);
		list = XtVaCreateManagedWidget (UISymListName + 1,xmListWidgetClass,scrolledW,
													XmNvisibleItemCount,	6,
													XmNselectionPolicy,	XmBROWSE_SELECT,
													XmNscrollBarDisplayPolicy,	XmSTATIC,
													NULL);
		XtAddCallback (list,XmNbrowseSelectionCallback,(XtCallbackProc) _UISymbolListSelectCBK,dShell);
		string = XmStringCreate ((char *) "Symbol",UICharSetNormal);
		label = XtVaCreateManagedWidget ("UISymbolLabel",xmLabelWidgetClass,mainForm,
													XmNtopAttachment,		XmATTACH_WIDGET,
													XmNtopWidget,			scrolledW,
													XmNleftAttachment,	XmATTACH_FORM,
													XmNlabelString,		string,
													NULL);
		XmStringFree (string);
		string = XmStringCreate ((char *) "Load Names",UICharSetNormal);
		button = XtVaCreateManagedWidget (UISymLoadNamesButtonName + 1,xmPushButtonWidgetClass,mainForm,
													XmNtopAttachment,		XmATTACH_WIDGET,
													XmNtopWidget,			label,
													XmNrightAttachment,	XmATTACH_FORM,
													XmNlabelString,		string,
													NULL);
		XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UISymbolLoadNamesCBK,list);
		XmStringFree (string);
		text = XtVaCreateManagedWidget (UISymTextFieldName + 1,xmTextFieldWidgetClass,mainForm,
													XmNtopAttachment,		XmATTACH_WIDGET,
													XmNtopWidget,			label,
													XmNleftAttachment,	XmATTACH_FORM,
													XmNrightAttachment,	XmATTACH_WIDGET,
													XmNrightWidget,		button,
													XmNrightOffset,		5,
													NULL);
		XtAddCallback (text,XmNvalueChangedCallback,(XtCallbackProc) _UISymbolTextValueChangedCBK,list);
		XtAddCallback (text,XmNvalueChangedCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&changed);

		foreMenu = XmCreatePulldownMenu (mainForm,(char *) "UISymForegroundMenuPane",NULL,0);
		backMenu = XmCreatePulldownMenu (mainForm,(char *) "UISymBackgroundMenuPane",NULL,0);

		for (symNum = 0;symNum <  UIColorNum (UIColorStandard);symNum++)
			{
			foreground = UIColor (UIColorStandard,symNum);
			_UISymSetButtonString (symString,symNum);
			string = XmStringCreate (UIStandardColorName(symNum),UICharSetNormal);
			button =  XtVaCreateManagedWidget (symString + 1,xmPushButtonWidgetClass,foreMenu,
													XmNuserData,			symNum,
													XmNforeground,			foreground,
													XmNlabelString,		string,
													NULL);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UISymbolSetForegroundCBK,text);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&changed);
			button =  XtVaCreateManagedWidget (symString + 1,xmPushButtonWidgetClass,backMenu,
													XmNuserData,			symNum,
													XmNforeground,			foreground,
													XmNlabelString,		string,
													NULL);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UISymbolSetBackgroundCBK,text);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&changed);
			XmStringFree (string);
			}

		string = XmStringCreate ((char *) "Foreground:",UICharSetNormal);
		foreMenu = XtVaCreateManagedWidget (UISymForegroundMenuName + 1,xmRowColumnWidgetClass,mainForm,
													XmNtopAttachment,			XmATTACH_WIDGET,
													XmNtopWidget,				text,
													XmNrightAttachment,		XmATTACH_FORM,
													XmNsubMenuId,				foreMenu,
													XmNlabelString,			string,
													XmNrowColumnType,			XmMENU_OPTION,
													XmNtraversalOn,			false,
													NULL);
		XmStringFree (string);
		string = XmStringCreate ((char *) "Background:",UICharSetNormal);
		backMenu = XtVaCreateManagedWidget (UISymBackgroundMenuName + 1,xmRowColumnWidgetClass,mainForm,
													XmNtopAttachment,			XmATTACH_WIDGET,
													XmNtopWidget,				foreMenu,
													XmNrightAttachment,		XmATTACH_FORM,
													XmNsubMenuId,				backMenu,
													XmNlabelString,			string,
													XmNrowColumnType,			XmMENU_OPTION,
													XmNtraversalOn,			false,
													NULL);
		rowCol = XtVaCreateManagedWidget ("UISymbolRowCol",xmRowColumnWidgetClass,mainForm,
													XmNtopAttachment,			XmATTACH_WIDGET,
													XmNtopWidget,				backMenu,
													XmNrightAttachment,		XmATTACH_FORM,
													XmNbottomAttachment,		XmATTACH_FORM,
													NULL);
		XtVaGetValues (mainForm,XmNforeground,	&foreground,XmNbackground,	&background,NULL);
		xgcv.foreground = foreground;
		xgcv.background = background;
		xgcv.fill_style = FillTiled;
		gc = XCreateGC (XtDisplay (UITopLevel ()),XtWindow (UITopLevel ()),GCForeground | GCBackground | GCFillStyle,&xgcv);

		symMenu = XmCreatePulldownMenu (rowCol,(char *) "UISymShadeMenuPane",NULL,0);
		depth = DefaultDepth (XtDisplay (UITopLevel ()),DefaultScreen (XtDisplay (UITopLevel ())));
		for (symNum = 0;(xgcv.tile = UIPattern (symNum,foreground,background)) != (Pixmap) NULL;symNum++)
			{
			labelPixmap = XCreatePixmap (XtDisplay (UITopLevel ()),XtWindow (UITopLevel ()),96,24,depth);
			XChangeGC (XtDisplay (UITopLevel ()),gc,GCTile,&xgcv);
			XFillRectangle (XtDisplay (UITopLevel ()),labelPixmap,gc,0,0,96,24);
			XFreePixmap (XtDisplay (UITopLevel ()),xgcv.tile);

			_UISymSetButtonString(symString,symNum);
			button = XtVaCreateManagedWidget (symString + 1,xmPushButtonGadgetClass,symMenu,
													XmNuserData,				symNum,
													XmNlabelType,				XmPIXMAP,
													XmNlabelPixmap,			labelPixmap,
													NULL);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UISymbolSetStyleCBK,text);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&changed);
			}
		string = XmStringCreate ((char *) "Shade:",UICharSetNormal);
		symMenu = XtVaCreateWidget (UISymShadeMenuName + 1,xmRowColumnWidgetClass,rowCol,
													XmNsubMenuId,				symMenu,
													XmNlabelString,			string,
													XmNrowColumnType,			XmMENU_OPTION,
													XmNtraversalOn,			false,
													NULL);
		XmStringFree (string);

		xgcv.foreground = background;
		xgcv.fill_style = FillSolid;
		XChangeGC (XtDisplay (UITopLevel ()),gc,GCForeground | GCFillStyle,&xgcv);
		symMenu = XmCreatePulldownMenu (rowCol,(char *) "UISymMarkerMenuPane",NULL,0);
		depth = DefaultDepth (XtDisplay (UITopLevel ()),DefaultScreen (XtDisplay (UITopLevel ())));
		for (symNum = 0;(markerPixmap = UIMarker (symNum,foreground,background)) != (Pixmap) NULL;symNum++)
			{
			labelPixmap = XCreatePixmap (XtDisplay (UITopLevel ()),XtWindow (UITopLevel ()),96,24,depth);
			XFillRectangle (XtDisplay (UITopLevel ()),labelPixmap,gc,0,0,96,24);
			XCopyArea (XtDisplay (UITopLevel ()),markerPixmap,labelPixmap,gc,0,0,11,11,42,6);
			XFreePixmap (XtDisplay (UITopLevel ()),markerPixmap);
			_UISymSetButtonString(symString,symNum);
			button = XtVaCreateManagedWidget (symString + 1,xmPushButtonGadgetClass,symMenu,
													XmNuserData,				symNum,
													XmNlabelType,				XmPIXMAP,
													XmNlabelPixmap,			labelPixmap,
													NULL);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UISymbolSetStyleCBK,text);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&changed);
			}
		string = XmStringCreate ((char *) "Marker:",UICharSetNormal);
		symMenu = XtVaCreateWidget (UISymMarkerMenuName + 1,xmRowColumnWidgetClass,rowCol,
													XmNsubMenuId,				symMenu,
													XmNlabelString,			string,
													XmNrowColumnType,			XmMENU_OPTION,
													XmNtraversalOn,			false,
													NULL);
		XmStringFree (string);

		symMenu = XmCreatePulldownMenu (rowCol,(char *) "UISymLineMenuPane",NULL,0);
		depth = DefaultDepth (XtDisplay (UITopLevel ()),DefaultScreen (XtDisplay (UITopLevel ())));
		for (symNum = 0;symNum < 12;symNum++)
			{
			labelPixmap = XCreatePixmap (XtDisplay (UITopLevel ()),XtWindow (UITopLevel ()),96,24,depth);
			xgcv.foreground = background;
			xgcv.fill_style = FillSolid;
			XChangeGC (XtDisplay (UITopLevel ()),gc,GCForeground | GCFillStyle,&xgcv);
			XFillRectangle (XtDisplay (UITopLevel ()),labelPixmap,gc,0,0,96,24);
			xgcv.line_width = symNum & 0x03;
			switch (symNum >> 0x02)
				{
				case 0:	xgcv.line_style = LineSolid;		break;
				case 1:	xgcv.line_style = LineOnOffDash;	break;
				case 2:	xgcv.line_style = LineDoubleDash;	break;
				}
			xgcv.foreground = foreground;
			xgcv.background = UIColor (UIColorStandard,0);
			XChangeGC (XtDisplay (UITopLevel ()),gc,GCForeground | GCBackground | GCLineWidth | GCLineStyle,&xgcv);
			XDrawLine (XtDisplay (UITopLevel ()),labelPixmap,gc,0,12,96,12);
			_UISymSetButtonString(symString,symNum);
			button = XtVaCreateManagedWidget (symString + 1,xmPushButtonGadgetClass,symMenu,
													XmNuserData,				symNum,
													XmNlabelType,				XmPIXMAP,
													XmNlabelPixmap,			labelPixmap,
													NULL);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UISymbolSetStyleCBK,text);
			XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&changed);
			}
		string = XmStringCreate ((char *) "Line:",UICharSetNormal);
		symMenu = XtVaCreateWidget (UISymLineMenuName + 1,xmRowColumnWidgetClass,rowCol,
													XmNsubMenuId,				symMenu,
													XmNlabelString,			string,
													XmNrowColumnType,			XmMENU_OPTION,
													XmNtraversalOn,			false,
													NULL);
		XmStringFree (string);
		XtAddCallback (UIDialogFormGetOkButton (dShell),XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&save);
		}
Beispiel #5
0
static void
add_resource_to_menu (Widget menu, Resource * node, XtCallbackProc callback)
{
  int i, j;
  char *v;
  Widget sub, btn;
  Resource *r;

  for (i = 0; i < node->c; i++)
    switch (resource_type (node->v[i]))
      {
      case 101:		/* named subnode */
	n = 0;
	stdarg (XmNtearOffModel, XmTEAR_OFF_ENABLED);
	sub = XmCreatePulldownMenu (menu, node->v[i].name, args, n);
	XtSetValues (sub, args, n);
	n = 0;
	stdarg (XmNsubMenuId, sub);
	btn = XmCreateCascadeButton (menu, node->v[i].name, args, n);
	XtManageChild (btn);
	add_resource_to_menu (sub, node->v[i].subres, callback);
	break;

      case 1:			/* unnamed subres */
	n = 0;
#if 0
	if ((v = resource_value (node->v[i].subres, "fg")))
	  {
	    do_color (v, XmNforeground);
	  }
	if ((v = resource_value (node->v[i].subres, "bg")))
	  {
	    do_color (v, XmNbackground);
	  }
	if ((v = resource_value (node->v[i].subres, "font")))
	  {
	    XFontStruct *fs = XLoadQueryFont (display, v);
	    if (fs)
	      {
		XmFontList fl =
		  XmFontListCreate (fs, XmSTRING_DEFAULT_CHARSET);
		stdarg (XmNfontList, fl);
	      }
	  }
#endif
	if ((v = resource_value (node->v[i].subres, "m")))
	  {
	    stdarg (XmNmnemonic, v);
	  }
	if ((r = resource_subres (node->v[i].subres, "a")))
	  {
	    XmString as = XmStringCreateLocalized (r->v[0].value);
	    stdarg (XmNacceleratorText, as);
	    //stdarg(XmNaccelerator, r->v[1].value);
	    note_accelerator (r->v[1].value, node->v[i].subres);
	  }
	v = "button";
	for (j = 0; j < node->v[i].subres->c; j++)
	  if (resource_type (node->v[i].subres->v[j]) == 10)
	    {
	      v = node->v[i].subres->v[j].value;
	      break;
	    }
	stdarg (XmNlabelString, XmStringCreateLocalized (v));
	if (node->v[i].subres->flags & FLAG_S)
	  {
	    int nn = n;
	    stdarg (XmNtearOffModel, XmTEAR_OFF_ENABLED);
	    sub = XmCreatePulldownMenu (menu, v, args + nn, n - nn);
	    n = nn;
	    stdarg (XmNsubMenuId, sub);
	    btn = XmCreateCascadeButton (menu, "menubutton", args, n);
	    XtManageChild (btn);
	    add_resource_to_menu (sub, node->v[i].subres, callback);
	  }
	else
	  {
	    Resource *radio = resource_subres (node->v[i].subres, "radio");
	    char *checked = resource_value (node->v[i].subres, "checked");
	    char *label = resource_value (node->v[i].subres, "sensitive");
	    if (radio)
	      {
		ToggleItem *ti = (ToggleItem *) malloc (sizeof (ToggleItem));
		ti->next = toggle_items;
		ti->group = radio->v[0].value;
		ti->item = radio->v[1].value;
		ti->callback = callback;
		ti->node = node->v[i].subres;
		toggle_items = ti;

		if (resource_value (node->v[i].subres, "set"))
		  {
		    stdarg (XmNset, True);
		  }
		stdarg (XmNindicatorType, XmONE_OF_MANY);
		btn = XmCreateToggleButton (menu, "menubutton", args, n);
		ti->w = btn;
		XtAddCallback (btn, XmNvalueChangedCallback,
			       (XtCallbackProc) radio_callback,
			       (XtPointer) ti);
	      }
	    else if (checked)
	      {
		if (strchr (checked, ','))
		  stdarg (XmNindicatorType, XmONE_OF_MANY);
		else
		  stdarg (XmNindicatorType, XmN_OF_MANY);
		btn = XmCreateToggleButton (menu, "menubutton", args, n);
		XtAddCallback (btn, XmNvalueChangedCallback,
			       callback, (XtPointer) node->v[i].subres);
	      }
	    else if (label && strcmp (label, "false") == 0)
	      {
		stdarg (XmNalignment, XmALIGNMENT_BEGINNING);
		btn = XmCreateLabel (menu, "menulabel", args, n);
	      }
	    else
	      {
		btn = XmCreatePushButton (menu, "menubutton", args, n);
		XtAddCallback (btn, XmNactivateCallback,
			       callback, (XtPointer) node->v[i].subres);
	      }

	    for (j = 0; j < node->v[i].subres->c; j++)
	      switch (resource_type (node->v[i].subres->v[j]))
		{
		case 110:	/* named value = X resource */
		  {
		    char *n = node->v[i].subres->v[j].name;
		    if (strcmp (n, "fg") == 0)
		      n = "foreground";
		    if (strcmp (n, "bg") == 0)
		      n = "background";
		    if (strcmp (n, "m") == 0
			|| strcmp (n, "a") == 0
			|| strcmp (n, "sensitive") == 0)
		      break;
		    if (strcmp (n, "checked") == 0)
		      {
			note_widget_flag (btn, XmNset,
					  node->v[i].subres->v[j].value);
			break;
		      }
		    if (strcmp (n, "active") == 0)
		      {
			note_widget_flag (btn, XmNsensitive,
					  node->v[i].subres->v[j].value);
			break;
		      }
		    XtVaSetValues (btn, XtVaTypedArg,
				   n,
				   XtRString,
				   node->v[i].subres->v[j].value,
				   strlen (node->v[i].subres->v[j].value) + 1,
				   NULL);
		  }
		  break;
		}

	    XtManageChild (btn);
	  }
	break;

      case 10:			/* unnamed value */
	n = 0;
	if (node->v[i].value[0] == '@')
	  {
	    if (strcmp (node->v[i].value, "@layerview") == 0)
	      insert_layerview_buttons (menu);
	    if (strcmp (node->v[i].value, "@layerpick") == 0)
	      insert_layerpick_buttons (menu);
	    if (strcmp (node->v[i].value, "@routestyles") == 0)
	      lesstif_insert_style_buttons (menu);
	  }
	else if (strcmp (node->v[i].value, "-") == 0)
	  {
	    btn = XmCreateSeparator (menu, "sep", args, n);
	    XtManageChild (btn);
	  }
	else if (i > 0)
	  {
	    btn = XmCreatePushButton (menu, node->v[i].value, args, n);
	    XtManageChild (btn);
	  }
	break;
      }
}
Beispiel #6
0
Widget
ui_build_menu(
	Widget		parent,
	int		menu_type,
	int		num_columns,
	char		*menu_title,
	char		*menu_name,
	MenuItem	*menu_items
)
{
    Widget	menu,
   		cascade,
		widget;
    Arg		args[4];
    int 	i;
    XmString	xmlabel;
    int		n = 0;

    if (num_columns > 1)
    {
    	XtSetArg(args[n], XmNpacking, XmPACK_COLUMN);    n++;
    	XtSetArg(args[n], XmNnumColumns, num_columns);   n++;
    }
    if (menu_type == XmMENU_PULLDOWN)
	menu = XmCreatePulldownMenu(parent, "pulldown_menu", args, n);
    else
    {
	XtSetArg(args[n], XmNwhichButton, AB_BMenu); n++;
        menu = XmCreatePopupMenu(parent, "popup_menu", args, n);
    }

    if (menu_type == XmMENU_PULLDOWN)
    {
        cascade = XtVaCreateManagedWidget(menu_name,
			xmCascadeButtonWidgetClass, parent,
			XmNsubMenuId,	menu,
			NULL);

	if (menu_title)
        {
	    xmlabel = XmStringCreateLocalized(menu_title);
	    XtVaSetValues(cascade, XmNlabelString, xmlabel, NULL);
	    XmStringFree(xmlabel);
	}
    }

    for (i = 0; menu_items[i].label != NULL; i++)
    {
        if (menu_items[i].subitems)
	{
	    widget = ui_build_menu(menu, XmMENU_PULLDOWN, 
				       menu_items[i].num_columns,
			               menu_items[i].label, 
				       menu_items[i].name,
				       (MenuItem *)menu_items[i].subitems);

	    XtVaSetValues(widget, XmNuserData, (XtArgVal)menu_items[i].user_data, NULL);
	}
	else
	{
	    widget = XtVaCreateManagedWidget(menu_items[i].name,
			         *menu_items[i].wclass, 
				  menu, 
                                  XmNuserData,    (XtArgVal)menu_items[i].user_data,
				  NULL);

	    if (menu_items[i].label != NULL)
	    {
		xmlabel = XmStringCreateLocalized(menu_items[i].label);
	  	XtVaSetValues(widget, XmNlabelString, xmlabel, NULL);
	    	XmStringFree(xmlabel);
	    }
	
	    /* If label is glyph type, then change type and call
	     * routine to set glyph.
	     */
	    if (menu_items[i].label_type == AB_LABEL_GLYPH)
	    {
        	XtVaSetValues(widget, XmNlabelType, XmPIXMAP, NULL);
		dtb_set_label_from_bitmap_data(widget,
				menu_items[i].pixwidth,
				menu_items[i].pixheight,
				menu_items[i].bits);

	    }
	}

	if (menu_items[i].active == FALSE)
	    XtSetSensitive(widget, FALSE);
 	else if (menu_items[i].callback != NULL)
	    XtAddCallback(widget, XmNactivateCallback, 
				menu_items[i].callback, 
				menu_items[i].client_data);
   }

   if (menu_type == XmMENU_POPUP)
	return menu;
   else
	return cascade;
}
Beispiel #7
0
EIF_POINTER font_box_create (char * a_name, EIF_POINTER a_parent, EIF_BOOLEAN dialog)
{
	Widget form, select_form, mode_option;
	Widget mode_menu, stand_fonts_button, non_stand_fonts_button;
	Widget non_stand_list;
	Widget stand_column, frame;
	Widget form_button;
	Widget ok_button, apply_button, cancel_button;
	Widget family_menu_b, weight_menu_b, slant_menu_b;
	Widget width_menu_b, point_menu_b, resolution_menu_b;
	Widget family_menu, weight_menu, slant_menu;
	Widget width_menu, point_menu, resolution_menu;
	Widget text;
	Widget *family_menu_buttons;
	Widget *weight_menu_buttons;
	Widget *slant_menu_buttons;
	Widget *width_menu_buttons;
	Widget *point_menu_buttons;
	Widget *resolution_menu_buttons;
	font_box_data * client;
	XmString string;
	Display * display;
	int number_fonts;
	char ** fonts_list;
	char ** non_stand_fonts_list;
	int number_non_stand, number_stand;
	XmString * non_stand_strings;
	font_box_font_info ** stand_fonts_list;
	int i, j;
	char * tmp_string;
	XmString tmp_xm_string;
	char **family_menu_list;
	char **weight_menu_list;
	char **slant_menu_list;
	char **width_menu_list;
	char **point_menu_list;
	char **resolution_menu_list;
	int number_family, number_weight, number_slant;
	int number_width, number_point, number_resolution;

/*
 * Creation of form dialog
 */
	if (dialog) {
		form = XmCreateFormDialog ((Widget) a_parent, (String) a_name, NULL, 0);
		XtVaSetValues (form, XmNautoUnmanage, False, NULL);
	}
	else form = XmCreateForm ((Widget) a_parent, (String) a_name, NULL, 0);

/*
 * Creation of sub-widgets
 */
	select_form = XmCreateForm (form, "selectForm", NULL, 0);
	XtManageChild (select_form);
	text = XmCreateText (form, "text", NULL, 0);
	XtManageChild (text);
	form_button = XmCreateForm (form, "buttonsForm", NULL, 0);
	XtManageChild (form_button);
	mode_option = XmCreateOptionMenu (select_form, "switchOption", NULL, 0);
	XtManageChild (mode_option);
	mode_menu = XmCreatePulldownMenu (select_form, "switchMenu", NULL, 0);
	stand_fonts_button = XmCreatePushButtonGadget (mode_menu, "standFont", NULL, 0);
	XtManageChild (stand_fonts_button);
	non_stand_fonts_button = XmCreatePushButtonGadget (mode_menu, "nonStandFont", NULL, 0);
	XtManageChild (non_stand_fonts_button);

/*
 * Creation of non-standard font selection system
 */
	non_stand_list = XmCreateScrolledList (select_form, "nonStandList", NULL, 0);
	XtManageChild (non_stand_list);

/*
 * Creation of standard font selection system
 */
	frame = XmCreateFrame (select_form, "standFrame", NULL, 0);
	XtManageChild (frame);
	stand_column = XmCreateRowColumn (frame, "standColumn", NULL, 0);
	XtManageChild (stand_column);
	family_menu_b = XmCreateOptionMenu (stand_column, "familyMenuButton", NULL, 0);
	XtManageChild (family_menu_b);
	weight_menu_b = XmCreateOptionMenu (stand_column, "weightMenuButton", NULL, 0);
	XtManageChild (weight_menu_b);
	slant_menu_b = XmCreateOptionMenu (stand_column, "slantMenuButton", NULL, 0);
	XtManageChild (slant_menu_b);
	width_menu_b = XmCreateOptionMenu (stand_column, "widthMenuButton", NULL, 0);
	XtManageChild (width_menu_b);
	point_menu_b = XmCreateOptionMenu (stand_column, "pointMenuButton", NULL, 0);
	XtManageChild (point_menu_b);
	resolution_menu_b = XmCreateOptionMenu (stand_column, "resolutionMenuButton", NULL, 0);
	XtManageChild (resolution_menu_b);
	family_menu = XmCreatePulldownMenu (stand_column, "familyMenu", NULL, 0);
	weight_menu = XmCreatePulldownMenu (stand_column, "weightMenu", NULL, 0);
	slant_menu = XmCreatePulldownMenu (stand_column, "slantMenu", NULL, 0);
	width_menu = XmCreatePulldownMenu (stand_column, "widthMenu", NULL, 0);
	point_menu = XmCreatePulldownMenu (stand_column, "pointMenu", NULL, 0);
	resolution_menu = XmCreatePulldownMenu (stand_column, "resolutionMenu", NULL, 0);

/*
 * Creation of buttons
 */
	ok_button = XmCreatePushButtonGadget (form_button, "Ok", NULL, 0);
	XtManageChild (ok_button);
	apply_button = XmCreatePushButtonGadget (form_button, "Apply", NULL, 0);
	XtManageChild (apply_button);
	cancel_button = XmCreatePushButtonGadget (form_button, "Cancel", NULL, 0);
	XtManageChild (cancel_button);

/*
 * Attachments in font selection system
 */
	AttachTop (mode_option, 0);
	AttachLeft (mode_option, 0);
	AttachRight (mode_option, 0);

/*
 * Attachments in non-standard font selection system
 */
	AttachTopWidget (mode_option, XtParent (non_stand_list), 5);
	AttachLeft (XtParent (non_stand_list), 0);
	AttachRight (XtParent (non_stand_list), 0);
	AttachBottom (XtParent (non_stand_list), 0);

/*
 * Attachments in standard font selection system
 */
	AttachTopWidget (mode_option, frame, 5);
	AttachLeft (frame, 0);
	AttachRight (frame, 0);
	AttachBottom (frame, 0);

/*
 * Attachments in buttons form
 */
	XtVaSetValues (form_button, XmNfractionBase, 6, NULL);
	AttachTop (ok_button, 0);
	AttachBottom (ok_button, 0);
	AttachTop (apply_button, 0);
	AttachBottom (apply_button, 0);
	AttachTop (cancel_button, 0);
	AttachBottom (cancel_button, 0);

/*
 * Attachments in global form
 */
	AttachTop (select_form, 10);
	AttachLeft (select_form, 10);
	AttachRight (select_form, 10);
	AttachTopWidget (select_form, text, 10);
	AttachLeft (text, 10);
	AttachRight (text, 10);
	AttachBottomWidget (form_button, text, 10);
	AttachLeft (form_button, 10);
	AttachRight (form_button, 10);
	AttachBottom (form_button, 10);

/*
 * Default values
 */
	XtVaSetValues (family_menu_b, XmNsubMenuId, family_menu, NULL);
	XtVaSetValues (weight_menu_b, XmNsubMenuId, weight_menu, NULL);
	XtVaSetValues (slant_menu_b, XmNsubMenuId, slant_menu, NULL);
	XtVaSetValues (width_menu_b, XmNsubMenuId, width_menu, NULL);
	XtVaSetValues (point_menu_b, XmNsubMenuId, point_menu, NULL);
	XtVaSetValues (resolution_menu_b, XmNsubMenuId, resolution_menu, NULL);
	XmTextSetString (text, "Current_selected_font");
	XtVaSetValues (text, XmNresizeHeight, True, XmNeditMode, XmMULTI_LINE_EDIT, NULL);
	XtVaSetValues (XtParent (non_stand_list), XmNmappedWhenManaged, False, NULL);
	string = XmStringCreateLtoR ("Non standard fonts", XmSTRING_DEFAULT_CHARSET);
	XtVaSetValues (non_stand_fonts_button, XmNlabelString, string, NULL);
	XmStringFree (string);
	string = XmStringCreateLtoR ("Standard fonts", XmSTRING_DEFAULT_CHARSET);
	XtVaSetValues (stand_fonts_button, XmNlabelString, string, NULL);
	XmStringFree (string);
	XtVaSetValues (mode_option, XmNsubMenuId, mode_menu, NULL);
	XtVaSetValues (mode_option, XmNmenuHistory, stand_fonts_button, NULL);

/*
 * Callbacks
 */
	client = (font_box_data *) cmalloc (sizeof (font_box_data));
	XtAddCallback (non_stand_list, XmNbrowseSelectionCallback, (XtCallbackProc) font_box_select_non_stand, client);
	XtAddCallback (stand_fonts_button, XmNactivateCallback, (XtCallbackProc) font_box_switch_to_stand, client);
	XtAddCallback (non_stand_fonts_button, XmNactivateCallback, (XtCallbackProc) font_box_switch_to_non_stand, client);
	XtAddCallback (form, XmNdestroyCallback, (XtCallbackProc) font_box_destroy_action, client);

/*
 * Fill the client structure
 */
	client->non_stand_list = non_stand_list;
	client->is_stand_mode = 1;
	client->frame = frame;
	client->text = text;
	client->family_menu_b = family_menu_b;
	client->weight_menu_b = weight_menu_b;
	client->slant_menu_b = slant_menu_b;
	client->width_menu_b = width_menu_b;
	client->point_menu_b = point_menu_b;
	client->resolution_menu_b = resolution_menu_b;
	client->form = form;
	client->ok_button = ok_button;
	client->apply_button = apply_button;
	client->cancel_button = cancel_button;
	client->buttons_shown = 7;
	client->stand_fonts_button = stand_fonts_button;
	client->non_stand_fonts_button = non_stand_fonts_button;
	font_box_attach_buttons (client);

/*
 * Get the font list of current display
 */
	display = XtDisplay (form);
	fonts_list = XListFonts (display, "*", 10000, &number_fonts);

/*
 * Get the non standard fonts
 */
	number_non_stand = 0;
	for (i = 0; i < number_fonts; i++)
		if ('-' != *(fonts_list [i])) number_non_stand++;
	non_stand_strings = (XmString *) cmalloc (number_non_stand*sizeof (XmString));
	non_stand_fonts_list = (char **) cmalloc (number_non_stand*sizeof (char *));
	for (i = j = 0; i < number_fonts; i++)
		if ('-' != *(fonts_list [i])) {
			non_stand_fonts_list [j] = fonts_list [i];
			non_stand_strings [j++] = XmStringCreate (fonts_list [i], XmSTRING_DEFAULT_CHARSET);
		}
	i = 1;
	while (i)
		for (j = i = 0; j < number_non_stand-1; j++)
			if (strcmp (non_stand_fonts_list [j], non_stand_fonts_list [j+1]) > 0) {
				i = 1;
				tmp_string = non_stand_fonts_list [j];
				non_stand_fonts_list [j] = non_stand_fonts_list [j+1];
				non_stand_fonts_list [j+1] = tmp_string;
				tmp_xm_string = non_stand_strings [j];
				non_stand_strings [j] = non_stand_strings [j+1];
				non_stand_strings [j+1] = tmp_xm_string;
			}
	XmListAddItems (non_stand_list, non_stand_strings, number_non_stand, 1);
	XmListSelectPos (non_stand_list, 1, False);

/*
 * Get the standard fonts
 */
	number_stand = number_fonts-number_non_stand;
	stand_fonts_list = (font_box_font_info **) cmalloc (number_stand*sizeof (font_box_font_info *));
	for (i = j = 0; i < number_fonts; i++)
		if ('-' == *(fonts_list [i])) {
			stand_fonts_list [j++] = font_box_create_font_info (fonts_list [i]);
		}
	number_family = 0;
	number_weight = 0;
	number_slant = 0;
	number_width = 0;
	number_point = 0;
	number_resolution = 0;
	for (i = 0; i < number_stand; i++) {
		font_box_put_item (&(stand_fonts_list [i]->family), &number_family, &family_menu_list);
		font_box_put_item (&(stand_fonts_list [i]->weight), &number_weight, &weight_menu_list);
		font_box_put_item (&(stand_fonts_list [i]->slant), &number_slant, &slant_menu_list);
		font_box_put_item (&(stand_fonts_list [i]->width), &number_width, &width_menu_list);
		font_box_put_item (&(stand_fonts_list [i]->point), &number_point, &point_menu_list);
		font_box_put_item (&(stand_fonts_list [i]->resolution), &number_resolution, &resolution_menu_list);
	}
	font_box_sort_alpha (&number_family, &family_menu_list);
	font_box_sort_alpha (&number_weight, &weight_menu_list);
	font_box_sort_alpha (&number_slant, &slant_menu_list);
	font_box_sort_alpha (&number_width, &width_menu_list);
	font_box_sort_num (&number_point, &point_menu_list);
	font_box_sort_alpha (&number_resolution, &resolution_menu_list);
	font_box_fill_menu (&family_menu_buttons, family_menu, &number_family, &family_menu_list);
	font_box_fill_menu (&weight_menu_buttons, weight_menu, &number_weight, &weight_menu_list);
	font_box_fill_menu (&slant_menu_buttons, slant_menu, &number_slant, &slant_menu_list);
	font_box_fill_menu (&width_menu_buttons, width_menu, &number_width, &width_menu_list);
	font_box_fill_menu (&point_menu_buttons, point_menu, &number_point, &point_menu_list);
	font_box_fill_menu (&resolution_menu_buttons, resolution_menu, &number_resolution, &resolution_menu_list);
	for (i = 0; i < number_family; i++)
		XtAddCallback (family_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_family, client);
	for (i = 0; i < number_weight; i++)
		XtAddCallback (weight_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_weight, client);
	for (i = 0; i < number_slant; i++)
		XtAddCallback (slant_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_slant, client);
	for (i = 0; i < number_width; i++)
		XtAddCallback (width_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_width, client);
	for (i = 0; i < number_point; i++)
		XtAddCallback (point_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_point, client);
	for (i = 0; i < number_resolution; i++)
		XtAddCallback (resolution_menu_buttons [i], XmNactivateCallback, (XtCallbackProc) font_box_set_resolution, client);

/*
 * Fill the client structure
 */
	client->non_stand_fonts_list = non_stand_fonts_list;
	client->stand_fonts_list = stand_fonts_list;
	client->current_font_name = non_stand_fonts_list [0];
	client->current_stand_font = 0;
	client->current_non_stand_font = 0;
	client->family_menu_buttons = family_menu_buttons;
	client->weight_menu_buttons = weight_menu_buttons;
	client->slant_menu_buttons = slant_menu_buttons;
	client->width_menu_buttons = width_menu_buttons;
	client->point_menu_buttons = point_menu_buttons;
	client->resolution_menu_buttons = resolution_menu_buttons;
	client->family_menu_list = family_menu_list;
	client->weight_menu_list = weight_menu_list;
	client->slant_menu_list = slant_menu_list;
	client->width_menu_list = width_menu_list;
	client->point_menu_list = point_menu_list;
	client->resolution_menu_list = resolution_menu_list;
	client->number_stand = number_stand;
	client->number_family = number_family;
	client->number_weight = number_weight;
	client->number_slant = number_slant;
	client->number_width = number_width;
	client->number_point = number_point;
	client->number_resolution = number_resolution;
	client->current_font = NULL;
	client->current_family = client->current_weight = client->current_slant = -1;
	client->current_width = client->current_point = client->current_resolution = -1;
	font_box_set_family (family_menu_buttons [0], client, NULL);

	return (EIF_POINTER) client;
}
Beispiel #8
0
XSilChessWindow::XSilChessWindow(XtAppContext app, Widget toplevel,
                                 Visual * vsl, int vsldepth, Colormap cmap)
{
	char tmp[512];
	Arg al[10];
	int i;
	XmString xms;

	// Initialize member variables
	App=app;
	TopLevel=toplevel;
	Disp=XtDisplay(TopLevel);
	Vsl=vsl;
	VslDepth=vsldepth;
	CMap=cmap;
	DlgVsl=DefaultVisual(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	DlgVslDepth=DefaultDepth(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	DlgCMap=DefaultColormap(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	PixelSize=(VslDepth<=8 ? 1 : (VslDepth<=16 ? 2 : 4));
	RedMask=Vsl->red_mask;
	GreenMask=Vsl->green_mask;
	BlueMask=Vsl->blue_mask;
	SelX=SelY-1;
	IsSearching=false;
	AbortSearching=false;
	NeedPainting=false;
	IsPainting=false;
	HintWanted=false;
	HintValid=false;

	// Create main window
	MainWin=XtVaCreateManagedWidget(
		"mainWin",xmMainWindowWidgetClass,TopLevel,
		(char*)NULL
	);

	// Create main menu bar
	MainMenu=XmCreateMenuBar(MainWin,(char*)"mainMenu",NULL,0);
	XtManageChild(MainMenu);

	// Create menu item: file
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	FileMenu=XmCreatePulldownMenu(MainMenu,(char*)"fileMenu",al,3);
	BFile=XtVaCreateManagedWidget(
		"file",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,FileMenu,
		(char*)NULL
	);

	// Create menu item: file/load
	BFileLoad=XtVaCreateManagedWidget(
		"load",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileLoad,XmNactivateCallback,HandleCallback,this);

	// Create menu item: file/save
	BFileSave=XtVaCreateManagedWidget(
		"save",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileSave,XmNactivateCallback,HandleCallback,this);

	// Create menu item: file/exit
	XtVaCreateManagedWidget(
		"separator",xmSeparatorWidgetClass,FileMenu,
		(char*)NULL
	);
	BFileExit=XtVaCreateManagedWidget(
		"exit",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileExit,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	GameMenu=XmCreatePulldownMenu(MainMenu,(char*)"gameMenu",al,3);
	BGame=XtVaCreateManagedWidget(
		"game",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,GameMenu,
		(char*)NULL
	);

	// Create menu item: game/new
	BGameNew=XtVaCreateManagedWidget(
		"new",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameNew,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/flip
	BGameFlip=XtVaCreateManagedWidget(
		"flip",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameFlip,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/undo
	BGameUndo=XtVaCreateManagedWidget(
		"undo",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameUndo,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/list
	BGameList=XtVaCreateManagedWidget(
		"list",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameList,XmNactivateCallback,HandleCallback,this);

	// Create menu item: computer
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	CompMenu=XmCreatePulldownMenu(MainMenu,(char*)"compMenu",al,3);
	BComp=XtVaCreateManagedWidget(
		"comp",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,CompMenu,
		(char*)NULL
	);

	// Create menu item: computer/hint
	BCompHint=XtVaCreateManagedWidget(
		"hint",xmPushButtonWidgetClass,CompMenu,
		(char*)NULL
	);
	XtAddCallback(BCompHint,XmNactivateCallback,HandleCallback,this);

	// Create menu item: computer/depth
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	XtSetArg(al[3],XmNradioBehavior,True);
	DepthMenu=XmCreatePulldownMenu(CompMenu,(char*)"depthMenu",al,4);
	BCompDepth=XtVaCreateManagedWidget(
		"depth",xmCascadeButtonWidgetClass,CompMenu,
		XmNsubMenuId,DepthMenu,
		(char*)NULL
	);

	// Create menu items: computer/depth/1...
	for (i=0; i<=SilChessMachine::MAX_SEARCH_DEPTH; i++) {
		sprintf(tmp,"%d",i);
		BDepth[i]=XtVaCreateManagedWidget(
			tmp,xmToggleButtonWidgetClass,DepthMenu,
			(char*)NULL
		);
		XtAddCallback(BDepth[i],XmNvalueChangedCallback,HandleCallback,this);
	}

	// Create menu item: help
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	HelpMenu=XmCreatePulldownMenu(MainMenu,(char*)"helpMenu",al,3);
	BHelp=XtVaCreateManagedWidget(
		"help",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,HelpMenu,
		(char*)NULL
	);
	XtVaSetValues(MainMenu,XmNmenuHelpWidget,BHelp,(char*)NULL);

	// Create menu item: help/about
	BHelpAbout=XtVaCreateManagedWidget(
		"about",xmPushButtonWidgetClass,HelpMenu,
		(char*)NULL
	);
	XtAddCallback(BHelpAbout,XmNactivateCallback,HandleCallback,this);

	// Create a parent for status bar and view
	MainForm=XtVaCreateManagedWidget(
		"mainForm",xmFormWidgetClass,MainWin,
		(char*)NULL
	);

	// Create status line
	StatusFrame=XtVaCreateManagedWidget(
		"statusFrame",xmFrameWidgetClass,MainForm,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNtopAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	StatusLabel=XtVaCreateManagedWidget(
		"statusLabel",xmLabelWidgetClass,StatusFrame,
		XmNalignment, XmALIGNMENT_BEGINNING,
		(char*)NULL
	);

	// Create the chess board view
	ViewFrame=XtVaCreateManagedWidget(
		"viewFrame",xmFrameWidgetClass,MainForm,
		XmNtopAttachment,XmATTACH_WIDGET,
		XmNtopWidget,StatusFrame,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	ViewArea=XtVaCreateManagedWidget(
		"viewArea",xmDrawingAreaWidgetClass,ViewFrame,
		XmNtopAttachment,XmATTACH_FORM,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	XtAddCallback(ViewArea,XmNexposeCallback,HandleCallback,this);
	XtAddCallback(ViewArea,XmNresizeCallback,HandleCallback,this);
	XtAddEventHandler(
		ViewArea,ButtonPressMask|ButtonMotionMask|ButtonReleaseMask|
		StructureNotifyMask,False,HandleEvent,this
	);
	XtVaGetValues(ViewArea,XmNwidth,&ViewWidth,(char*)NULL);
	XtVaGetValues(ViewArea,XmNheight,&ViewHeight,(char*)NULL);
	ViewWin=0;
	ViewGC=NULL;

	// Create dialog: load game
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage,True);
	LoadDialog=XmCreateFileSelectionDialog(TopLevel,(char*)"loadDialog",al,4);
	XtAddCallback(LoadDialog,XmNokCallback,HandleCallback,this);
	XtUnmanageChild(XmFileSelectionBoxGetChild(LoadDialog,XmDIALOG_HELP_BUTTON));

	// Create dialog: save game
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	SaveDialog=XmCreateFileSelectionDialog(TopLevel,(char*)"saveDialog",al,4);
	XtAddCallback(SaveDialog,XmNokCallback,HandleCallback,this);
	XtUnmanageChild(XmFileSelectionBoxGetChild(SaveDialog,XmDIALOG_HELP_BUTTON));

	// Create dialog: file exists, overwrite?
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	OverwriteDialog=XmCreateWarningDialog(TopLevel,(char*)"overwriteDialog",al,4);
	XtUnmanageChild(XmMessageBoxGetChild(OverwriteDialog,XmDIALOG_HELP_BUTTON));
	XtAddCallback(OverwriteDialog,XmNokCallback,HandleCallback,this);

	// Create dialog: error message
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	ErrorBox=XmCreateWarningDialog(TopLevel,(char*)"errorBox",al,4);
	XtUnmanageChild(XmMessageBoxGetChild(ErrorBox,XmDIALOG_CANCEL_BUTTON));
	XtUnmanageChild(XmMessageBoxGetChild(ErrorBox,XmDIALOG_HELP_BUTTON));

	// Create dialog: list of moves
	ListDialogPopup=XtVaCreateWidget(
		"listDialog_popup",xmDialogShellWidgetClass,TopLevel,
		XmNvisual,DlgVsl,
		XmNdepth,DlgVslDepth,
		XmNcolormap,DlgCMap,
		(char*)NULL
	);
	ListDialog=XtVaCreateWidget(
		"listDialog",xmFormWidgetClass,ListDialogPopup,
		(char*)NULL
	);
	LDClose=XtVaCreateManagedWidget(
		"close",xmPushButtonWidgetClass,ListDialog,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	XtAddCallback(LDClose,XmNactivateCallback,HandleCallback,this);
	LDScroll=XtVaCreateManagedWidget(
		"scroll",xmScrolledWindowWidgetClass,ListDialog,
		XmNscrollingPolicy,XmAUTOMATIC,
		XmNscrollBarDisplayPolicy,XmAS_NEEDED,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNtopAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_WIDGET,
		XmNbottomWidget,LDClose,
		(char*)NULL
	);
	LDList=XtVaCreateManagedWidget(
		"list",xmLabelGadgetClass,LDScroll,
		XmNalignment,XmALIGNMENT_BEGINNING,
		(char*)NULL
	);

	// Create dialog: about
	xms=XmStringCreateLtoR((char*)AboutText,XmFONTLIST_DEFAULT_TAG);
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage,True);
	XtSetArg(al[4],XmNmessageString,xms);
	XtSetArg(al[5],XmNmessageAlignment,XmALIGNMENT_CENTER);
	AboutDialog=XmCreateMessageDialog(TopLevel,(char*)"aboutDialog",al,6);
	XmStringFree(xms);
	XtUnmanageChild(XmMessageBoxGetChild(AboutDialog,XmDIALOG_CANCEL_BUTTON));
	XtUnmanageChild(XmMessageBoxGetChild(AboutDialog,XmDIALOG_HELP_BUTTON));

	// Set main window areas
	XmMainWindowSetAreas(MainWin,MainMenu,NULL,NULL,NULL,MainForm);

	// Create chess machine
	Machine = new SilChessMachine();

	// Setup ray tracer
	RT.SetViewSize(ViewWidth,ViewHeight);
	RT.SetWorld(Machine);

	// Update all
	UpdateStatusBar();
	UpdateMovesList();
	UpdateView();
	UpdateDepthMenu();
}
Beispiel #9
0
Widget *XbrMenu(Widget parent, char *title, int menu_type,
  XbrMenuData menu_data[], int n)
{
    XtAppContext app_context = XtWidgetToApplicationContext(parent);
    Widget *widgets;
    Boolean radio_behaviour = False;
    int i, extras;
    Arg args[10];
    Cardinal num;
    XmString string;
    char name[256];

    /* Number of extra widgets to create - for a popup this is just the popup
       menu but for pulldowns there is the menu and the cascade button.
    */
    if(menu_type == XbrMENU_POPUP)
        extras = 1;
    else
        extras = 2; 
                      
    /* Allocate memory for widgets */
    if((widgets = (Widget *) malloc(sizeof(Widget) * (n+extras))) == NULL) {
        XtAppError(app_context, "Error - out of memory!\n");
        return(NULL);
    }

    /* Create menu */
    switch(menu_type) {
        case XbrMENU_POPUP:
            sprintf(name, "%sPopup", title);
            widgets[MENU] = XmCreatePopupMenu(parent, name, NULL, 0);
            break;
        case XbrMENU_OPTION:
            sprintf(name, "%sPane", title);
            widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
            num = 0; 
            string = XmStringCreateLocalized(title);
            XtSetArg(args[num], XmNsubMenuId, widgets[MENU]); num++;
            XtSetArg(args[num], XmNlabelString, string); num++;
            sprintf(name, "%sOption", title);
            widgets[CASCADE] = XmCreateOptionMenu(parent, name, args, num);
            XmStringFree(string);
            XtManageChild(widgets[CASCADE]);
            break;
        case XbrMENU_PULLDOWN_RADIO:
            radio_behaviour = True;
        case XbrMENU_PULLDOWN:
            sprintf(name, "%sPulldown", title);
            widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
            XtVaSetValues(widgets[MENU], XmNradioBehavior, radio_behaviour,
              NULL);

            /* Create menu title */
            sprintf(name, "%sCascade", title);
            widgets[CASCADE]  = XtVaCreateManagedWidget(name,
                          xmCascadeButtonWidgetClass, parent,
                          XmNsubMenuId, widgets[MENU],
                          XtVaTypedArg, XmNlabelString, XmRString,
                          title, sizeof(char *),
                          NULL);
            break;
        default:
            XtAppError(app_context, "Unknown menu type!\n");
    }

    /* Add desired widgets */
    for(i = 0; i < n; i++) {
        sprintf(name, "%s%d", title, i);
        switch(menu_data[i].type) {
            /* Label widget - easy */
            case XbrLABEL:
                string = XmStringCreateLocalized(menu_data[i].label);
                widgets[i+extras] = XtVaCreateManagedWidget(name,
                                        xmLabelWidgetClass, widgets[MENU],
                                        XmNlabelString, string,
                                        NULL);
                XmStringFree(string);
                break;

            /* Push button gadget - include activate callback & data */
            case XbrPB:
                string = XmStringCreateLocalized(menu_data[i].label);
                widgets[i+extras] = XtVaCreateManagedWidget(name,
                          xmPushButtonWidgetClass, widgets[MENU],
                          XmNlabelString, string,
                          NULL);
                XmStringFree(string);
                if(menu_data[i].callback)
                    XtAddCallback(widgets[i+extras], XmNactivateCallback,
                      menu_data[i].callback, menu_data[i].data);
                if(menu_data[i].set && menu_type == XbrMENU_OPTION)
                    XtVaSetValues(widgets[CASCADE], XmNmenuHistory, 
                        widgets[i+extras], NULL);
                break;

            /* Toggle button - include value changed callback & data */
            case XbrTOGGLE:
                num = 0;
                string = XmStringCreateLocalized(menu_data[i].label);
                XtSetArg(args[num], XmNlabelString, string); num++;
                XtSetArg(args[num], XmNindicatorType, XmONE_OF_MANY); num++;
                if(menu_data[i].set != XbrNOSET) {
                    XtSetArg(args[num], XmNset, menu_data[i].set); num++;
                } 
                widgets[i+extras] = XmCreateToggleButton(widgets[MENU], name,
                  args, num);
                XtManageChild(widgets[i+extras]);
                XmStringFree(string);
                if(menu_data[i].callback)
                    XtAddCallback(widgets[i+extras], XmNvalueChangedCallback,
                      menu_data[i].callback, menu_data[i].data);
                break;

            /* Separator to make menu look pretty! */
            case XbrSEPARATOR:
                widgets[i+extras] = XtVaCreateManagedWidget(name,
                           xmSeparatorWidgetClass, widgets[MENU],
                           NULL);
                break;

            /* A sub menu */
            case XbrSUBMENU:
                widgets[i+extras] = (Widget)XbrMenu(widgets[MENU], menu_data[i].title, menu_data[i].stype,
                  menu_data[i].submenu, menu_data[i].n);
                break;
            default:
                XtAppError(app_context, "Unknown menu item!\n");
                break;
        }
    }

    return(widgets);
}
Beispiel #10
0
Widget XNavMotif::build_menu( Widget Parent,
			      int   MenuType,
			      const char *MenuTitle,
			      void *MenuUserData,
			      void (*Callback)( Widget, XNav *, XmAnyCallbackStruct *),
			      void *CallbackData,
			      xmenu_sMenuItem *Items,
			      int *idx)
{
  Widget Menu, Cascade, W;
  int i;
  unsigned int Level;
  XmString Str;
  WidgetClass Class;
  Arg ArgList[5]; 
  XmFontList fontlist;
  XFontStruct *font;
  XmFontListEntry fontentry;

  // Set default fontlist
  font = XLoadQueryFont( flow_Display(Parent),
  	      "-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
  fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
  fontlist = XmFontListAppendEntry( NULL, fontentry);
  XtFree( (char *)fontentry);

  i = 0;
  XtSetArg(ArgList[i], XmNuserData, MenuUserData); i++;
  XtSetArg(ArgList[i], XmNbuttonFontList, fontlist); i++;
  XtSetArg(ArgList[i], XmNlabelFontList, fontlist); i++;
  if (MenuType == MENU_PULLDOWN || MenuType == MENU_OPTION)
    Menu = XmCreatePulldownMenu(Parent, (char*) "_pulldown", ArgList, i);
  else if (MenuType == MENU_POPUP)
    Menu = XmCreatePopupMenu(Parent, (char*) "_popup", ArgList, i);  
  else  {
    XtWarning("Invalid menu type passed to BuildMenu().");
    return NULL;
  }

  if (MenuType == MENU_PULLDOWN) {
    Str = XmStringCreateSimple((char*) MenuTitle);	
    Cascade = XtVaCreateManagedWidget(MenuTitle,
	    xmCascadeButtonGadgetClass, Parent,
	    XmNsubMenuId,   Menu,
	    XmNlabelString, Str,
	    NULL);
    XmStringFree(Str);
  } 
  else if (MenuType == MENU_OPTION) {
    Str = XmStringCreateSimple((char*) MenuTitle);
    XtSetArg(ArgList[0], XmNsubMenuId, Menu);
    XtSetArg(ArgList[1], XmNlabelString, Str);
    Cascade = XmCreateOptionMenu(Parent, (char*) MenuTitle, ArgList, 2);
    XmStringFree(Str);
  }

  XmFontListFree( fontlist);

  Level = Items[*idx].Level;

  for (; Items[*idx].Level != 0 && Items[*idx].Level >= Level; (*idx)++) {
    if (Items[*idx].Item == xmenu_eMenuItem_Cascade ||
      Items[*idx].Item == xmenu_eMenuItem_Ref) {
      if (MenuType == MENU_OPTION) {
        XtWarning("You can't have submenus from option menu items.");
        return NULL;
      } 
      else {
        i = *idx;
        (*idx)++;	
        build_menu(Menu, MENU_PULLDOWN, 
		   Lng::translate( Items[i].Name), MenuUserData, 
		   Callback, CallbackData, Items, idx);
        (*idx)--;
      }
    }
    else {
      if (Items[*idx].Item == xmenu_eMenuItem_Separator)
        Class = xmSeparatorGadgetClass;
      else
        Class = xmPushButtonGadgetClass;
 
      W = XtVaCreateManagedWidget(Lng::translate( Items[*idx].Name), 
		    Class, Menu,
		    XmNuserData, *idx,
		    XmNsensitive, (Boolean)(Items[*idx].Flags.f.Sensitive == 1),
		    NULL);

      if (Callback && Class == xmPushButtonGadgetClass)
        XtAddCallback(W, XmNactivateCallback, (XtCallbackProc) Callback, 
		      (XtPointer) CallbackData);
    }
  }

  return MenuType == MENU_POPUP ? Menu : Cascade;
}
Beispiel #11
0
WXWidget wxMenu::CreateMenu (wxMenuBar * menuBar,
                             WXWidget parent,
                             wxMenu * topMenu,
                             size_t WXUNUSED(index),
                             const wxString& title,
                             bool pullDown)
{
    Widget menu = (Widget) 0;
    Widget buttonWidget = (Widget) 0;
    Arg args[5];
    XtSetArg (args[0], XmNnumColumns, m_numColumns);
    XtSetArg (args[1], XmNpacking, (m_numColumns > 1) ? XmPACK_COLUMN : XmPACK_TIGHT);

    if (!pullDown)
    {
        menu = XmCreatePopupMenu ((Widget) parent, wxMOTIF_STR("popup"), args, 2);
#if 0
        XtAddCallback(menu,
            XmNunmapCallback,
            (XtCallbackProc)wxMenuPopdownCallback,
            (XtPointer)this);
#endif
    }
    else
    {
        char mnem = wxFindMnemonic (title);
        menu = XmCreatePulldownMenu ((Widget) parent, wxMOTIF_STR("pulldown"), args, 2);

        wxString title2(wxStripMenuCodes(title));
        wxXmString label_str(title2);
        buttonWidget = XtVaCreateManagedWidget(title2,
#if wxUSE_GADGETS
            xmCascadeButtonGadgetClass, (Widget) parent,
#else
            xmCascadeButtonWidgetClass, (Widget) parent,
#endif
            XmNlabelString, label_str(),
            XmNsubMenuId, menu,
            NULL);

        if (mnem != 0)
            XtVaSetValues (buttonWidget, XmNmnemonic, mnem, NULL);
    }

    m_menuWidget = (WXWidget) menu;

    m_topLevelMenu = topMenu;

    size_t i = 0;
    for ( wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
          node;
          node = node->GetNext(), ++i )
    {
        wxMenuItem *item = node->GetData();

        item->CreateItem(menu, menuBar, topMenu, i);
    }

    SetBackgroundColour(m_backgroundColour);
    SetForegroundColour(m_foregroundColour);
    SetFont(m_font);

    return buttonWidget;
}
Beispiel #12
0
DBInt UIDataHeaderForm(DBObjData *data) {
    char *text;
    DBInt i, edit;
    DBUnsigned var;
    static DBInt dataType, save, changed[10];
    static Widget dShell = NULL;
    static Widget nameTextF, subjectTextF, geoDomTextF, versionTextF;
    static Widget citRefText, citInstTextF, srcInstTextF, srcPersTextF, commentText;
    static Widget typeMenu;

    if (dShell == NULL) {
        XmString string, select;
        Widget mainForm, label, button, separator;

        var = 0;
        dShell = UIDialogForm((char *) "Data Header Information");
        mainForm = UIDialogFormGetMainForm(dShell);
        select = XmStringCreate((char *) "Select", UICharSetBold);
        string = XmStringCreate((char *) "Name:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormNameLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_FORM,
                                        XmNtopOffset, 10,
                                        XmNrightAttachment, XmATTACH_POSITION,
                                        XmNrightPosition, 25,
                                        XmNrightOffset, 10,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        nameTextF = XtVaCreateManagedWidget("UIDataHeaderFormNameText", xmTextFieldWidgetClass, mainForm,
                                            XmNtopAttachment, XmATTACH_FORM,
                                            XmNtopOffset, 10,
                                            XmNleftAttachment, XmATTACH_WIDGET,
                                            XmNleftWidget, label,
                                            XmNleftOffset, 5,
                                            XmNmaxLength, DBDataNameLen - 1,
                                            XmNcolumns, DBDataNameLen - 1,
                                            NULL);
        XtAddCallback(nameTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK, changed + var++);
        typeMenu = XmCreatePulldownMenu(mainForm, (char *) "UIDataHeaderFormTypeMenu", NULL, 0);
        for (i = 0; i < (int) (sizeof(_UIDataTypeList) / sizeof(UIButtonList)); ++i) {
            string = XmStringCreate(DBDataTypeString(_UIDataTypeList[i].ID), UICharSetNormal);
            _UIDataTypeList[i].Button = XtVaCreateManagedWidget("UIDataHeaderFormTypeButton", xmPushButtonGadgetClass,
                                                                typeMenu,
                                                                XmNuserData, _UIDataTypeList[i].ID,
                                                                XmNlabelString, string,
                                                                NULL);
            XmStringFree(string);
            XtAddCallback(_UIDataTypeList[i].Button, XmNactivateCallback, (XtCallbackProc) _UIDataHeaderFormButtonCBK,
                          &dataType);
        }
        string = XmStringCreate((char *) "Data Type:", UICharSetBold);
        typeMenu = XtVaCreateManagedWidget("UIDataHeaderFormTypeMenu", xmRowColumnWidgetClass, mainForm,
                                           XmNtopAttachment, XmATTACH_WIDGET,
                                           XmNtopWidget, nameTextF,
                                           XmNtopOffset, 2,
                                           XmNrightAttachment, XmATTACH_FORM,
                                           XmNrightOffset, 10,
                                           XmNsubMenuId, typeMenu,
                                           XmNlabelString, string,
                                           XmNrowColumnType, XmMENU_OPTION,
                                           XmNtraversalOn, false,
                                           NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) "Subject:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormSubjectLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, nameTextF,
                                        XmNtopOffset, 10,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        subjectTextF = XtVaCreateManagedWidget("UIDataHeaderFormSubjectField", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, nameTextF,
                                               XmNtopOffset, 10,
                                               XmNleftAttachment, XmATTACH_WIDGET,
                                               XmNleftWidget, label,
                                               XmNleftOffset, 5,
                                               XmNmaxLength, DBDataSubjectLen - 1,
                                               XmNcolumns, DBDataSubjectLen - 1,
                                               NULL);
        XtAddCallback(subjectTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        button = XtVaCreateManagedWidget("UIDataHeaderFormSubjectSelectButton", xmPushButtonWidgetClass, mainForm,
                                         XmNtopAttachment, XmATTACH_WIDGET,
                                         XmNtopWidget, nameTextF,
                                         XmNtopOffset, 10,
                                         XmNleftAttachment, XmATTACH_WIDGET,
                                         XmNleftWidget, subjectTextF,
                                         XmNleftOffset, 5,
                                         XmNrightAttachment, XmATTACH_WIDGET,
                                         XmNrightWidget, typeMenu,
                                         XmNrightOffset, 20,
                                         XmNlabelString, select,
                                         XmNtraversalOn, false,
                                         XmNuserData, (XtArgVal) UIDatasetSubject,
                                         NULL);
        XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) _UIDataHeaderButtonCBK, subjectTextF);


        string = XmStringCreate((char *) "Geograhic Domain:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormGeoDomainLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, subjectTextF,
                                        XmNtopOffset, 10,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        geoDomTextF = XtVaCreateManagedWidget("UIDataHeaderFormGeoField", xmTextFieldWidgetClass, mainForm,
                                              XmNtopAttachment, XmATTACH_WIDGET,
                                              XmNtopWidget, subjectTextF,
                                              XmNtopOffset, 10,
                                              XmNleftAttachment, XmATTACH_WIDGET,
                                              XmNleftWidget, label,
                                              XmNleftOffset, 5,
                                              XmNmaxLength, DBDataSubjectLen - 1,
                                              XmNcolumns, DBDataSubjectLen - 1,
                                              NULL);
        XtAddCallback(geoDomTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        button = XtVaCreateManagedWidget("UIDataHeaderFormGeoDomainSelectButton", xmPushButtonWidgetClass, mainForm,
                                         XmNtopAttachment, XmATTACH_WIDGET,
                                         XmNtopWidget, subjectTextF,
                                         XmNtopOffset, 10,
                                         XmNleftAttachment, XmATTACH_WIDGET,
                                         XmNleftWidget, geoDomTextF,
                                         XmNleftOffset, 5,
                                         XmNrightAttachment, XmATTACH_WIDGET,
                                         XmNrightWidget, typeMenu,
                                         XmNrightOffset, 20,
                                         XmNlabelString, select,
                                         XmNuserData, (XtArgVal) UIDatasetGeoDomain,
                                         XmNtraversalOn, false,
                                         NULL);
        XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) _UIDataHeaderButtonCBK, geoDomTextF);


        versionTextF = XtVaCreateManagedWidget("UIDataHeaderFormVersionText", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, subjectTextF,
                                               XmNtopOffset, 5,
                                               XmNrightAttachment, XmATTACH_FORM,
                                               XmNrightOffset, 10,
                                               XmNcolumns, DBDataVersionLen - 1,
                                               NULL);
        XtAddCallback(versionTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        string = XmStringCreate((char *) "Version:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, subjectTextF,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, versionTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        separator = XtVaCreateManagedWidget("UIDataHeaderFormSeparator", xmSeparatorWidgetClass, mainForm,
                                            XmNtopAttachment, XmATTACH_WIDGET,
                                            XmNtopWidget, geoDomTextF,
                                            XmNtopOffset, 5,
                                            XmNleftAttachment, XmATTACH_FORM,
                                            XmNleftOffset, 20,
                                            XmNrightAttachment, XmATTACH_FORM,
                                            XmNrightOffset, 20,
                                            NULL);
        string = XmStringCreate((char *) "Citation Reference:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormCitRefLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, separator,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        citRefText = XtVaCreateManagedWidget("UIDataHeaderFormCitRefText", xmTextWidgetClass, mainForm,
                                             XmNtopAttachment, XmATTACH_WIDGET,
                                             XmNtopWidget, separator,
                                             XmNtopOffset, 5,
                                             XmNleftAttachment, XmATTACH_WIDGET,
                                             XmNleftWidget, label,
                                             XmNleftOffset, 5,
                                             XmNmaxLength, DBDataCitationRefLen - 1,
                                             XmNrows, DBDataCitationRefLen / DBDataNameLen,
                                             XmNcolumns, DBDataNameLen - 1,
                                             XmNeditMode, XmMULTI_LINE_EDIT,
                                             XmNwordWrap, true,
                                             NULL);
        XtAddCallback(citRefText, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextCBK, changed + var++);
        string = XmStringCreate((char *) "Citation Institute:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormInstRefLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, citRefText,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        citInstTextF = XtVaCreateManagedWidget("UIDataHeaderFormCitInstText", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, citRefText,
                                               XmNtopOffset, 5,
                                               XmNleftAttachment, XmATTACH_WIDGET,
                                               XmNleftWidget, label,
                                               XmNleftOffset, 5,
                                               XmNmaxLength, DBDataCitationInstLen - 1,
                                               XmNcolumns, DBDataNameLen - 1,
                                               NULL);
        XtAddCallback(citInstTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        string = XmStringCreate((char *) "Source Institue:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormSourceInstLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, citInstTextF,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        srcInstTextF = XtVaCreateManagedWidget("UIDataHeaderFormSourceInstText", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, citInstTextF,
                                               XmNtopOffset, 5,
                                               XmNleftAttachment, XmATTACH_WIDGET,
                                               XmNleftWidget, label,
                                               XmNleftOffset, 5,
                                               XmNmaxLength, DBDataSourceInstLen - 1,
                                               XmNcolumns, DBDataNameLen - 1,
                                               NULL);
        XtAddCallback(srcInstTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        string = XmStringCreate((char *) "Source Person:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormSourcePersonLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, srcInstTextF,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        srcPersTextF = XtVaCreateManagedWidget("UIDataHeaderFormSourcePersText", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, srcInstTextF,
                                               XmNtopOffset, 5,
                                               XmNleftAttachment, XmATTACH_WIDGET,
                                               XmNleftWidget, label,
                                               XmNleftOffset, 5,
                                               XmNmaxLength, DBDataSourcePersonLen - 1,
                                               XmNcolumns, DBDataSourcePersonLen - 1,
                                               NULL);
        XtAddCallback(srcPersTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        string = XmStringCreate((char *) "Last Modification:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, srcInstTextF,
                                        XmNtopOffset, 5,
                                        XmNleftAttachment, XmATTACH_WIDGET,
                                        XmNleftWidget, srcPersTextF,
                                        XmNleftOffset, 10,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) "Not Set", UICharSetNormal);
        XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelGadgetClass, mainForm,
                                XmNtopAttachment, XmATTACH_WIDGET,
                                XmNtopWidget, srcInstTextF,
                                XmNtopOffset, 5,
                                XmNleftAttachment, XmATTACH_WIDGET,
                                XmNleftWidget, label,
                                XmNleftOffset, 5,
                                XmNwidth, 100,
                                XmNrecomputeSize, false,
                                XmNlabelString, string,
                                NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) "Comment:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormCommentLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, srcPersTextF,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        commentText = XtVaCreateManagedWidget("UIDataHeaderFormCommentText", xmTextWidgetClass, mainForm,
                                              XmNtopAttachment, XmATTACH_WIDGET,
                                              XmNtopWidget, srcPersTextF,
                                              XmNtopOffset, 5,
                                              XmNleftAttachment, XmATTACH_WIDGET,
                                              XmNleftWidget, label,
                                              XmNleftOffset, 5,
                                              XmNbottomAttachment, XmATTACH_FORM,
                                              XmNtopOffset, 10,
                                              XmNmaxLength, DBDataCommentLen - 1,
                                              XmNrows, DBDataCommentLen / DBDataNameLen,
                                              XmNcolumns, DBDataNameLen - 1,
                                              XmNeditMode, XmMULTI_LINE_EDIT,
                                              XmNwordWrap, true,
                                              NULL);
        XtAddCallback(commentText, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextCBK, changed + var++);
        XtAddCallback(UIDialogFormGetOkButton(dShell), XmNactivateCallback, (XtCallbackProc) UIAuxSetBooleanTrueCBK,
                      &save);
        XmStringFree(select);
    }

    edit = true;
    for (i = sizeof(_UIDataTypeList) / sizeof(UIButtonList) - 1; i >= 0; --i)
        if ((_UIDataTypeList[i].ID & data->Type()) == data->Type()) {
            XtSetSensitive(_UIDataTypeList[i].Button, true);
            XtVaSetValues(typeMenu, XmNmenuHistory, _UIDataTypeList[i].Button, NULL);
            dataType = _UIDataTypeList[i].ID;
        }
        else XtSetSensitive(_UIDataTypeList[i].Button, false);

    XtVaSetValues(nameTextF, XmNuserData, data->Name(), NULL);
    XmTextFieldSetString(nameTextF, data->Name());
    XmTextFieldSetEditable(nameTextF, edit);

    XtVaSetValues(subjectTextF, XmNuserData, data->Document(DBDocSubject), NULL);
    XmTextFieldSetString(subjectTextF, data->Document(DBDocSubject));
    XmTextFieldSetEditable(subjectTextF, edit);

    XtVaSetValues(geoDomTextF, XmNuserData, data->Document(DBDocGeoDomain), NULL);
    XmTextFieldSetString(geoDomTextF, data->Document(DBDocGeoDomain));
    XmTextFieldSetEditable(geoDomTextF, edit);

    XtVaSetValues(versionTextF, XmNuserData, data->Document(DBDocVersion), NULL);
    XmTextFieldSetString(versionTextF, data->Document(DBDocVersion));
    XmTextFieldSetEditable(versionTextF, edit);

    XtVaSetValues(citRefText, XmNuserData, data->Document(DBDocCitationRef), NULL);
    XmTextSetString(citRefText, data->Document(DBDocCitationRef));
    XmTextSetEditable(citRefText, edit);

    XtVaSetValues(citInstTextF, XmNuserData, data->Document(DBDocCitationInst), NULL);
    XmTextFieldSetString(citInstTextF, data->Document(DBDocCitationInst));
    XmTextFieldSetEditable(citInstTextF, edit);

    XtVaSetValues(srcInstTextF, XmNuserData, data->Document(DBDocSourceInst), NULL);
    XmTextFieldSetString(srcInstTextF, data->Document(DBDocSourceInst));
    XmTextFieldSetEditable(srcInstTextF, edit);

    XtVaSetValues(srcPersTextF, XmNuserData, data->Document(DBDocSourcePerson), NULL);
    XmTextFieldSetString(srcPersTextF, data->Document(DBDocSourcePerson));
    XmTextFieldSetEditable(srcPersTextF, edit);

    XtVaSetValues(commentText, XmNuserData, data->Document(DBDocComment), NULL);
    XmTextSetString(commentText, data->Document(DBDocComment));
    XmTextSetEditable(commentText, edit);

    save = false;
    XmProcessTraversal(nameTextF, XmTRAVERSE_CURRENT);
    UIDialogFormPopup(dShell);
    for (i = 0; i < (int) (sizeof(changed) / sizeof(int)); ++i) changed[i] = false;
    while (UILoop()) {
        var = 0;
        text = XmTextFieldGetString(nameTextF);
        if (strlen(text) == 0)
            XtSetSensitive(UIDialogFormGetOkButton(dShell), false);
        else {
            for (i = 0; i < (int) (sizeof(changed) / sizeof(int)); ++i)
                var = changed[i] ? var + 1 : var;
            XtSetSensitive(UIDialogFormGetOkButton(dShell), var > 0);
        }
        XtFree(text);
    }
    UIDialogFormPopdown(dShell);

    if (save) {
        text = XmTextFieldGetString(nameTextF);
        data->Name(text);
        XtFree(text);
        text = XmTextFieldGetString(subjectTextF);
        data->Document(DBDocSubject, text);
        XtFree(text);
        text = XmTextFieldGetString(geoDomTextF);
        data->Document(DBDocGeoDomain, text);
        XtFree(text);
        text = XmTextFieldGetString(versionTextF);
        data->Document(DBDocVersion, text);
        XtFree(text);
        text = XmTextGetString(citRefText);
        data->Document(DBDocCitationRef, text);
        XtFree(text);
        text = XmTextFieldGetString(citInstTextF);
        data->Document(DBDocCitationInst, text);
        XtFree(text);
        text = XmTextFieldGetString(srcInstTextF);
        data->Document(DBDocSourceInst, text);
        XtFree(text);
        text = XmTextFieldGetString(srcPersTextF);
        data->Document(DBDocSourcePerson, text);
        XtFree(text);
        text = XmTextGetString(commentText);
        data->Document(DBDocComment, text);
        XtFree(text);
        if (data->Type() != dataType) data->Type(dataType);
        return (true);
    }
    else return (false);
}
Beispiel #13
0
void RGISAnalysePointSTNPointsCBK (Widget widget,RGISWorkspace *workspace,XmAnyCallbackStruct *callData)

	{
	char *srcText;
	static DBInt cont, diffMethod;
	DBDataset *dataset;
	DBObjData *dbData;
	DBObjTable *table;
	DBObjTableField *field = (DBObjTableField *) NULL;
	static Widget dShell = NULL, mainForm, button;
	static Widget srcTextF, dstTextF, cmpTextF, errTextF;
	static Widget menu, mButton;

	if (dShell == (Widget) NULL)
		{
		XmString string;

		dShell = UIDialogForm ((char *) "Area Field",false);
		mainForm = UIDialogFormGetMainForm (dShell);

		string = XmStringCreate ((char *) "Select",UICharSetBold);
		button = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsSrcButton",xmPushButtonWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_FORM,
								XmNtopOffset,				10,
								XmNrightAttachment,		XmATTACH_FORM,
								XmNrightOffset,			10,
								XmNmarginHeight,			5,
								XmNtraversalOn,			False,
								XmNlabelString,			string,
								XmNuserData,				DBTableFieldIsNumeric,
								NULL);
		XmStringFree (string);
		srcTextF = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsSrcTextF",xmTextFieldWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_OPPOSITE_WIDGET,
								XmNtopWidget,				button,
								XmNrightAttachment,		XmATTACH_WIDGET,
								XmNrightWidget,			button,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_OPPOSITE_WIDGET,
								XmNbottomWidget,			button,
								XmNmaxLength,				DBStringLength,
								XmNcolumns,					DBStringLength / 2,
								NULL);
		XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxObjectSelectCBK,srcTextF);
		string = XmStringCreate ((char *) "Area Field:",UICharSetBold);
		XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsSrcLabel",xmLabelWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_OPPOSITE_WIDGET,
								XmNtopWidget,				button,
								XmNleftAttachment,		XmATTACH_FORM,
								XmNleftOffset,				10,
								XmNrightAttachment,		XmATTACH_WIDGET,
								XmNrightWidget,			srcTextF,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_OPPOSITE_WIDGET,
								XmNbottomWidget,			button,
								XmNlabelString,			string,
								NULL);
		XmStringFree (string);
		string = XmStringCreate ((char *) "Select",UICharSetBold);
		button = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsSrcButton",xmPushButtonWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_WIDGET,
								XmNtopWidget,				srcTextF,
								XmNtopOffset,				10,
								XmNrightAttachment,		XmATTACH_FORM,
								XmNrightOffset,			10,
								XmNmarginHeight,			5,
								XmNtraversalOn,			False,
								XmNlabelString,			string,
								XmNuserData,				DBTableFieldIsNumeric,
								NULL);
		XmStringFree (string);
		dstTextF = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsDstTextF",xmTextFieldWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_OPPOSITE_WIDGET,
								XmNtopWidget,				button,
								XmNrightAttachment,		XmATTACH_WIDGET,
								XmNrightWidget,			button,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_OPPOSITE_WIDGET,
								XmNbottomWidget,			button,
								XmNmaxLength,				DBStringLength,
								XmNcolumns,					DBStringLength / 2,
								NULL);
		XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxObjectSelectCBK,dstTextF);
		string = XmStringCreate ((char *) "Target Field:",UICharSetBold);
		XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsDstLabel",xmLabelWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_OPPOSITE_WIDGET,
								XmNtopWidget,				button,
								XmNleftAttachment,		XmATTACH_FORM,
								XmNleftOffset,				10,
								XmNrightAttachment,		XmATTACH_WIDGET,
								XmNrightWidget,			dstTextF,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_OPPOSITE_WIDGET,
								XmNbottomWidget,			button,
								XmNlabelString,			string,
								NULL);
		XmStringFree (string);

		string = XmStringCreate ((char *) "Select",UICharSetBold);
		button = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsErrorButton",xmPushButtonWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_WIDGET,
								XmNtopWidget,				dstTextF,
								XmNtopOffset,				10,
								XmNrightAttachment,		XmATTACH_FORM,
								XmNrightOffset,			10,
								XmNmarginHeight,			5,
								XmNtraversalOn,			False,
								XmNlabelString,			string,
								XmNuserData,				DBTableFieldIsNumeric,
								NULL);
		XmStringFree (string);
		cmpTextF = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsCompTextF",xmTextFieldWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_OPPOSITE_WIDGET,
								XmNtopWidget,				button,
								XmNrightAttachment,		XmATTACH_WIDGET,
								XmNrightWidget,			button,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_OPPOSITE_WIDGET,
								XmNbottomWidget,			button,
								XmNmaxLength,				DBStringLength,
								XmNcolumns,					DBStringLength / 2,
								NULL);
		XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxObjectSelectCBK,cmpTextF);

		string = XmStringCreate ((char *) "Compare Field:",UICharSetBold);
		XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsDstLabel",xmLabelWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_OPPOSITE_WIDGET,
								XmNtopWidget,				button,
								XmNleftAttachment,		XmATTACH_FORM,
								XmNleftOffset,				10,
								XmNrightAttachment,		XmATTACH_WIDGET,
								XmNrightWidget,			cmpTextF,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_OPPOSITE_WIDGET,
								XmNbottomWidget,			button,
								XmNlabelString,			string,
								NULL);
		XmStringFree (string);

		string = XmStringCreate ((char *) "Select",UICharSetBold);
		button = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsErrorButton",xmPushButtonWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_WIDGET,
								XmNtopWidget,				cmpTextF,
								XmNtopOffset,				10,
								XmNrightAttachment,		XmATTACH_FORM,
								XmNrightOffset,			10,
								XmNmarginHeight,			5,
								XmNtraversalOn,			False,
								XmNlabelString,			string,
								XmNuserData,				DBTableFieldIsNumeric,
								NULL);
		XmStringFree (string);
		errTextF = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsErrorTextF",xmTextFieldWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_OPPOSITE_WIDGET,
								XmNtopWidget,				button,
								XmNrightAttachment,		XmATTACH_WIDGET,
								XmNrightWidget,			button,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_OPPOSITE_WIDGET,
								XmNbottomWidget,			button,
								XmNmaxLength,				DBStringLength,
								XmNcolumns,					DBStringLength / 2,
								NULL);
		XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxObjectSelectCBK,errTextF);
		string = XmStringCreate ((char *) "Error Field:",UICharSetBold);
		XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsDstLabel",xmLabelWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_OPPOSITE_WIDGET,
								XmNtopWidget,				button,
								XmNleftAttachment,		XmATTACH_FORM,
								XmNleftOffset,				10,
								XmNrightAttachment,		XmATTACH_WIDGET,
								XmNrightWidget,			errTextF,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_OPPOSITE_WIDGET,
								XmNbottomWidget,			button,
								XmNlabelString,			string,
								NULL);
		XmStringFree (string);

		menu = XmCreatePulldownMenu (mainForm,(char *) "RGISAnalysePointSTNPointsMenu",NULL,0);
		string = XmStringCreate ((char *) "Plain",UICharSetNormal);
		mButton = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsMenuButton",xmPushButtonWidgetClass,menu,
								XmNlabelString,			string,
								XmNuserData,				&diffMethod,
								NULL);
		XmStringFree (string);
		XtAddCallback (mButton,XmNactivateCallback,(XtCallbackProc) UIAuxSetIntegerCBK,(XtPointer) 0);
		string = XmStringCreate ((char *) "Simple %",UICharSetNormal);
		mButton = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsMenuButton",xmPushButtonWidgetClass,menu,
								XmNlabelString,			string,
								XmNuserData,				&diffMethod,
								NULL);
		XmStringFree (string);
		XtAddCallback (mButton,XmNactivateCallback,(XtCallbackProc) UIAuxSetIntegerCBK,(XtPointer) 1);
		string = XmStringCreate ((char *) "Symmetric %",UICharSetNormal);
		mButton = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsMenuButton",xmPushButtonWidgetClass,menu,
								XmNlabelString,			string,
								XmNuserData,				&diffMethod,
								NULL);
		XmStringFree (string);
		XtAddCallback (mButton,XmNactivateCallback,(XtCallbackProc) UIAuxSetIntegerCBK,(XtPointer) 2);
		string = XmStringCreate ((char *) "Difference Method:",UICharSetBold);
		menu = XtVaCreateManagedWidget ("RGISAnalysePointSTNPointsMenu",xmRowColumnWidgetClass,mainForm,
								XmNtopAttachment,			XmATTACH_WIDGET,
								XmNtopWidget,				button,
								XmNtopOffset,				10,
								XmNrightAttachment,		XmATTACH_FORM,
								XmNrightOffset,			10,
								XmNbottomAttachment,		XmATTACH_FORM,
								XmNbottomOffset,			10,
								XmNrowColumnType,			XmMENU_OPTION,
								XmNlabelString,			string,
								XmNsubMenuId,				menu,
								NULL);
		XmStringFree (string);
		XtAddCallback (UIDialogFormGetOkButton (dShell),XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&cont);
		XtSetSensitive (UIDialogFormGetOkButton (dShell),true);
		}

	dataset = UIDataset ();
	dbData = dataset->Data ();
	table = dbData->Table (DBrNItems);
	XtVaSetValues (srcTextF,XmNuserData,table->Fields (),NULL);
	XtVaSetValues (dstTextF,XmNuserData,table->Fields (),NULL);
	XtVaSetValues (cmpTextF,XmNuserData,table->Fields (),NULL);
	XtVaSetValues (errTextF,XmNuserData,table->Fields (),NULL);
	UIDialogFormPopup (dShell);
	cont = false;
	while (UILoop ())
		{
		if ((strlen (srcText = XmTextFieldGetString (srcTextF)) > 0) &&
			 ((field = table->Field (srcText)) != (DBObjTableField *) NULL))
				XtSetSensitive (UIDialogFormGetOkButton (dShell),True);
		else	XtSetSensitive (UIDialogFormGetOkButton (dShell),False);
		XtFree (srcText);
		if ((strlen (srcText = XmTextFieldGetString (cmpTextF)) > 0) &&
			 ((field = table->Field (srcText)) != (DBObjTableField *) NULL))
			{
			XtSetSensitive (button,True);
			XtSetSensitive (errTextF,True);
			XtSetSensitive (menu,True);
			}
		else
			{
			XmTextFieldSetString (errTextF,(char *) "");
			XtSetSensitive (button,False);
			XtSetSensitive (errTextF,False);
			XtSetSensitive (menu,False);
			}
		XtFree (srcText);
		}
	UIDialogFormPopdown (dShell);
	if (cont)
		{
		char dataName [DBDataNameLen + 5];
		DBObjData *netData = dbData->LinkedData ();

		sprintf (dataName,"%s STN",dbData->Name ());
		dbData = new DBObjData (*dbData);
		dbData->Name (dataName);
		if (UIDataHeaderForm (dbData))
			{
			char *dstText;
			DBObjTable *groups;
			DBObjRecord *pointRec;

			srcText = XmTextFieldGetString (srcTextF);
			dbData->LinkedData (netData);
			table = dbData->Table (DBrNItems);
			groups = dbData->Table (DBrNGroups);
			for (pointRec = table->First ();pointRec != (DBObjRecord *) NULL;pointRec = table->Next ())
				if ((pointRec->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle)
					{
					if (groups != (DBObjTable *) NULL)
						groups->Delete (groups->Item (pointRec->RowID ()));
					table->Delete (pointRec);
					pointRec = table->Next (DBBackward);
					}

			field = table->Field (srcText);
			XtFree (srcText);
			RGlibPointSTNCoordinates (dbData,field);
			UIPauseDialogOpen ((char *) "Moving Points");
			RGlibPointSTNCharacteristics (dbData);
			UIPauseDialogClose ();
			srcText = XmTextFieldGetString (srcTextF);
			if (strlen (dstText = XmTextFieldGetString (dstTextF)) > 0)
				{
				srcText = XmTextFieldGetString (srcTextF);
				RGlibGenFuncTopoSubtract (table,RGlibNextStation,srcText,dstText);
				XtFree (dstText);
				}
			if (strlen (dstText = XmTextFieldGetString (errTextF)) > 0)
				{
				char *cmpText;
				srcText = XmTextFieldGetString (srcTextF);
				cmpText = XmTextFieldGetString (cmpTextF);
				RGlibGenFuncFieldCompare (table,srcText,cmpText,dstText,diffMethod);
				XtFree (dstText);
				XtFree (cmpText);
				}
			XtFree (srcText);
			UI2DViewRedrawAll ();
			workspace->CurrentData (dbData);
			}
		else delete dbData;
		}
	}
Beispiel #14
0
int main(int argc, char **argv)
{
    XtAppContext	app;
    Widget	top, mb, form, fc, fp, quit, s, om, mp, w;
    int		i;
    Arg		arg;
    XmString	xms;

    XtSetLanguageProc(NULL, NULL, NULL);

    toplevel = XtVaAppInitialize(&app, "Label", NULL, 0,
                                 &argc, argv, fallback, NULL);

    form = XtVaCreateManagedWidget("form", xmFormWidgetClass, toplevel,
                                   XmNwidth,		500,
                                   XmNheight,		300,
                                   XmNresizePolicy,	XmRESIZE_NONE,
                                   NULL);

    mb  = XtVaCreateManagedWidget("mb", xmRowColumnWidgetClass, form,
                                  XmNrowColumnType,	XmMENU_BAR,
                                  XmNtopAttachment,	XmATTACH_FORM,
                                  XmNleftAttachment,	XmATTACH_FORM,
                                  XmNrightAttachment,	XmATTACH_FORM,
                                  XmNbottomAttachment,	XmATTACH_NONE,
                                  NULL);

    fp = XmCreatePulldownMenu(mb, "file pulldown", NULL, 0);
    fc = XtVaCreateManagedWidget("File", xmCascadeButtonWidgetClass, mb,
                                 XmNsubMenuId,	fp,
                                 NULL);

    quit = XtVaCreateManagedWidget("Quit", xmPushButtonWidgetClass, fp,
                                   NULL);
    XtAddCallback(quit, XmNactivateCallback, Quit, NULL);

    /* Panel of scales */
    top = mb;
    for (i=0; i<XtNumber(list); i++) {
        xms = XmStringCreateSimple(list[i].name);
        s = XtVaCreateManagedWidget(list[i].name, xmScaleWidgetClass, form,
                                    XmNorientation,		XmHORIZONTAL,
                                    XmNminimum,		list[i].min,
                                    XmNmaximum,		list[i].max,
                                    XmNvalue,		list[i].initial,
                                    XmNtopAttachment,	XmATTACH_WIDGET,
                                    XmNtopWidget,		top,
                                    XmNleftAttachment,	XmATTACH_FORM,
                                    XmNrightAttachment,	XmATTACH_POSITION,
                                    XmNrightPosition,	25,
                                    XmNbottomAttachment,	XmATTACH_NONE,
                                    XmNtitleString,		xms,
                                    XmNshowValue,		True,
                                    NULL);
        XmStringFree(xms);
        top = s;
        XtAddCallback(s, XmNvalueChangedCallback, Change, (XtPointer)i);
    }

    /* Option menu for placement */
    mp = XmCreatePulldownMenu(form, "option pane", NULL, 0);

    xms = XmStringCreateSimple("Placement");
    XtSetArg(arg, XmNlabelString, xms);
    om = XmCreateOptionMenu(form, "option", &arg, 1);
    XmStringFree(xms);

    XtVaSetValues(om,
                  XmNsubMenuId,		mp,
                  XmNtopAttachment,	XmATTACH_WIDGET,
                  XmNtopWidget,		top,
                  XmNleftAttachment,	XmATTACH_FORM,
                  XmNrightAttachment,	XmATTACH_POSITION,
                  XmNrightPosition,	25,
                  XmNbottomAttachment,	XmATTACH_NONE,
                  NULL);
    XtManageChild(om);

    w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
                                XtVaTypedArg, XmNlabelString, XmRString, "TOP_RIGHT", 10,
                                NULL);
    XtAddCallback(w, XmNactivateCallback,
                  ChangePlacement, (XtPointer)XmTOP_RIGHT);
    w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
                                XtVaTypedArg, XmNlabelString, XmRString, "BOTTOM_RIGHT", 12,
                                NULL);
    XtAddCallback(w, XmNactivateCallback,
                  ChangePlacement, (XtPointer)XmBOTTOM_RIGHT);

    XtVaSetValues(om, XmNmenuHistory, w, NULL);

    w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
                                XtVaTypedArg, XmNlabelString, XmRString, "BOTTOM_LEFT", 11,
                                NULL);
    XtAddCallback(w, XmNactivateCallback,
                  ChangePlacement, (XtPointer)XmBOTTOM_LEFT);
    w = XtVaCreateManagedWidget("button", xmPushButtonWidgetClass, mp,
                                XtVaTypedArg, XmNlabelString, XmRString, "TOP_LEFT", 9,
                                NULL);
    XtAddCallback(w, XmNactivateCallback,
                  ChangePlacement, (XtPointer)XmTOP_LEFT);

    /* Create the SW */
    sw  = XtVaCreateManagedWidget("sw", xmScrolledWindowWidgetClass, form,
                                  XmNscrollingPolicy,	XmAUTOMATIC,
                                  XmNtopAttachment,	XmATTACH_WIDGET,
                                  XmNtopWidget,		mb,
                                  XmNleftAttachment,	XmATTACH_POSITION,
                                  XmNleftPosition,	25,
                                  XmNrightAttachment,	XmATTACH_NONE,
                                  XmNbottomAttachment,	XmATTACH_NONE,
                                  XmNwidth,		100,
                                  XmNheight,		100,
                                  NULL);

    ab = XtVaCreateManagedWidget("ab", xmArrowButtonWidgetClass, sw,
                                 XmNwidth,	300,
                                 XmNheight,	300,
                                 NULL);
    XtAddCallback(ab,XmNactivateCallback,cb,0);

    XtRealizeWidget(toplevel);



    {
        static XtWidgetGeometry Expected[] = {
            CWWidth | CWHeight            ,  508,  524,  500,  300, 0,0,0, /* form */
            CWWidth | CWHeight | CWX | CWY,    0,    0,  500,   31, 0,0,0, /* mb */
            CWWidth | CWHeight | CWX | CWY,    5,    5,   40,   21, 0,0,0, /* File */
            CWWidth | CWHeight | CWX | CWY,    0,   31,  125,   56, 0,0,0, /* width */
            CWWidth | CWHeight | CWX | CWY,    0,   35,   34,   17, 0,0,0, /* Title */
            CWWidth | CWHeight | CWX | CWY,    0,   16,  125,   19, 0,0,0, /* Scrollbar */
            CWWidth | CWHeight | CWX | CWY,    0,   87,  125,   56, 0,0,0, /* height */
            CWWidth | CWHeight | CWX | CWY,    0,   35,   40,   17, 0,0,0, /* Title */
            CWWidth | CWHeight | CWX | CWY,    0,   16,  125,   19, 0,0,0, /* Scrollbar */
            CWWidth | CWHeight | CWX | CWY,    0,  143,  125,   56, 0,0,0, /* spacing */
            CWWidth | CWHeight | CWX | CWY,    0,   35,   46,   17, 0,0,0, /* Title */
            CWWidth | CWHeight | CWX | CWY,    0,   16,  125,   19, 0,0,0, /* Scrollbar */
            CWWidth | CWHeight | CWX | CWY,    0,  199,  125,   56, 0,0,0, /* shadowThickness */
            CWWidth | CWHeight | CWX | CWY,    0,   35,   94,   17, 0,0,0, /* Title */
            CWWidth | CWHeight | CWX | CWY,    0,   16,  125,   19, 0,0,0, /* Scrollbar */
            CWWidth | CWHeight | CWX | CWY,    0,  255,  125,   31, 0,0,0, /* option */
            CWWidth | CWHeight | CWX | CWY,    3,    3,   58,   25, 0,0,0, /* OptionLabel */
            CWWidth | CWHeight | CWX | CWY,   64,    3,  109,   25, 0,0,0, /* OptionButton */
            CWWidth | CWHeight | CWX | CWY,  125,   31,  100,  100, 0,0,0, /* sw */
            CWWidth | CWHeight | CWX | CWY,    4,    4,   69,   69, 0,0,0, /* ScrolledWindowClipWindow */
            CWWidth | CWHeight | CWX | CWY,    0,    0,  300,  300, 0,0,0, /* ab */
            CWWidth | CWHeight | CWX | CWY,   81,    0,   19,   77, 0,0,0, /* VertScrollBar */
            CWWidth | CWHeight | CWX | CWY,    0,   81,   77,   19, 0,0,0, /* HorScrollBar */
        };
        PrintDetails(toplevel,Expected);
    };
    LessTifTestMainLoop(toplevel);

    exit(0);
}
Beispiel #15
0
int
main(int argc, char **argv)
{
  Widget	toplevel, form, mb, tf, sl, st, cb, menu, pb;
  XtAppContext	app;
  Arg		al[10];
  int		ac;

  XtSetLanguageProc(NULL, NULL, NULL);

  toplevel = XtVaAppInitialize(&app, "Phone", NULL, 0, &argc, argv, NULL, NULL);

  form = XtVaCreateManagedWidget("form", xmFormWidgetClass, toplevel,
		XmNwidth,		450,
		XmNheight,		300,
		XmNresizable,		True,
		XmNfractionBase,	3,
	NULL);

  mb = XtVaCreateManagedWidget("mb", xmRowColumnWidgetClass, form,
		XmNtopAttachment,	XmATTACH_FORM,
		XmNtopOffset,		0,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNleftOffset,		0,
		XmNrightAttachment,	XmATTACH_FORM,
		XmNrightOffset,		0,
		XmNrowColumnType,	XmMENU_BAR,
	NULL);

  tf = XtVaCreateManagedWidget("tf", xmTextFieldWidgetClass, form,
		XmNtopAttachment,	XmATTACH_WIDGET,
		XmNtopOffset,		0,
		XmNtopWidget,		mb,
		XmNleftAttachment,	XmATTACH_FORM,
		XmNleftOffset,		0,
		XmNrightAttachment,	XmATTACH_FORM,
		XmNrightOffset,		0,
	NULL);

  ac = 0;
  XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  XtSetArg(al[ac], XmNtopWidget, tf); ac++;
  XtSetArg(al[ac], XmNtopOffset, 0); ac++;
  XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  XtSetArg(al[ac], XmNleftOffset, 0); ac++;
  XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
  XtSetArg(al[ac], XmNrightPosition, 1); ac++;
  XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
  sl = XmCreateScrolledList(form, "sl", al, ac);
  XtManageChild(sl);

  ac = 0;
  XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  XtSetArg(al[ac], XmNtopWidget, tf); ac++;
  XtSetArg(al[ac], XmNtopOffset, 0); ac++;
  XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  XtSetArg(al[ac], XmNleftWidget, XtParent(sl)); ac++;
  XtSetArg(al[ac], XmNleftOffset, 0); ac++;
  XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  XtSetArg(al[ac], XmNrightOffset, 0); ac++;
  XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
  st = XmCreateScrolledText(form, "st", al, ac);
  XtManageChild(st);

  ac = 0;
  menu = XmCreatePulldownMenu(mb, "menu", al, ac);

  cb = XtVaCreateManagedWidget("cb", xmCascadeButtonGadgetClass, mb,
		XmNsubMenuId,	menu,
	NULL);

  pb = XtVaCreateManagedWidget("quit", xmPushButtonGadgetClass, menu,
	NULL);
  XtAddCallback(pb, XmNactivateCallback, Quit, NULL);

  XtRealizeWidget(toplevel);
  {
  static XtWidgetGeometry Expected[] = {
  	{CWWidth | CWHeight,		0,	0,	450,	300,	0,0,0,	/* Form */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	0,	450,	31,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	5,	5,	28,	21,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	31,	450,	31,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	62,	150,	238,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	0,	150,	238,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	150,	62,	300,	238,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	223,	300,	15,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	0,	300,	219,	0,0,0,	/* two */},
  	{CWWidth | CWHeight | CWX | CWY,	0,	0,	0,	0,	0,0,0,	/* two */},
};

  PrintDetails(toplevel, Expected);
  }

  XtAddCallback(st, XmNfocusCallback, Focus, "in");
  XtAddCallback(st, XmNlosingFocusCallback, Focus, "out");
  XtAddCallback(tf, XmNfocusCallback, Focus, "in");
  XtAddCallback(tf, XmNlosingFocusCallback, Focus, "out");

      LessTifTestMainLoop(toplevel);

  exit(0);
}
Beispiel #16
0
void setup_gui_display() 
{

  Widget hsep, sm_sep, menu, menubut, but, fsep, seph; 
  
  Widget build_opt, build_menu, build4but, build5but, build6but;
  Widget build7but, build8but;
  
  Widget prod_file_button, im_prod_lb_button, db_select_title;

  Widget all_packetbut;


  Widget filter_label; 

  Widget label2, sep;
  Widget disp_list_but, filter_list_but, label3, label5;

  Widget prod_info_frame, prod_info_hdr_lbl;
  Widget alt_src_frame, alt_src_form, alt_src_frame_label;

XmString *initlist;

   Arg args[20];
   int n=0;
   int i=0;

   XmString xmstr, labelstr, list_label_str; 

  static char* help1 = HELP_FILE_MAIN_WIN;
  static char* help2 = HELP_FILE_DISPLAY_WIN;
  static char* help3 = HELP_FILE_PROD_SPEC;
  static char* help4 = HELP_FILE_SITE_SPEC;

  static char *helpfile = HELP_FILE_PDLB_SELECT;

  static int build4 = BUILD_4_AND_EARLIER;
  static int build5 = BUILD_5;
  static int build6 = BUILD_6;
  static int build7 = BUILD_7;
  static int build8 = BUILD_8; /*  and later */


   /* end declarations */



  
  mainwin = XtVaCreateManagedWidget("mainwin",
     xmMainWindowWidgetClass, shell,
     NULL);

  form = XtVaCreateManagedWidget("form", xmFormWidgetClass, mainwin,
     NULL);

  setup_gui_colors();
  


  /* --- BEGIN MENU BAR --- */

/*  NEW MENU */
/*  Menu Bars must have homogeneous content, in order to add an option menu */
/*  at the top, the manu bar should be a child of the form rather than the */
/*  main window so it does not cross the complete top of the window */
/* //  menubar = XmCreateMenuBar(mainwin, "menubar", NULL, 0); */
  menubar = XmCreateMenuBar(form, "menubar", NULL, 0);

  XtVaSetValues(menubar,
            XmNtopAttachment,    XmATTACH_FORM,
            XmNtopOffset,        0,
            XmNbottomAttachment, XmATTACH_NONE,     
            XmNleftAttachment,   XmATTACH_FORM,
            XmNleftOffset,        0, 
            XmNrightAttachment,  XmATTACH_NONE, 
            NULL); 
        
  XtVaSetValues(XtParent(menubar),
            XmNallowShellResize,     TRUE,
            NULL); 



  /* create file menu */

  menu = XmCreatePulldownMenu(menubar, "filemenu", NULL, 0);
  menubut = XtVaCreateManagedWidget("File",xmCascadeButtonWidgetClass,menubar,
                    XmNsubMenuId, menu, NULL);
  but = XtVaCreateManagedWidget("Preferences...",xmPushButtonWidgetClass,menu,NULL); 
  XtAddCallback(but, XmNactivateCallback, pref_window_callback, NULL);
  
  fsep = XtVaCreateManagedWidget("fsep2",xmSeparatorWidgetClass,menu,NULL);  
  
  but = XtVaCreateManagedWidget("Exit",xmPushButtonWidgetClass,menu,NULL); 
  XtAddCallback(but, XmNactivateCallback, exit_callback, NULL);   
 


  /* create help menu */

  menu = XmCreatePulldownMenu(menubar, "helpmenu", NULL, 0);
  menubut = XtVaCreateManagedWidget("Help",xmCascadeButtonWidgetClass,menubar,
                    XmNsubMenuId, menu, NULL);
  but = XtVaCreateManagedWidget("About CVG",xmPushButtonWidgetClass,menu,NULL); 
  XtAddCallback(but, XmNactivateCallback, about_callback, NULL);

  seph = XtVaCreateManagedWidget("seph1",xmSeparatorWidgetClass,menu,NULL);

  but = XtVaCreateManagedWidget("Main Window",xmPushButtonWidgetClass,menu,NULL); 
  XtAddCallback(but, XmNactivateCallback, help_window_callback, help1);
  but = XtVaCreateManagedWidget("Display Window",xmPushButtonWidgetClass,menu,NULL); 
  XtAddCallback(but, XmNactivateCallback, help_window_callback, help2);
  but = XtVaCreateManagedWidget("Product Configuration",
                xmPushButtonWidgetClass,menu,NULL);
  XtAddCallback(but, XmNactivateCallback, help_window_callback, help3);
  but = XtVaCreateManagedWidget("Site Specific Information",
                xmPushButtonWidgetClass,menu,NULL);
  XtAddCallback(but, XmNactivateCallback, help_window_callback, help4);



  XtVaSetValues(menubar, XmNmenuHelpWidget, menubut, NULL);
 
  XtManageChild(menubar);

  /* --- END MENUBAR --- */



/*****************************************************************/
  labelstr = XmStringCreateLtoR("Product from ORPG ", XmFONTLIST_DEFAULT_TAG);
  build_opt = XmCreateOptionMenu(form, "build_opt", NULL, 0);
  build_menu = XmCreatePulldownMenu(form, "disp_menu", NULL, 0);

  build4but = XtVaCreateManagedWidget("Build 4 -", xmPushButtonWidgetClass, 
             build_menu, NULL);
  XtAddCallback(build4but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build4);
  
  build5but = XtVaCreateManagedWidget("Build 5   ", xmPushButtonWidgetClass, 
            build_menu, NULL);
  XtAddCallback(build5but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build5);
  
  build6but = XtVaCreateManagedWidget("Build 6   ", xmPushButtonWidgetClass, 
             build_menu, NULL);
  XtAddCallback(build6but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build6);
  
  build7but = XtVaCreateManagedWidget("Build 7   ", xmPushButtonWidgetClass, 
             build_menu, NULL);
  XtAddCallback(build7but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build7);
  
  build8but = XtVaCreateManagedWidget("Build 8 +", xmPushButtonWidgetClass, 
            build_menu, NULL);
  XtAddCallback(build8but, XmNactivateCallback, orpg_build_callback, (XtPointer) &build8);

  XtVaSetValues(build_opt, 
        XmNsubMenuId,        build_menu,
        XmNorientation,      XmHORIZONTAL,
        XmNspacing,          0,
        XmNlabelString,      labelstr,
        XmNtopAttachment,    XmATTACH_FORM,
        XmNtopOffset,        0,
        XmNbottomAttachment, XmATTACH_NONE,
        XmNrightAttachment,  XmATTACH_FORM, 
        XmNrightOffset,      5,
        XmNleftAttachment,   XmATTACH_NONE,
        NULL);

  XmStringFree(labelstr);

if(orpg_build_i <= 4)
    XtVaSetValues(build_opt, XmNmenuHistory, build4but, NULL);
else if(orpg_build_i == 5)
    XtVaSetValues(build_opt, XmNmenuHistory, build5but, NULL);
else if(orpg_build_i == 6)
    XtVaSetValues(build_opt, XmNmenuHistory, build6but, NULL);   
else if(orpg_build_i == 7)
    XtVaSetValues(build_opt, XmNmenuHistory, build7but, NULL); 
else if(orpg_build_i >= 8)
    XtVaSetValues(build_opt, XmNmenuHistory, build8but, NULL);

  XtManageChild(build_opt);

/*******************************************************************************/


  /* --- BEGIN RADIO BOX --- */
  
  screen_radio_label = XtVaCreateManagedWidget("Screen:", 
        xmLabelWidgetClass,  form,
        XmNtopAttachment,    XmATTACH_FORM,
        XmNtopOffset,        45,
        XmNbottomAttachment, XmATTACH_NONE,
        XmNleftAttachment,   XmATTACH_FORM,
        XmNleftOffset,       5,
        XmNrightAttachment,  XmATTACH_NONE,          
        NULL);  
  

  screen_radiobox = XmCreateRadioBox(form, "radioselect", NULL, 0);

  XtVaSetValues(screen_radiobox,
        XmNorientation,      XmHORIZONTAL,
        XmNpacking,          XmPACK_TIGHT,
        XmNtopAttachment,    XmATTACH_FORM,
        XmNtopOffset,        38,
        XmNbottomAttachment, XmATTACH_NONE,     
        XmNleftAttachment,   XmATTACH_WIDGET,
        XmNleftWidget,       screen_radio_label,
        XmNleftOffset,       0,
        XmNrightAttachment,  XmATTACH_NONE,
        NULL);
  XtManageChild(screen_radiobox);


  /* create the toggle buttons within the radio box */
 
  s1_radio = XtVaCreateManagedWidget("1", xmToggleButtonWidgetClass,
                     screen_radiobox, XmNset, TRUE, NULL);
  XtAddCallback(s1_radio, XmNarmCallback, screen1_radio_callback, NULL);
  
  s2_radio = XtCreateManagedWidget("2", xmToggleButtonWidgetClass,
                   screen_radiobox, NULL, 0);
  XtAddCallback(s2_radio, XmNarmCallback, screen2_radio_callback, NULL);
  
  s3_radio = XtCreateManagedWidget("Aux", xmToggleButtonWidgetClass,
                   screen_radiobox, NULL, 0);
  XtAddCallback(s3_radio, XmNarmCallback, screen3_radio_callback, NULL);
  

  /* the default settings: */
  XtSetSensitive(s1_radio, True);
  XtSetSensitive(s2_radio, False);
  XtSetSensitive(s3_radio, True);

  /* --- END RADIO BOX --- */




   alt_src_frame = XtVaCreateManagedWidget ("alternatesrcframe",
     xmFrameWidgetClass,    form,
     XmNwidth,             231,
     XmNheight,            68,
     XmNshadowType,        XmSHADOW_ETCHED_IN,
     
     XmNtopAttachment,     XmATTACH_FORM,
     XmNtopOffset,         20,
     XmNleftAttachment,   XmATTACH_WIDGET,
     XmNleftWidget,       screen_radiobox,
     XmNleftOffset,       2,
     XmNbottomAttachment,  XmATTACH_NONE,
     XmNrightAttachment,   XmATTACH_NONE,
     NULL);

  alt_src_frame_label = XtVaCreateManagedWidget ("Alternate Data Source",
    xmLabelGadgetClass,        alt_src_frame,
    XmNframeChildType,         XmFRAME_TITLE_CHILD,
    XmNchildVerticalAlignment, XmALIGNMENT_CENTER,
    NULL);



   alt_src_form = XtVaCreateManagedWidget("altform",
       xmFormWidgetClass, alt_src_frame,
       XmNwidth,             231,
       XmNheight,            68,
       NULL);

  prod_file_button = XtVaCreateManagedWidget("Product Disk File",
     xmPushButtonWidgetClass, alt_src_form,
     XmNtopAttachment,    XmATTACH_FORM,
     XmNtopOffset,        2,
     XmNleftAttachment,   XmATTACH_FORM,
     XmNleftOffset,       6,     
     XmNbottomAttachment, XmATTACH_FORM,
     XmNbottomOffset,       8, 
     XmNrightAttachment,  XmATTACH_NONE,
     XmNwidth,            bwidth-20,
     XmNheight,           bheight,
     NULL);
  XtAddCallback(prod_file_button, 
     XmNactivateCallback, diskfile_select_callback,
     NULL);



  im_prod_lb_button = XtVaCreateManagedWidget("Product LB",
     xmPushButtonWidgetClass, alt_src_form,
     XmNtopAttachment,    XmATTACH_FORM,
     XmNtopOffset,        2,
     XmNleftAttachment,   XmATTACH_WIDGET,
     XmNleftWidget,       prod_file_button,
     XmNleftOffset,       4,
     XmNrightAttachment,   XmATTACH_FORM,
     
     XmNrightOffset,       8,
     
     XmNbottomAttachment, XmATTACH_NONE,
     XmNwidth,            bwidth-55,
     XmNheight,           bheight,
     NULL);
  XtAddCallback(im_prod_lb_button, XmNactivateCallback, ilb_file_select_callback, NULL);



  /*  display all packets button, default is unset */
  all_packetbut = XtVaCreateManagedWidget("Display All Packets", 
     xmToggleButtonWidgetClass, form, 
     XmNtopAttachment,    XmATTACH_FORM,
     XmNtopOffset,        27,
     XmNleftAttachment,   XmATTACH_WIDGET,
     XmNleftWidget,       alt_src_frame,
     XmNleftOffset,       5,
     XmNbottomAttachment, XmATTACH_NONE,
     XmNrightAttachment,  XmATTACH_NONE,
     NULL);   
  
  XtAddCallback(all_packetbut, XmNvalueChangedCallback, select_all_graphic_callback, NULL);

  sm_sep = XtVaCreateManagedWidget("", xmSeparatorWidgetClass, form,
      XmNtopAttachment,      XmATTACH_WIDGET,
      XmNtopWidget,          build_opt,
      XmNtopOffset,          6,
      XmNleftAttachment,     XmATTACH_WIDGET,
      XmNleftWidget,         all_packetbut,
      XmNleftOffset,         5,       
      XmNrightAttachment,    XmATTACH_FORM, 
      XmNrightOffset,        8,
      XmNbottomAttachment,   XmATTACH_NONE,      
      NULL);

  /*  overlay button, only active if all packets are selected */
  overlay_but = XtVaCreateManagedWidget("Overlay Packets ", 
     xmToggleButtonWidgetClass, form, 
     XmNtopAttachment,    XmATTACH_FORM,
     XmNtopOffset,        49,
     XmNleftAttachment,   XmATTACH_WIDGET,
     XmNleftWidget,       alt_src_frame,
     XmNleftOffset,       23,
     XmNbottomAttachment, XmATTACH_NONE,
     XmNrightAttachment,  XmATTACH_NONE,
     NULL);  
  
  /* may not be used. instead value for is_set is read by packet_selection_manu */
  XtAddCallback(overlay_but, XmNvalueChangedCallback, overlayflag_callback, NULL);



  packet_button = XtVaCreateManagedWidget("Select Packets",
     xmPushButtonWidgetClass,form,
     XmNtopAttachment,    XmATTACH_FORM,
     XmNtopOffset,        48,
     XmNleftAttachment,   XmATTACH_WIDGET,
     XmNleftWidget,       all_packetbut,
     XmNleftOffset,       10,     
     XmNbottomAttachment, XmATTACH_NONE,
     XmNrightAttachment,  XmATTACH_NONE,
     XmNwidth,            bwidth-33,
     XmNheight,           bheight,
     NULL);
  XtAddCallback(packet_button, XmNactivateCallback, display_packetselect_callback, NULL);

   /*  initial state of the all_packetbut, overlay_but and packet_button */
   if(select_all_flag == TRUE) {
     XtVaSetValues(all_packetbut,
         XmNset,           XmSET,
         NULL);
      XtVaSetValues(overlay_but,
         XmNsensitive,     True,
         XmNset,           XmSET,
         NULL);
     XtVaSetValues(packet_button,
         XmNsensitive,     False,
         NULL);
     
   } else {
     XtVaSetValues(all_packetbut,
         XmNset,           XmUNSET,
         NULL);
     XtVaSetValues(overlay_but,
         XmNsensitive,     False,
         XmNset,           XmUNSET,
         NULL);    
     XtVaSetValues(packet_button,
         XmNsensitive,     True,
         NULL);
   }

  

 hsep = XtVaCreateManagedWidget("", xmSeparatorWidgetClass, form,
      XmNseparatorType,      XmSHADOW_ETCHED_IN,
      XmNseparatorType,      XmDOUBLE_LINE,
      XmNmargin,             20,
      XmNtopAttachment,      XmATTACH_FORM,
      XmNtopOffset,          77,
      XmNleftAttachment,     XmATTACH_FORM,
      XmNrightAttachment,    XmATTACH_FORM,
      XmNbottomAttachment,   XmATTACH_NONE,
      XmNwidth,              510,
      XmNheight,             5,
      NULL);


/*  BEGIN GUI ELEMENTS FROM DB SELECT HERE */



   db_select_title = XtVaCreateManagedWidget(" Product Database Selection Dialog ", 
     xmLabelWidgetClass, form,
     XmNtopAttachment,     XmATTACH_WIDGET,
     XmNtopWidget,         hsep,
     XmNtopOffset,         5,
     XmNleftAttachment,    XmATTACH_FORM,
     XmNleftOffset,        5,
     XmNbottomAttachment,  XmATTACH_NONE,
     XmNrightAttachment,   XmATTACH_FORM,
     XmNrightOffset,       5,
     XmNalignment,         XmALIGNMENT_CENTER,
     XmNrecomputeSize,     True,
     NULL);

    xmstr = XmStringCreateLtoR(" Product Database Selection Dialog ", "largefont"); 
    XtVaSetValues(db_select_title, XmNlabelString, xmstr, NULL);
    XmStringFree(xmstr);


/* the filter selection widgets here */


    filter_label = XtVaCreateManagedWidget("PRODUCT LIST FILTER SELECTION", 
       xmLabelWidgetClass, form,
       XmNtopAttachment,     XmATTACH_WIDGET,
       XmNtopWidget,         db_select_title,
       XmNtopOffset,         5,
       XmNleftAttachment,    XmATTACH_FORM,
       XmNleftOffset,        85,
       NULL);


    prodid_text = XtVaCreateManagedWidget("", 
       xmTextFieldWidgetClass, form, 
       XmNcolumns,           5,
       XmNmaxLength,         4,       
       XmNmarginHeight,      2,
       XmNmarginWidth,       2,
       XmNtopAttachment,     XmATTACH_WIDGET,
       XmNtopWidget,         filter_label,
       XmNtopOffset,         5,
       XmNleftAttachment,    XmATTACH_FORM,
       XmNleftOffset,        290,
       NULL);


    vol_text = XtVaCreateManagedWidget("", 
       xmTextFieldWidgetClass, form, 
       XmNcolumns,           4,
       XmNmaxLength,         3,
       XmNmarginHeight,      2,
       XmNmarginWidth,       2,
       XmNtopAttachment,     XmATTACH_OPPOSITE_WIDGET,
       XmNtopWidget,         prodid_text,
       XmNleftAttachment,    XmATTACH_FORM,
       XmNleftOffset,        40,
       NULL);



/*-------------------*/
  prod_filter_radiobox = XmCreateRadioBox(form, "filterselect", NULL, 0);

  XtVaSetValues(prod_filter_radiobox,
        XmNorientation,      XmHORIZONTAL,
        XmNpacking,          XmPACK_TIGHT,
        XmNtopAttachment,    XmATTACH_WIDGET,
        XmNtopWidget,        filter_label,
        XmNtopOffset,        2,
        XmNbottomAttachment, XmATTACH_NONE,             
        XmNrightAttachment,  XmATTACH_WIDGET,
        XmNrightWidget,      prodid_text, 
        XmNrightOffset,      0,
        NULL);
  XtManageChild(prod_filter_radiobox);
  
  /* create the toggle buttons within the radio box */
 
  prodid_radio = XtVaCreateManagedWidget("ProdID", xmToggleButtonWidgetClass,
                   prod_filter_radiobox, XmNset, TRUE, NULL);
  XtAddCallback(prodid_radio, XmNvalueChangedCallback, prodid_filter_callback, NULL);

  type_radio = XtCreateManagedWidget("Name:", xmToggleButtonWidgetClass,
                   prod_filter_radiobox, NULL, 0);
  XtAddCallback(type_radio, XmNvalueChangedCallback, type_filter_callback, NULL);
  pcode_radio = XtCreateManagedWidget("PCode:", xmToggleButtonWidgetClass,
                   prod_filter_radiobox, NULL, 0);
  XtAddCallback(pcode_radio, XmNvalueChangedCallback, pcode_filter_callback, NULL);

/*-------------------*/


              
    label2 = XtVaCreateManagedWidget("Vol:", 
       xmLabelWidgetClass, form,
       XmNtopAttachment,     XmATTACH_WIDGET,
       XmNtopWidget,         filter_label,
       XmNtopOffset,         9,
       XmNrightAttachment,   XmATTACH_WIDGET,
       XmNrightWidget,       vol_text, 
       XmNrightOffset,       3,            
       NULL);
       

  sep = XtVaCreateManagedWidget("", xmSeparatorWidgetClass, form,
       XmNseparatorType,      XmSHADOW_ETCHED_IN,
       XmNorientation,        XmVERTICAL,
       XmNmargin,             10,
       XmNtopAttachment,      XmATTACH_WIDGET,
       XmNtopWidget,          db_select_title,
       XmNtopOffset,          5,
       XmNrightAttachment,     XmATTACH_NONE,
       XmNleftAttachment,     XmATTACH_FORM,
       XmNleftOffset,         345,
       XmNbottomAttachment,   XmATTACH_NONE,
       XmNwidth,              4,
       XmNheight,             60,
       NULL);
/* end filter selection widgets */

/* display list widget */

   disp_list_but = XtVaCreateManagedWidget("Update List & Filter",
      xmPushButtonWidgetClass, form,
      XmNtopAttachment,    XmATTACH_WIDGET,
      XmNtopWidget,        db_select_title,
      XmNtopOffset,        5,
      XmNrightAttachment,  XmATTACH_NONE,
      XmNleftAttachment,   XmATTACH_WIDGET,
      XmNleftWidget,       sep,
      XmNleftOffset,       15,
      XmNwidth,            120,
      XmNheight,           25,
      NULL);
   XtAddCallback(disp_list_but, XmNactivateCallback, build_list_Callback, NULL); 
  
   XtManageChild(disp_list_but);
   
/*  Add capability to set text in disp_list_but label to red when there is */
/*  a new database list to update   Black - current, Red - new data available */


   filter_list_but = XtVaCreateManagedWidget("Apply Filter Only",
      xmPushButtonWidgetClass, form,
      XmNtopAttachment,    XmATTACH_WIDGET,
      XmNtopWidget,        db_select_title,
      XmNtopOffset,        5,
      XmNrightAttachment,  XmATTACH_NONE,
      XmNleftAttachment,   XmATTACH_WIDGET,
      XmNleftWidget,       sep,
      XmNleftOffset,       145,
      XmNwidth,            105,
      XmNheight,           25,
      NULL);
   XtAddCallback(filter_list_but, XmNactivateCallback, filter_list_Callback, NULL); 
  
    XtManageChild(filter_list_but);






label3 = XtVaCreateManagedWidget("Products   Available / Listed: ", 
       xmLabelWidgetClass, form,
       XmNtopAttachment,    XmATTACH_WIDGET, 
       XmNtopWidget,        disp_list_but,
       XmNtopOffset,        5,
       XmNleftAttachment,    XmATTACH_WIDGET,
       XmNleftWidget,        sep,
       XmNleftOffset,        15,
       XmNleftOffset,        10,
       NULL);



/* Linux Issue - Red Hat sometimes has a problem initially rendering
                 label widgets if they are allowed to resize themselves
*/

  
   num_prod_label = XtVaCreateManagedWidget("---", 
      xmLabelWidgetClass,  form,
      XmNtopAttachment,    XmATTACH_WIDGET, 
      XmNtopWidget,        disp_list_but,
      XmNtopOffset,        5,
      XmNrightAttachment,  XmATTACH_NONE,
      XmNleftAttachment,   XmATTACH_WIDGET, 
      XmNleftWidget,       label3,
      XmNleftOffset,       1,
      XmNbottomAttachment, XmATTACH_NONE,
      XmNwidth,            35,
      XmNrecomputeSize,    False,
      XmNalignment,        XmALIGNMENT_END,
      NULL);


    label5 = XtVaCreateManagedWidget("/", 
       xmLabelWidgetClass,  form,
       XmNtopAttachment,    XmATTACH_OPPOSITE_WIDGET, 
       XmNtopWidget,        num_prod_label,
       XmNleftAttachment,   XmATTACH_WIDGET, 
       XmNleftWidget,       num_prod_label,
       XmNleftOffset,       1,
       NULL);



   list_size_label = XtVaCreateManagedWidget("---", 
      xmLabelWidgetClass,  form,
      XmNtopAttachment,    XmATTACH_OPPOSITE_WIDGET,
      XmNtopWidget,        num_prod_label,
      XmNrightAttachment,  XmATTACH_NONE,
      XmNleftAttachment,   XmATTACH_WIDGET, 
      XmNleftWidget,       label5,
      XmNleftOffset,       1,
      XmNbottomAttachment, XmATTACH_NONE,
      XmNwidth,            35,
      XmNrecomputeSize,    False,
      XmNalignment,        XmALIGNMENT_END,
      NULL);





   prod_info_frame = XtVaCreateManagedWidget ("prodinfoframe",
     xmFrameWidgetClass,     form,
       XmNtopAttachment,     XmATTACH_WIDGET,
       XmNtopWidget,         list_size_label,
       XmNtopOffset,         33,
       XmNleftAttachment,    XmATTACH_FORM,
       XmNleftOffset,        3,
       XmNrightAttachment,   XmATTACH_NONE,      
       XmNbottomAttachment,  XmATTACH_NONE, 
           
     NULL);

   prod_info_label = XtVaCreateManagedWidget("  ", 
     xmLabelWidgetClass,     prod_info_frame,
     XmNalignment,           XmALIGNMENT_BEGINNING,
     XmNrecomputeSize,       False,
     XmNwidth,               598,     
     NULL);


   prod_info_hdr_lbl = XtVaCreateManagedWidget( " ", 

     xmLabelWidgetClass,        form,
       XmNbottomAttachment,     XmATTACH_WIDGET,
       XmNbottomWidget,         prod_info_frame,
       XmNbottomOffset,         2, 
       XmNleftAttachment,       XmATTACH_OPPOSITE_WIDGET,
       XmNleftWidget,           prod_info_frame,     
       XmNalignment,            XmALIGNMENT_BEGINNING,
       NULL);

/* CVG 9.0 - improve alignment of labels and list on some X-servers */
{
   char *label_buf = 
     " msg  Vol ProdID  Param1     Param2     Param3     Param4     Param5     Param6 ";
   labelstr = XmStringCreateLtoR(label_buf, "tabfont");
   XtVaSetValues(prod_info_hdr_lbl, XmNlabelString, labelstr, NULL);
   XmStringFree(labelstr);
}

/* --- DB PRODUCT SELECTION BOX  --- */


/* an initial empty list */
initlist = (XmStringTable) XtMalloc(5 * sizeof (XmString));
initlist[0] = XmStringCreateLtoR (initstr[0], "tabfont");
initlist[1] = XmStringCreateLtoR (initstr[1], "tabfont");
initlist[2] = XmStringCreateLtoR (initstr[2], "tabfont");
initlist[3] = XmStringCreateLtoR (initstr[3], "tabfont");
initlist[4] = XmStringCreateLtoR (initstr[4], "tabfont");


/*****************BEGIN ORIGINAL SELECT DILOG***********************/
   /* create dialog window */
   n=0;
   /* controls height of list area */
   XtSetArg(args[n], XmNlistVisibleItemCount, NUM_VISIBLE); n++;


   XtSetArg(args[n], XmNokLabelString,     
        XmStringCreateLtoR("Select Database Product", XmFONTLIST_DEFAULT_TAG)); n++; 

   XtSetArg(args[n], XmNhelpLabelString,     
        XmStringCreateLtoR("Database Dialog  Help", XmFONTLIST_DEFAULT_TAG)); n++; 

/* the following is critical if using selection box in application shell */
   XtSetArg(args[n], XmNdialogStyle, XmDIALOG_MODELESS); n++;
/* the following keeps this window open */   
   XtSetArg(args[n], XmNautoUnmanage,False); n++;

/* this resource should keep list from getting wider, it doesn't */
/*XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); n++; */
/* this resource prevents change in size but dramatically slows list function if window too narrow */
/*XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++; */


   db_dialog = XmCreateSelectionBox(form, "product_selectd", args, n);
   
   XtVaSetValues(db_dialog,
      XmNtopAttachment,      XmATTACH_WIDGET,
      XmNmarginHeight,       0,
      XmNmarginWidth,        0,
      XmNtopWidget,          prod_info_frame,     
      XmNtopOffset,          0,
      XmNleftAttachment,     XmATTACH_FORM,
      XmNleftOffset,         5,
      XmNrightAttachment,    XmATTACH_FORM,
      XmNrightOffset,        5,
      XmNbottomAttachment,   XmATTACH_FORM,
      XmNbottomOffset,       5,
      NULL);
   
   /* get rid of buttons 'n' stuff we don't want */
   XtUnmanageChild(XmSelectionBoxGetChild(db_dialog, XmDIALOG_SELECTION_LABEL));
   XtUnmanageChild(XmSelectionBoxGetChild(db_dialog, XmDIALOG_TEXT));
   XtUnmanageChild(XmSelectionBoxGetChild(db_dialog, XmDIALOG_APPLY_BUTTON));
   XtUnmanageChild(XmSelectionBoxGetChild(db_dialog, XmDIALOG_CANCEL_BUTTON));


   /* CVG 9.0 - improve alignment of labels and list on some X-servers */
   create_db_list_label(&list_label_str);
    
   XtVaSetValues(db_dialog,
      XmNlistLabelString,    list_label_str,
      NULL);
   XmStringFree(list_label_str);
 
   
   /* default select first item in list */
   db_list = XmSelectionBoxGetChild(db_dialog, XmDIALOG_LIST);  
 

XtVaSetValues(db_list,
/*  ATTEMPT TO DELEAY CALLBACKS UNTIL BUTTON RELEASED */
/*     XmNautomaticSelection, XmNO_AUTO_SELECT, */
    XmNautomaticSelection, XmAUTO_SELECT,

    XmNselectionPolicy,    XmBROWSE_SELECT,

    XmNitems,              initlist,
    XmNitemCount,          5,
    XmNmatchBehavior,      XmNONE,  /*  disables character match navigation */
    XmNdoubleClickInterval, 250,
    NULL);

/*  FREE initlist; */
    for(i=0; i<5; i++) 
            XmStringFree(initlist[i]);
        
        XtFree((char *)initlist); 
        initlist=NULL;

    XtAddCallback(db_list, XmNbrowseSelectionCallback, browse_select_Callback, NULL);


/*  do not add defaultActionCallback for the db_list itself! disables double click */
/*     XtAddCallback(db_list, XmNdefaultActionCallback, listselection_Callback, NULL); */

   XtAddCallback(db_dialog, XmNokCallback, listselection_Callback, NULL);

   
   
   XtAddCallback(db_dialog, XmNhelpCallback, help_window_callback, helpfile);

   
     XtManageChild(db_dialog);
/*****************END ORIGINAL SELECT DIALOG***********************/   





/*  END GUI ELEMENTS FROM DB SELECT */

  /* cleanup */

  XtVaSetValues(mainwin,

        XmNworkWindow,        form,
        
        
        NULL);

/* the top level shell has already been realized in cvg.c */
  XtRealizeWidget(mainwin);



  /* reset the colors */
  XSetForeground(display, gc, white_color);
  XSetBackground(display, gc, black_color);
  
} /* end setup_gui_display */
Beispiel #17
0
/*+++++++++++++++++++++++++++++++++++++++++++++*/
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);

}
Beispiel #18
0
Datei: menu.c Projekt: yhsesq/yhs
void create_segmentation_menu(Widget parent)
{
  Widget segmentation_menu_pane, segmentation_menu_button,
	 region_detection_button, region_detection_pane, region_growing_button,
	 grow_image_button, watershed_button, split_merge_button,
	 segmentation_sep_1, edge_detection_button, edge_detection_pane,
	 edge_sobel_button, hough_button, edge_prewitt_button, edge_frei_button,
	 edge_marr_button, edge_roberts_button, edge_vert_button,
	 edge_horiz_button, edge_hv_button, edge_unsharp_button,
	 segmentation_sep_2, mixed_methods_button, mixed_methods_pane, mixed_button,
	 region_growing_pane, grow_region_button;


   /* Create the menu pane for the menu */
  segmentation_menu_pane = XmCreatePulldownMenu(parent, "segmentation menu pane ", NULL, 0);

  /* Populate the menu pane */
  /* Region detection button */
  region_detection_pane = XmCreatePulldownMenu(segmentation_menu_pane, "region detection pane",
                              NULL, 0);


    /* Region growing button */
    region_growing_pane = XmCreatePulldownMenu(region_detection_pane,
				"region growing pane",NULL, 0);
	grow_region_button = XmCreatePushButton(region_growing_pane,
				"Grow Regions in 3D ... ", NULL, 0);
	create_region_dialog(parent);
	XtManageChild(grow_region_button);
	XtAddCallback(grow_region_button, XmNactivateCallback,
		(XtCallbackProc) activate_region_dialog, (XtPointer) NULL);

	grow_image_button = XmCreatePushButton(region_growing_pane,
				"Grow Images in 3D ... ", NULL, 0);
	XtManageChild(grow_image_button);
	XtAddCallback(grow_image_button, XmNactivateCallback,
		(XtCallbackProc) activate_image_dialog, (XtPointer) NULL);

    /* Submenus of Region Growing*/
    argcount = 0;
    XtSetArg(args[argcount], XmNsubMenuId, region_growing_pane); argcount++;
    region_growing_button = XmCreateCascadeButton(region_detection_pane,
				"Region Growing", args, argcount );
    XtManageChild(region_growing_button);

    watershed_button = XmCreatePushButton(region_detection_pane, "Watershed ", NULL, 0);
    XtManageChild(watershed_button);
    create_sigma_dialog(parent);
    XtAddCallback(watershed_button, XmNactivateCallback,
		(XtCallbackProc) activate_total_gradient_dialog, (XtPointer) NULL);

    split_merge_button = XmCreatePushButton(region_detection_pane, "Split-Merge", NULL, 0);
    create_split_dialog(parent);
/*    XtManageChild(split_merge_button); */
    XtAddCallback(split_merge_button, XmNactivateCallback,
		(XtCallbackProc) activate_split_dialog, (XtPointer) NULL);

 
/* Submenus of Region */
  argcount = 0;
  XtSetArg(args[argcount], XmNsubMenuId, region_detection_pane); argcount++;
  region_detection_button = XmCreateCascadeButton(segmentation_menu_pane, "Region Detection",
       args, argcount );
  XtManageChild(region_detection_button); 


  /* Separator 1 */
  segmentation_sep_1 = XmCreateSeparator(segmentation_menu_pane, "segmentation sep 1", NULL, 0);
  XtManageChild(segmentation_sep_1);
  
  
  /* Edge detection button */
  edge_detection_pane = XmCreatePulldownMenu(segmentation_menu_pane, "edge detection pane", NULL, 0);

  edge_sobel_button = XmCreatePushButton(edge_detection_pane, "Edge Sobel", NULL, 0);
/*  XtManageChild(edge_sobel_button); */
  XtAddCallback(edge_sobel_button, XmNactivateCallback,
		(XtCallbackProc) edge_sobel_callback, (XtPointer) NULL);

  hough_button = XmCreatePushButton(edge_detection_pane, "Hough", NULL, 0);
/*  XtManageChild(hough_button); */
  create_hough_dialog(parent); /* Dialogo*/
  XtAddCallback(hough_button, XmNactivateCallback,
		(XtCallbackProc) activate_hough_dialog, (XtPointer) NULL);

  edge_prewitt_button = XmCreatePushButton(edge_detection_pane, "Edge Prewitt", NULL, 0);
/*  XtManageChild(edge_prewitt_button); */
  XtAddCallback(edge_prewitt_button, XmNactivateCallback,
		(XtCallbackProc) edge_prewitt_callback, (XtPointer) NULL);

  edge_frei_button = XmCreatePushButton(edge_detection_pane, "Edge Frei", NULL, 0);
/*  XtManageChild(edge_frei_button); */
  XtAddCallback(edge_frei_button, XmNactivateCallback,
		(XtCallbackProc) edge_frei_callback, (XtPointer) NULL);

  edge_marr_button = XmCreatePushButton(edge_detection_pane, "Edge Marr", NULL, 0);
/*  XtManageChild(edge_marr_button); */
  XtAddCallback(edge_marr_button, XmNactivateCallback,
		(XtCallbackProc) edge_marr_callback, (XtPointer) NULL);

  edge_roberts_button = XmCreatePushButton(edge_detection_pane, "Edge Roberts", NULL, 0);
/*  XtManageChild(edge_roberts_button); */
  XtAddCallback(edge_roberts_button, XmNactivateCallback,
		(XtCallbackProc) edge_roberts_callback, (XtPointer) NULL);

  edge_vert_button = XmCreatePushButton(edge_detection_pane, "Edge Vert.", NULL, 0);
/*  XtManageChild(edge_vert_button); */
  XtAddCallback(edge_vert_button, XmNactivateCallback,
		(XtCallbackProc) edge_vert_callback, (XtPointer) NULL);

  edge_horiz_button = XmCreatePushButton(edge_detection_pane, "Erode", NULL, 0);
  XtManageChild(edge_horiz_button);
 create_edge_dilate_dialog(parent);
  XtAddCallback(edge_horiz_button, XmNactivateCallback,
		(XtCallbackProc) activate_edge_dilate_dialog, (XtPointer) NULL);

  edge_hv_button = XmCreatePushButton(edge_detection_pane, "Dilate", NULL, 0);
  XtManageChild(edge_hv_button);
  create_edge_hv_dialog(parent);
  XtAddCallback(edge_hv_button, XmNactivateCallback,
		(XtCallbackProc) activate_edge_hv_dialog, (XtPointer) NULL);

  edge_unsharp_button = XmCreatePushButton(edge_detection_pane, "Edge Unsharp", NULL, 0);
/*  XtManageChild(edge_unsharp_button); */
  XtAddCallback(edge_unsharp_button, XmNactivateCallback,
		(XtCallbackProc) edge_unsharp_callback, (XtPointer) NULL);


  /* Submenus del Edge */
  argcount = 0;
  XtSetArg(args[argcount], XmNsubMenuId, edge_detection_pane); argcount++;
  edge_detection_button = XmCreateCascadeButton(segmentation_menu_pane, "Edge Detection",
	  args, argcount );
  XtManageChild(edge_detection_button);


  /* Separator 2 */
  segmentation_sep_2 = XmCreateSeparator(segmentation_menu_pane, "segmentation sep 2", NULL, 0);
  XtManageChild(segmentation_sep_2);


  /* Mixed button */
  mixed_methods_pane = XmCreatePulldownMenu(segmentation_menu_pane, "mixed methods pane", NULL, 0);

  mixed_button = XmCreatePushButton(mixed_methods_pane, "Mixed Methods", NULL, 0);
/*  XtManageChild(mixed_button); */
/* XtAddCallback(mixed_button, XmNactivateCallback,
		(XtCallbackProc) mixed_callback, (XtPointer) NULL);
*/
 /* Submenus del Mixed */
  argcount = 0;
  XtSetArg(args[argcount], XmNsubMenuId, mixed_methods_pane); argcount++;
  mixed_methods_button = XmCreateCascadeButton(segmentation_menu_pane, "Mixed Methods",
	  args, argcount );
/*  XtManageChild(mixed_methods_button); */


  /* Create the segmentation cascade button on the menu bar and */
  /* attach the about menu pane to it.                   */
  argcount = 0;
  XtSetArg(args[argcount], XmNsubMenuId, segmentation_menu_pane); argcount++;
  segmentation_menu_button = XmCreateCascadeButton(parent, "Segmentation ",
					      args, argcount);
  XtManageChild(segmentation_menu_button);
 
}
Beispiel #19
0
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 */
Beispiel #20
0
/*F--------------------------------------------------------------------------
 *  Function:	xUIpulldown()
 *					-create a pulldown menu recursively
 *  In:			-parameters to create a pulldown
 *  out:			-
 *  Return:		-
 *---------------------------------------------------------------------------
 */
Widget *xUIpulldown( char *title, Widget menubar, MENULIST *menulist, int nitems)
{
	extern MENU menu[];

	Arg		wargs[5];
	int		i, nr;
	Widget	*buttons;
	int		separators=0;
	MENULIST	*pML;						/* direct access to a menulist item */
	XmString		xmStr;


	buttons = (Widget *)XtMalloc(nitems * sizeof(Widget));

	if (title) {
		XtCreateManagedWidget(title, xmLabelWidgetClass, menubar, 0, 0);
		XtCreateManagedWidget(SEPAR, xmSeparatorWidgetClass, menubar, 0, 0);
	}

	/*-- build for as many basic pulldown items ----*/
	for (i=0; i<nitems; i++)
		{
		pML = &menulist[i];
		xmStr = XmStringCreateLtoR(menulist[i].titel, XmSTRING_DEFAULT_CHARSET);
		XtSetArg(wargs[0], XmNlabelString, xmStr );
		XtSetArg(wargs[1], XmNancestorSensitive, menulist[i].status);
		XtSetArg(wargs[2], XmNmnemonic, menulist[i].mnemonic);

		if (!menulist[i].titel)
			{
			/*-- no titel means create a separator ------------------*/
			XtCreateManagedWidget(SEPAR, xmSeparatorWidgetClass, menubar, 0, 0);
			separators++;
			XmStringFree( xmStr);
			}
		else if (menulist[i].func)
			{
			/*-- create normal pushbutton or option/help cascade-button --------*/
			if (menulist[i].anz_subitems == 0)
				{
				/*-- case of option or help ----*/
				buttons[i-separators] = XtCreateWidget( PULLDOWN,
                                    xmCascadeButtonWidgetClass, menubar, wargs, 3);
				}
			else
				{
				buttons[i-separators] = XtCreateWidget( PULLDOWN,
                                    xmPushButtonWidgetClass,    menubar, wargs, 3);
				}
			/*--- last item is help ----*/
			if (i+1==nitems)
				{
				XtSetArg(wargs[0], XmNmenuHelpWidget, buttons[i-separators]);
				XtSetValues(menubar, wargs, 1);
				}
			XtAddCallback(buttons[i-separators], XmNactivateCallback,
							 (XtCallbackProc)menulist[i].func, (XtPointer)menulist[i].data);
			XmStringFree( xmStr);

			/*--- fill menu member "button" with created widget ---------*/
			if (menulist[i].menu == True)    /* grouplist menu */
				{
				nr = (MENU *)menulist[i].data - menu;
				menu[nr].button = buttons[i-separators];
				}
			}
		else if (!menulist[i].submenu)
			{
			/*-- no submenu  then create label leaf -------------*/
			buttons[i-separators] = XtCreateWidget( PULLDOWN,
                                        xmLabelWidgetClass, menubar, wargs, 3);
			XmStringFree( xmStr);
			}
		else
			{
			Widget submenu;
			char tmptit[] = "Submenu";
			menulist[i].submenutitle = tmptit;
			submenu = XmCreatePulldownMenu(menubar, menulist[i].submenutitle, 0, 0);
			XtSetArg(wargs[3], XmNsubMenuId, submenu);
			buttons[i-separators] = XtCreateWidget( PULLDOWN, xmCascadeButtonWidgetClass,
																menubar, wargs, 4);
			/*--- last item is help cascade button ----*/
			if (i+1==nitems)
				{
				XtSetArg(wargs[0], XmNmenuHelpWidget, buttons[i-separators]);
				XtSetValues(menubar, wargs, 1);
				}
			XmStringFree( xmStr);
			/*-- recursion call -----*/
			menulist[i].button = xUIpulldown(NULL, submenu,
														menulist[i].submenu, menulist[i].anz_subitems);
			}
		}/*for*/

	XtManageChildren(buttons, nitems-separators);
	return(buttons);
}
Beispiel #21
0
int main ( int argc, char *argv[] )
{
  XtAppContext	app_con ;

  Widget	toplevel ;
  Widget	menu_widget ;
  Widget	opt_widget ;
  Widget	button ;
  
  Arg		arg[5] ;
  Cardinal	arg_num ;
  int 		i ;
  int		val[] = { 0, 1, 2, 3, 4, 5 } ;
  int		j = 0 ;
  char 		buffer[10] ;
    
  toplevel = XtVaAppInitialize( &app_con,
    NULL,
    NULL, 0,
    &argc, argv,
    NULL,
    NULL );
    
  menu_widget = XmCreatePulldownMenu(
    toplevel, "pulldown", NULL, 0 );

#if 0
  /* 
   * if this callback is added, all subsequent callbacks get called too 
   */
  XtAddCallback( menu_widget, XmNentryCallback, entry_cb, &val[j++] );  
#endif

  arg_num = 0 ;
  XtSetArg( arg[arg_num], XmNsubMenuId, menu_widget );	arg_num++ ;
  opt_widget = XmCreateOptionMenu(
    toplevel, "options", arg, arg_num );

#if 0
  /* 
   * if this callback is added, all subsequent callbacks get called too 
   */
  XtAddCallback( menu_widget, XmNentryCallback, entry_cb, &val[j++] );  
#endif

  for ( i = 0 ; i < 5 ; i++ )
  {
    sprintf( buffer, "item%d", i );
    button = XmCreatePushButtonGadget( 
      menu_widget, buffer, NULL, 0 );
    XtManageChild( button );
  }

  XtAddCallback( menu_widget, XmNentryCallback, entry_cb, &val[j++] );  

#if 1
  /* 
   * if this button is created, lesstif doesn't call the entry callback
   * for item0 .. item4, but calls it for item5
   */
    sprintf( buffer, "item%d", i );
    button = XmCreatePushButtonGadget( 
      menu_widget, buffer, NULL, 0 );
    XtManageChild( button );
#endif

  XtManageChild( opt_widget );

  XtAddCallback( menu_widget, XmNentryCallback, entry_cb, &val[j++] );  

  XtRealizeWidget( toplevel );
  
  {
  static XtWidgetGeometry Expected[] = {
  	CWWidth | CWHeight,		0,	0,	80,	35,	0,0,0,
  	CWWidth | CWHeight | CWX | CWY,	3,	3,	4,	29,	0,0,0,
  	CWWidth | CWHeight | CWX | CWY,	10,	3,	67,	29,	0,0,0,
};

  PrintDetails(toplevel, Expected);
  }
    LessTifTestMainLoop(toplevel);
    /*
  XtAppMainLoop( app_con );
  */
  
  return 0;
}
static void CreateMenuChildren ( Widget           parent, 
                                 MenuDescription *desc, 
                                 XtPointer        defaultClientData ) 
{
    Widget  w;
    int     i;

   /*
    * Create an entry for each item in the menu.
    */
    
    for ( i=0; desc[i].type != END; i++ )  
    {
        switch ( desc[i].type ) 
        {
          case LABEL:
        
            w = XtCreateManagedWidget ( desc[i].name,
                                        xmLabelWidgetClass,
                                        parent, NULL, 0 );
            
            break;

          case BUTTON:
        
           /*
            * Create a button, and add the specified callback.
            * If the item-specific client data is NULL, add
            * the default client data passed to this function.
            */

            w = XtCreateManagedWidget ( desc[i].name,
                                        xmPushButtonWidgetClass,
                                        parent, NULL, 0 );
            XtAddCallback ( w, 
                            XmNactivateCallback,
                            desc[i].func, 
                            desc[i].data ? 
                                    desc[i].data : 
                                    defaultClientData );
            break;

          case TOGGLE:

           /*
            * Toggles are handled just like buttons, except for
            * the name of the callback list.
            */
        
            w = XtCreateManagedWidget ( desc[i].name,
                                        xmToggleButtonWidgetClass,
                                        parent, NULL, 0 );
            XtAddCallback ( w, 
                            XmNvalueChangedCallback,
                            desc[i].func, 
                            desc[i].data ?
                                   desc[i].data :
                                   defaultClientData );
            break;


          case SEPARATOR:
            
            XtCreateManagedWidget ( "separator",
                                    xmSeparatorWidgetClass,
                                    parent, NULL, 0 );
            break;

          case PULLDOWN:
          {
            Widget pulldown;

           /*
            * A pulldown requires the creation of a pulldown
            * menu pane and a cascade button. Children are added to
            * the pane by calling this function recursively.
            */
            
            pulldown = XmCreatePulldownMenu ( parent,
                                              desc[i].name,
                                              NULL, 0 );
            
            w = XtVaCreateManagedWidget ( desc[i].name,
                                          xmCascadeButtonWidgetClass,
                                          parent, 
                                          XmNsubMenuId, pulldown,
                                          NULL );
            
            CreateMenuChildren ( pulldown, desc[i].subMenu, 
                                 defaultClientData );
            break;
          } 

          	case HELPPANE:
          	{
	            Widget pulldown;

	           /*
            * A help pane can be handled just like the pulldown case,
            * but the cascade button is used as the value of 
            * the menubar's XmNmenuHelpWidget resource.
            */

	            pulldown = XmCreatePulldownMenu ( parent, desc[i].name,
						      NULL, 0 );
	    
	            w = XtVaCreateManagedWidget ( desc[i].name,
						  xmCascadeButtonWidgetClass,
						  parent, 
						  XmNsubMenuId, pulldown,
						  NULL );

	            XtVaSetValues ( parent, XmNmenuHelpWidget, w, NULL );
	    
	            CreateMenuChildren ( pulldown, desc[i].subMenu, 
                                 defaultClientData );

	            break;
          	} 

         case RADIOPULLDOWN:
         {
            Widget pulldown;

           /*
            * A radio pulldown is handled just like the pulldown case,
            * but the menu pane is set to exhibit radio behavior.
            * Items added to this pane are expected to be toggles.
            */
            
            pulldown = XmCreatePulldownMenu ( parent, desc[i].name,
                                              NULL, 0 );

            XtVaSetValues ( pulldown, XmNradioBehavior, TRUE, NULL );
            
            w = XtVaCreateManagedWidget ( desc[i].name,
                                          xmCascadeButtonWidgetClass,
                                          parent, 
                                          XmNsubMenuId, pulldown,
                                          NULL );
            
            CreateMenuChildren ( pulldown, desc[i].subMenu,
                                 defaultClientData );
            break;
         } 
       }
    }
}
Widget CreateMenu ( MenuType         menuType,
                    char            *name,
                    Widget           parent,
                    MenuDescription *desc,
                    XtPointer        defaultClientData ) 
{
    Widget w;

   /*
    * Create the basic menu widget, based on the type of
    * menu requested. Do any special setup required
    * and then call CreateMenuChildren() to populate the menu.
    */

    switch ( menuType ) 
    {
      case POPUP:

       /*
        * Popups must have an event handler registered with the
        * parent to display the menu when button 3 is pressed.
        */

        w = XmCreatePopupMenu ( parent, name, NULL, 0 );
    
        AttachPopup ( parent, w );

        CreateMenuChildren ( w, desc, defaultClientData );

        return ( w );

      case MENUBAR:

        /*
         * For menu bars, just create the menu bar, and then
         * add children. All direct children are expected
         * to be pulldown menus.
         */

         w = XmCreateMenuBar ( parent, name, NULL, 0 );

         CreateMenuChildren ( w, desc, defaultClientData );

         XtManageChild ( w );

         return ( w );
    
      case OPTION:
      {
        /*
         * All option menus have a pulldown, but it is nicer to hide
         * this, allowing the programmer to just specify the contents
         * of the pane. So, create the option menu, create and attach
         * a pulldown pane, and then call CreateMenuChildren() to
         * populate the pulldown menu pane.
         */

         Widget option = XmCreateOptionMenu ( parent, name, NULL, 0 );

         w = XmCreatePulldownMenu ( parent, name, NULL, 0 );

         XtVaSetValues ( option, XmNsubMenuId, w, NULL );

         CreateMenuChildren ( w, desc, defaultClientData );

         XtManageChild ( option );

         return ( option );
     }

      default:
        XtError ( "Invalid Menu Type" );
        return ( NULL );
    }
}
Beispiel #24
0
bool wxChoice::Create(wxWindow *parent, wxWindowID id,
                      const wxPoint& pos,
                      const wxSize& size,
                      int n, const wxString choices[],
                      long style,
                      const wxValidator& validator,
                      const wxString& name)
{
    if ( !CreateControl(parent, id, pos, size, style, validator, name) )
        return false;

    Widget parentWidget = (Widget) parent->GetClientWidget();

    m_formWidget = (WXWidget) XtVaCreateManagedWidget(name.c_str(),
        xmRowColumnWidgetClass, parentWidget,
        XmNmarginHeight, 0,
        XmNmarginWidth, 0,
        XmNpacking, XmPACK_TIGHT,
        XmNorientation, XmHORIZONTAL,
        XmNresizeWidth, False,
        XmNresizeHeight, False,
        NULL);

    XtVaSetValues ((Widget) m_formWidget, XmNspacing, 0, NULL);

    /*
    * Create the popup menu
    */
    m_menuWidget = (WXWidget) XmCreatePulldownMenu ((Widget) m_formWidget,
                                                    wxMOTIF_STR("choiceMenu"),
                                                    NULL, 0);

    if (n > 0)
    {
        int i;
        for (i = 0; i < n; i++)
            Append (choices[i]);
    }

    /*
    * Create button
    */
    Arg args[10];
    Cardinal argcnt = 0;

    XtSetArg (args[argcnt], XmNsubMenuId, (Widget) m_menuWidget); ++argcnt;
    XtSetArg (args[argcnt], XmNmarginWidth, 0); ++argcnt;
    XtSetArg (args[argcnt], XmNmarginHeight, 0); ++argcnt;
    XtSetArg (args[argcnt], XmNpacking, XmPACK_TIGHT); ++argcnt;
    m_buttonWidget = (WXWidget) XmCreateOptionMenu ((Widget) m_formWidget,
                                                    wxMOTIF_STR("choiceButton"),
                                                    args, argcnt);

    m_mainWidget = m_buttonWidget;

    XtManageChild ((Widget) m_buttonWidget);

    // New code from Roland Haenel ([email protected])
    // Some time ago, I reported a problem with wxChoice-items under
    // Linux and Motif 2.0 (they caused sporadic GPFs). Now it seems
    // that I have found the code responsible for this behaviour.
#if XmVersion >= 1002
#if XmVersion <  2000
    // JACS, 24/1/99: this seems to cause a malloc crash later on, e.g.
    // in controls sample.
    //
    // Widget optionLabel = XmOptionLabelGadget ((Widget) m_buttonWidget);
    // XtUnmanageChild (optionLabel);
#endif
#endif

    wxSize bestSize = GetBestSize();
    if( size.x > 0 ) bestSize.x = size.x;
    if( size.y > 0 ) bestSize.y = size.y;

    XtVaSetValues((Widget) m_formWidget, XmNresizePolicy, XmRESIZE_NONE, NULL);

    ChangeFont(false);
    ChangeBackgroundColour();

    AttachWidget (parent, m_buttonWidget, m_formWidget,
                  pos.x, pos.y, bestSize.x, bestSize.y);

    return true;
}
Beispiel #25
0
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();
  }
}
Beispiel #26
0
Widget NxmVolcano_menuCreate ( Widget parent, Widget textwid,
                               XtCallbackProc push_cb )
/************************************************************************
 * NxmVolcano_menuCreate                                                *
 *                                                                      *
 * This function creates a volcano list menu.                           *
 *                                                                      *
 * Widget NxmVolcano_menuCreate(parent, textwid, push_cb)               *
 *                                                                      *
 * Input parameters:                                                    *
 *  parent        Widget  parent widget ID                              *
 *  textwid       Widget  text field id on the left side                *
 *  (*push_cb)()  void    callback function for push btn                *
 *                                                                      *
 * Output parameters:                                                   *
 *                           NONE                                       *
 * Return parameters:                                                   *
 *       NxmVolcano_create   Widget   The menu bar widget               *
 *                                                                      *
 **                                                                     *
 * Log:                                                                 *
 * H. Zeng/XTRIA        10/02   initial coding                          *
 * M. Li/SAIC		11/03	Re-arranged cascade button group	*
 ***********************************************************************/
{
    Widget    menub, menu, cascade, push_btn, vol_menu[24];
    int       toff = 5, menu_idx, ii, iret, nn;
    static    Boolean   first = TRUE;
    char      *vol_list[] = {"AA-AM", "AN-AZ", "B", "CA-CH", "CI-CZ", "D-E", 
		             "F", "G", "H", "I-J", "KA-KH", "KI-KZ", "L",
			     "MA-MC", "ME-MZ", "N", "O-P", "Q-R", "SA-SE",
			     "SF-SZ", "TA-TH", "TI-TZ", "U", "V-Z" }; 
    XmString  xmstr;
    Pixel     fg, bg;
    long      btn_idx, ignore;
    char      filename[256];
    static    Pixmap    menu_pxm;
/*---------------------------------------------------------------------*/
/*
 * If it is the first time NxmVolcano_menuCreate() be called, read 
 * volcano info. from volcano.tbl.
 */
    if ( _gotVolInfo == FALSE ) {

         NxmVolcano_rdInfo();
    }

/*
 * Create volcano menu bar and cascade button.
 */
    menub = XmCreateMenuBar (parent, "tmbar", NULL, 0);

    XtVaSetValues (menub,
                   XmNleftAttachment,           XmATTACH_WIDGET,
                   XmNleftWidget,               textwid,
                   XmNleftOffset,               toff,
		   XmNbottomAttachment,      	XmATTACH_FORM,
                   XmNbottomOffset,          	toff,
		   XmNrightAttachment,          XmATTACH_FORM,
                   XmNrightOffset,              toff,
                   XmNmarginHeight,             0,
                   XmNmarginWidth,              0,
                   XmNborderWidth,              0,
                   XmNwidth,                    5,
                   XmNhighlightThickness,       1,
                   XmNshadowThickness,          1,
                   NULL);

    menu  = XmCreatePulldownMenu (menub, "tmmenu", NULL, 0);

    cascade = XtVaCreateManagedWidget ("tmcascade",
                                       xmCascadeButtonWidgetClass, menub,
                                       XmNsubMenuId, menu,
                                       NULL);
    if (first) {
        first = FALSE;

        XtVaGetValues (parent,
                       XmNforeground,   &fg,
                       XmNbackground,   &bg,
                       NULL);

        cfl_inqr ("menu_arrow.xbm", "$NAWIPS/icons/nmap", &ignore, 
                  filename, &iret);

        if (iret == 0) {
            menu_pxm = XmGetPixmap (XtScreen (parent), filename, fg, bg);
        }
        else {
            menu_pxm = XmUNSPECIFIED_PIXMAP;
        }
    }

    if (menu_pxm == (Pixmap)XmUNSPECIFIED_PIXMAP) {
        xmstr = XmStringCreateLocalized ("\\/");

        XtVaSetValues (cascade,
                       XmNlabelString, xmstr,
                       NULL);

        XmStringFree (xmstr);
    }
    else {
        XtVaSetValues (cascade,
                       XmNlabelType,            XmPIXMAP,
                       XmNlabelPixmap,          menu_pxm,
                       XmNmarginHeight,         0,
                       XmNmarginWidth,          0,
                       NULL);
    }

/*
 * Create the first push button.
 */
    btn_idx = 0;
    xmstr = XmStringCreateLocalized ("-Not_listed.__Enter_Name/Location-");
    push_btn = XtVaCreateManagedWidget ("vol_list_button",
                                         xmPushButtonWidgetClass, menu,
                                         XmNlabelString,       xmstr,
                                         XmNuserData,          textwid,
                                         NULL);
    XmStringFree (xmstr);
    XtAddCallback ( push_btn, XmNactivateCallback,
                    (XtCallbackProc)push_cb, (XtPointer)btn_idx );
    btn_idx++;

/*
 * Create cascade button group.
 */
    nn = XtNumber(vol_list);
    for ( ii = 0; ii < nn; ii++ ) {
	xmstr = XmStringCreateLocalized (vol_list[ii]);
	vol_menu[ii] = XmCreatePulldownMenu (menu, "tmmenu", NULL, 0);
    	XtVaCreateManagedWidget ("tmcascade",
                                  xmCascadeButtonWidgetClass, menu,
                                  XmNlabelString,  xmstr,
                                  XmNsubMenuId,    vol_menu[ii],
                                  NULL);
	XmStringFree (xmstr);
    }

/*
 * Create the rest of volcano push buttons.
 */
    for ( ii = 0; ii < _volNum; ii++ ) {

/*
 * Check which cascade group the volcano station belongs to.
 */
        if ( strcasecmp (_volTbl[ii].name, "AN") < 0 ) {
             menu_idx = 0;
        }
        else if ( strcasecmp (_volTbl[ii].name, "B") < 0 ) {
             menu_idx = 1;
        }
        else if ( strcasecmp (_volTbl[ii].name, "C") < 0 ) {
             menu_idx = 2;
        }
        else if ( strcasecmp (_volTbl[ii].name, "CI") < 0 ) {
             menu_idx = 3;
        }
        else if ( strcasecmp (_volTbl[ii].name, "D") < 0 ) {
             menu_idx = 4;
        }
        else if ( strcasecmp (_volTbl[ii].name, "F") < 0 ) {
             menu_idx = 5;
        }
        else if ( strcasecmp (_volTbl[ii].name, "G") < 0 ) {
             menu_idx = 6;
        }
        else if ( strcasecmp (_volTbl[ii].name, "H") < 0 ) {
             menu_idx = 7;
        }
        else if ( strcasecmp (_volTbl[ii].name, "I") < 0 ) {
             menu_idx = 8;
        }
        else if ( strcasecmp (_volTbl[ii].name, "K") < 0 ) {
             menu_idx = 9;
        }
        else if ( strcasecmp (_volTbl[ii].name, "KI") < 0 ) {
             menu_idx = 10;
        }
        else if ( strcasecmp (_volTbl[ii].name, "L") < 0 ) {
             menu_idx = 11;
        }
        else if ( strcasecmp (_volTbl[ii].name, "M") < 0 ) {
             menu_idx = 12;
        }
        else if ( strcasecmp (_volTbl[ii].name, "ME") < 0 ) {
             menu_idx = 13;
        }
        else if ( strcasecmp (_volTbl[ii].name, "N") < 0 ) {
             menu_idx = 14;
        }
        else if ( strcasecmp (_volTbl[ii].name, "O") < 0 ) {
             menu_idx = 15;
        }
        else if ( strcasecmp (_volTbl[ii].name, "Q") < 0 ) {
             menu_idx = 16;
        }
        else if ( strcasecmp (_volTbl[ii].name, "S") < 0 ) {
             menu_idx = 17;
        }
        else if ( strcasecmp (_volTbl[ii].name, "SF") < 0 ) {
             menu_idx = 18;
        }
        else if ( strcasecmp (_volTbl[ii].name, "T") < 0 ) {
             menu_idx = 19;
        }
	else if ( strcasecmp (_volTbl[ii].name, "TI") < 0 ) {
             menu_idx = 20;
        }
        else if ( strcasecmp (_volTbl[ii].name, "U") < 0 ) {
             menu_idx = 21;
        }
        else if ( strcasecmp (_volTbl[ii].name, "V") < 0 ) {
             menu_idx = 22;
        }
        else {
             menu_idx = 23;
        }

        xmstr = XmStringCreateLocalized (_volTbl[ii].name);
        push_btn = XtVaCreateManagedWidget ("vol_list_button",
                                xmPushButtonWidgetClass, vol_menu[menu_idx],
                                XmNlabelString,          xmstr,
                                XmNuserData,             textwid,
                                NULL);
        XmStringFree (xmstr);
        XtAddCallback ( push_btn, XmNactivateCallback,
                        (XtCallbackProc)push_cb, (XtPointer)btn_idx );
        btn_idx++;

    }

    XtManageChild(menub);
    return (menub);

}
Beispiel #27
0
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);
}
Beispiel #28
0
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);
    
}
Beispiel #29
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];
}
Beispiel #30
-1
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);
}