Пример #1
0
void popup_message_always(char *banner, char *message) {
    XmString msg_str;
    int j,i;
    Atom delw;


    if (disable_all_popups)
        return;

    if (banner == NULL || message == NULL)
        return;

    i=0;
    for (j=0; j<MAX_POPUPS; j++) {
        if (!pw[j].popup_message_dialog) {
            i=j;
            j=MAX_POPUPS+1;
        }
    }

    if(!pw[i].popup_message_dialog) {
        if (banner!=NULL && message!=NULL) {

begin_critical_section(&popup_message_dialog_lock, "popup_gui.c:popup_message" );

            pw[i].popup_message_dialog = XtVaCreatePopupShell(banner,
                xmDialogShellWidgetClass, appshell,
                XmNdeleteResponse, XmDESTROY,
                XmNdefaultPosition, FALSE,
                XmNtitleString,banner,
// An half-hearted attempt at fixing the problem where a popup
// comes up extremely small.  Setting a minimum size for the popup.
XmNminWidth, 220,
XmNminHeight, 80,
                XmNfontList, fontlist1,
                NULL);

            pw[i].pane = XtVaCreateWidget("popup_message pane",xmPanedWindowWidgetClass, pw[i].popup_message_dialog,
                          XmNbackground, colors[0xff],
                          NULL);

            pw[i].form =  XtVaCreateWidget("popup_message form",xmFormWidgetClass, pw[i].pane,
                            XmNfractionBase, 5,
                            XmNbackground, colors[0xff],
                            XmNautoUnmanage, FALSE,
                            XmNshadowThickness, 1,
                            NULL);

            pw[i].popup_message_data = XtVaCreateManagedWidget("popup_message message",xmLabelWidgetClass, pw[i].form,
                                      XmNtopAttachment, XmATTACH_FORM,
                                      XmNtopOffset, 10,
                                      XmNbottomAttachment, XmATTACH_NONE,
                                      XmNleftAttachment, XmATTACH_FORM,
                                      XmNleftOffset, 10,
                                      XmNrightAttachment, XmATTACH_FORM,
                                      XmNrightOffset, 10,
                                      XmNbackground, colors[0xff],
                                      XmNfontList, fontlist1,
                                      NULL);

            pw[i].button_close = XtVaCreateManagedWidget(langcode("UNIOP00003"),xmPushButtonGadgetClass, pw[i].form,
                                      XmNtopAttachment, XmATTACH_WIDGET,
                                      XmNtopWidget, pw[i].popup_message_data,
                                      XmNtopOffset, 10,
                                      XmNbottomAttachment, XmATTACH_FORM,
                                      XmNbottomOffset, 5,
                                      XmNleftAttachment, XmATTACH_POSITION,
                                      XmNleftPosition, 2,
                                      XmNrightAttachment, XmATTACH_POSITION,
                                      XmNrightPosition, 3,
                                      XmNbackground, colors[0xff],
                                      XmNfontList, fontlist1,
                                      NULL);

            sprintf(pw[i].name,"%d",i);

            msg_str=XmStringCreateLtoR(message,XmFONTLIST_DEFAULT_TAG);
            XtVaSetValues(pw[i].popup_message_data,XmNlabelString,msg_str,NULL);
            XmStringFree(msg_str);

            XtAddCallback(pw[i].button_close, XmNactivateCallback, popup_message_destroy_shell,(XtPointer)pw[i].name);

            delw = XmInternAtom(XtDisplay(pw[i].popup_message_dialog),"WM_DELETE_WINDOW", FALSE);

            XmAddWMProtocolCallback(pw[i].popup_message_dialog, delw, popup_message_destroy_shell, (XtPointer)pw[i].name);

            pos_dialog(pw[i].popup_message_dialog);

            XtManageChild(pw[i].form);
            XtManageChild(pw[i].pane);

end_critical_section(&popup_message_dialog_lock, "popup_gui.c:popup_message" );

            XtPopup(pw[i].popup_message_dialog,XtGrabNone);

// An half-hearted attempt at fixing the problem where a popup
// comes up extremely small.  Commenting out the below so we can
// change the size if necessary to read the message.
//            fix_dialog_size(pw[i].popup_message_dialog);

            pw[i].sec_opened=sec_now();
        }
    }
}
Пример #2
0
static Widget        _Uxbuild_kuipCommandP()
{
        Widget                _UxParent;


        /* Creation of kuipCommandP */
        _UxParent = XtVaCreatePopupShell( "kuipCommandP_shell",
                        xmDialogShellWidgetClass, UxTopLevel,
                        XmNallowShellResize, TRUE,
                        XmNtitle, "kuipCommandP",
                        NULL );

        kuipCommandP = XtVaCreateWidget( "kuipCommandP",
                        xmFormWidgetClass,
                        _UxParent,
                        XmNautoUnmanage, FALSE,
                        RES_CONVERT( XmNdialogTitle, "Command" ),
                        XmNdefaultPosition, FALSE,
                        XmNresizePolicy, XmRESIZE_ANY,
                        NULL );
        UxPutContext( kuipCommandP, (char *) UxKuipCommandPContext );


        /* Creation of commandSep */
        commandSep = XtVaCreateManagedWidget( "commandSep",
                        xmSeparatorGadgetClass,
                        kuipCommandP,
                        XmNheight, 10,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNbottomOffset, 45,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNleftOffset, 0,
                        XmNrightAttachment, XmATTACH_FORM,
                        XmNrightOffset, 0,
                        NULL );
        UxPutContext( commandSep, (char *) UxKuipCommandPContext );


        /* Creation of km_cmdOK */
        km_cmdOK = XtVaCreateManagedWidget( "km_cmdOK",
                        xmPushButtonGadgetClass,
                        kuipCommandP,
                        XmNwidth, 80,
                        XmNheight, 30,
                        RES_CONVERT( XmNlabelString, "OK" ),
                        XmNshowAsDefault, 1,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNbottomOffset, 5,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNleftOffset, 5,
                        XmNtopAttachment, XmATTACH_NONE,
                        XmNrightAttachment, XmATTACH_POSITION,
                        XmNrightOffset, 5,
                        XmNrightPosition, 20,
                        XmNmnemonicCharSet, "O",
                        NULL );
        UxPutContext( km_cmdOK, (char *) UxKuipCommandPContext );


        /* Creation of km_cmdEX */
        km_cmdEX = XtVaCreateManagedWidget( "km_cmdEX",
                        xmPushButtonGadgetClass,
                        kuipCommandP,
                        XmNwidth, 80,
                        XmNheight, 30,
                        RES_CONVERT( XmNlabelString, "Execute" ),
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNbottomOffset, 5,
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNleftOffset, 5,
                        XmNleftWidget, km_cmdOK,
                        XmNrightAttachment, XmATTACH_POSITION,
                        XmNrightOffset, 5,
                        XmNrightPosition, 40,
                        RES_CONVERT( XmNmnemonic, "E" ),
                        NULL );
        UxPutContext( km_cmdEX, (char *) UxKuipCommandPContext );


        /* Creation of km_cmdRE */
        km_cmdRE = XtVaCreateManagedWidget( "km_cmdRE",
                        xmPushButtonGadgetClass,
                        kuipCommandP,
                        XmNwidth, 80,
                        XmNheight, 30,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNbottomOffset, 5,
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNleftOffset, 5,
                        XmNleftWidget, km_cmdEX,
                        XmNrightAttachment, XmATTACH_POSITION,
                        XmNrightOffset, 5,
                        XmNrightPosition, 60,
                        XmNtopAttachment, XmATTACH_NONE,
                        RES_CONVERT( XmNlabelString, "Reset" ),
                        RES_CONVERT( XmNmnemonic, "R" ),
                        NULL );
        UxPutContext( km_cmdRE, (char *) UxKuipCommandPContext );


        /* Creation of km_cmdCA */
        km_cmdCA = XtVaCreateManagedWidget( "km_cmdCA",
                        xmPushButtonGadgetClass,
                        kuipCommandP,
                        XmNwidth, 80,
                        XmNheight, 30,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNbottomOffset, 5,
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNleftOffset, 5,
                        XmNleftWidget, km_cmdRE,
                        XmNrightAttachment, XmATTACH_POSITION,
                        XmNrightOffset, 5,
                        XmNrightPosition, 80,
                        RES_CONVERT( XmNlabelString, "Cancel" ),
                        RES_CONVERT( XmNmnemonic, "C" ),
                        NULL );
        UxPutContext( km_cmdCA, (char *) UxKuipCommandPContext );


        /* Creation of km_cmdHE */
        km_cmdHE = XtVaCreateManagedWidget( "km_cmdHE",
                        xmPushButtonGadgetClass,
                        kuipCommandP,
                        XmNwidth, 80,
                        XmNheight, 30,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNbottomOffset, 5,
                        XmNrightAttachment, XmATTACH_POSITION,
                        XmNrightOffset, 5,
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNleftOffset, 5,
                        XmNleftWidget, km_cmdCA,
                        XmNrightPosition, 100,
                        RES_CONVERT( XmNlabelString, "Help" ),
                        RES_CONVERT( XmNmnemonic, "H" ),
                        NULL );
        UxPutContext( km_cmdHE, (char *) UxKuipCommandPContext );

        XtVaSetValues(kuipCommandP,
                        XmNdefaultButton, km_cmdOK,
                        NULL );


        XtAddCallback( kuipCommandP, XmNdestroyCallback,
                (XtCallbackProc) UxDestroyContextCB,
                (XtPointer) UxKuipCommandPContext);


        return ( kuipCommandP );
}
Пример #3
0
static Widget   _Uxbuild_inputTrDialog()
{
        Widget  inputTrDialog_shell;

        inputTrDialog_shell = XtVaCreatePopupShell( "inputTrDialog_shell",
                        xmDialogShellWidgetClass, kuipIo,
                        XmNwidth, 520,
                        XmNheight, 315,
                        XmNshellUnitType, XmPIXELS,
                        XmNtitle, "inputTrDialog",
                        NULL );

        inputTrDialog = XtVaCreateWidget( "inputTrDialog",
                        xmFormWidgetClass, inputTrDialog_shell,
                        XmNdefaultPosition, FALSE,
                        XmNautoUnmanage, FALSE,
                        RES_CONVERT( XmNdialogTitle, "Input Transcript" ),
                        XmNheight, 315,
                        XmNwidth, 520,
                        XmNunitType, XmPIXELS,
                        NULL );

        UxPutContext( inputTrDialog, (char *) UxInputTrDialogContext );

        closeInputTrButton = XtVaCreateManagedWidget( "closeInputTrButton",
                        xmPushButtonWidgetClass, inputTrDialog,
                        XmNrightPosition, 60,
                        XmNrightAttachment, XmATTACH_POSITION,
                        XmNleftPosition, 40,
                        XmNleftAttachment, XmATTACH_POSITION,
                        RES_CONVERT( XmNlabelString, "Close" ),
                        XmNbottomOffset, 10,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNheight, 30,
                        XmNwidth, 60,
                        NULL );

        UxPutContext( closeInputTrButton, (char *) UxInputTrDialogContext );

        separator2 = XtVaCreateManagedWidget( "separator2",
                        xmSeparatorWidgetClass, inputTrDialog,
                        XmNrightAttachment, XmATTACH_FORM,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNbottomWidget, closeInputTrButton,
                        XmNbottomOffset, 10,
                        XmNbottomAttachment, XmATTACH_WIDGET,
                        NULL );

        UxPutContext( separator2, (char *) UxInputTrDialogContext );

        scrolledWindow = XtVaCreateManagedWidget( "scrolledWindow",
                        xmScrolledWindowWidgetClass, inputTrDialog,
                        XmNbottomWidget, separator2,
                        XmNbottomOffset, 5,
                        XmNbottomAttachment, XmATTACH_WIDGET,
                        XmNtopOffset, 5,
                        XmNrightOffset, 5,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNrightAttachment, XmATTACH_FORM,
                        XmNleftOffset, 5,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNshadowThickness, 0,
                        XmNscrollBarDisplayPolicy, XmSTATIC,
                        XmNvisualPolicy, XmVARIABLE,
                        XmNscrollingPolicy, XmAPPLICATION_DEFINED,
                        NULL );

        UxPutContext( scrolledWindow, (char *) UxInputTrDialogContext );

        inputTrText = XtVaCreateManagedWidget( "inputTrText",
                        xmTextWidgetClass, scrolledWindow,
                        XmNeditable, FALSE,
                        XmNeditMode, XmMULTI_LINE_EDIT ,
                        XmNheight, 210,
                        XmNwidth, 495,
                        NULL );

        UxPutContext( inputTrText, (char *) UxInputTrDialogContext );

        XtAddCallback( inputTrDialog, XmNdestroyCallback,
                        UxFreeClientDataCB,
                        (XtPointer) UxInputTrDialogContext );

        XtVaSetValues(inputTrDialog,
                        XmNdefaultButton, closeInputTrButton,
                        NULL );



        return ( inputTrDialog );
}
Пример #4
0
UI2DView::UI2DView () : DBObject ("Noname 2DView",sizeof (UI2DView))

	{
	char name [DBStringLength];
	Widget menuBar, scrolledWindow, radioBox;
	Widget button;
	static Pixmap iconPixmap	 = (Pixmap) NULL, meshPixmap	 = (Pixmap) NULL;
	static Pixmap fullPixmap	 = (Pixmap) NULL, extentPixmap = (Pixmap) NULL;
	static Pixmap capturePixmap = (Pixmap) NULL, redrawPixmap = (Pixmap) NULL;
	static Pixmap zoomPixmap	 = (Pixmap) NULL, panePixmap	 = (Pixmap) NULL, userPixmap	 = (Pixmap) NULL;
	Pixel foreground, background;
	XWindowAttributes xwa;
	XSetWindowAttributes xswa;
	Atom deleteWindowAtom = XmInternAtom(XtDisplay(UITopLevel ()),(char *) "WM_DELETE_WINDOW",FALSE);

	_UI2DViewLIST.Add (this); sprintf (name,"2DView:%2d",RowID ()); Name (name);
	Image = (XImage *) NULL;
	DrawRegion = FullRegion = NULL;
	MaxVertexNumVAR = 0;
	PointARR = (XPoint *) NULL;
	RequiredEXT = (UIDataset ())->Extent ();
	DShell = XtVaCreatePopupShell ("UI2DView",xmDialogShellWidgetClass,UITopLevel (),
												XmNkeyboardFocusPolicy,		XmPOINTER,
												XmNtitle,						Name (),
												XmNtransient,					false,
												XmNminWidth,					600,
												XmNminHeight,					450,
												NULL);
	XmAddWMProtocolCallback (DShell,deleteWindowAtom,(XtCallbackProc) _UI2DViewDeleteCBK,(XtPointer) this);
	MainFormW = XtVaCreateManagedWidget ("UI2DViewForm",xmFormWidgetClass,DShell,
												XmNdialogStyle,				XmDIALOG_WORK_AREA,
												XmNshadowThickness,			0,
												XmNwidth,						600,
												XmNheight,						450,
												NULL);
	menuBar = XtVaCreateManagedWidget ("UI2DViewMenuBar",xmRowColumnWidgetClass,MainFormW,
												XmNtopAttachment,				XmATTACH_FORM,
												XmNtopOffset,					2,
												XmNleftAttachment,			XmATTACH_FORM,
												XmNleftOffset,					2,
												XmNrightAttachment, 			XmATTACH_FORM,
												XmNrightOffset,				2,
												XmNorientation,				XmHORIZONTAL,
												XmNrowColumnType,				XmWORK_AREA,
												NULL);
	XtVaGetValues (MainFormW,XmNforeground,	&foreground,XmNbackground,	&background,NULL);

	iconPixmap = iconPixmap == (Pixmap) NULL ?
					XmGetPixmap(XtScreen (UITopLevel()),(char *) "GHAAS2Dview.bmp",foreground,background): iconPixmap;
	XtVaSetValues (DShell,XmNiconPixmap, iconPixmap,NULL);

	fullPixmap = fullPixmap == (Pixmap) NULL ?
					XmGetPixmap(XtScreen(UITopLevel()),(char *) "GHAASfull.bmp",  foreground,background) : fullPixmap;
	extentPixmap = extentPixmap  == (Pixmap) NULL ?
					XmGetPixmap(XtScreen(UITopLevel()),(char *) "GHAASextent.bmp",foreground,background) : extentPixmap;
	capturePixmap= capturePixmap == (Pixmap) NULL ?
					XmGetPixmap(XtScreen(UITopLevel()),(char *) "GHAAScapture.bmp",foreground,background):capturePixmap;
	redrawPixmap = redrawPixmap == (Pixmap) NULL ?
					XmGetPixmap(XtScreen(UITopLevel()),(char *) "GHAASredraw.bmp", foreground,background) : redrawPixmap;
	zoomPixmap = zoomPixmap == (Pixmap) NULL ?
					XmGetPixmap(XtScreen(UITopLevel()),(char *) "GHAASzoom.bmp",  foreground,background) : zoomPixmap;
	panePixmap = panePixmap == (Pixmap) NULL ?
					XmGetPixmap(XtScreen(UITopLevel()),(char *) "GHAASpane.bmp",  foreground,background) : panePixmap;
	userPixmap = userPixmap == (Pixmap) NULL ?
					XmGetPixmap(XtScreen(UITopLevel()),(char *) "GHAASuser.bmp",  foreground,background) : userPixmap;
	meshPixmap = meshPixmap == (Pixmap) NULL ?
					XmGetPixmap(XtScreen(UITopLevel()),(char *) "GHAASmesh.bmp",  foreground,background) : meshPixmap;

	button = XtVaCreateManagedWidget ("UI2DViewRedrawButton",xmPushButtonGadgetClass,menuBar,
												XmNlabelType,					XmPIXMAP,
												XmNlabelPixmap,				redrawPixmap,
												NULL);
	XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UI2DViewRedrawCBK,this);
	button = XtVaCreateManagedWidget ("UI2DViewFullButton",xmPushButtonGadgetClass,menuBar,
												XmNlabelType,					XmPIXMAP,
												XmNlabelPixmap,				fullPixmap,
												NULL);
	XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UI2DViewFullActivateCBK,this);
	button = XtVaCreateManagedWidget ("UI2DViewExtentButton",xmPushButtonGadgetClass,menuBar,
												XmNlabelType,					XmPIXMAP,
												XmNlabelPixmap,				extentPixmap,
												NULL);
	XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _UI2DViewExtentActivateCBK,this);
	button = XtVaCreateManagedWidget ("UI2DViewCaptureButton",xmPushButtonGadgetClass,menuBar,
												XmNlabelType,					XmPIXMAP,
												XmNlabelPixmap,				capturePixmap,
												NULL);
	radioBox = XtVaCreateManagedWidget ("UI2DViewRadioBox",xmRowColumnWidgetClass,menuBar,
												XmNorientation,				XmHORIZONTAL,
												XmNpacking,						XmPACK_COLUMN,
												XmNisHomogeneous,				true,
												XmNentryClass,					xmToggleButtonGadgetClass,
												XmNradioBehavior,				true,
												NULL);
	ZoomToggle = XtVaCreateManagedWidget ("UI2DViewZoomToggle",xmToggleButtonGadgetClass,radioBox,
												XmNlabelType,					XmPIXMAP,
												XmNlabelPixmap,				zoomPixmap,
												XmNshadowThickness,			0,
												XmNset,							true,
												NULL);
	XtAddCallback (ZoomToggle,XmNvalueChangedCallback,(XtCallbackProc) _UI2DViewZoomToggleValueCBK,this);
	PaneToggle = XtVaCreateManagedWidget ("UI2DViewPaneToggle",xmToggleButtonGadgetClass,radioBox,
												XmNlabelType,					XmPIXMAP,
												XmNlabelPixmap,				panePixmap,
												XmNshadowThickness,			0,
												NULL);
	XtAddCallback (PaneToggle,XmNvalueChangedCallback,(XtCallbackProc) _UI2DViewPaneToggleValueCBK,this);
	UserToggle = XtVaCreateWidget ("UI2DViewUserToggle",xmToggleButtonGadgetClass,radioBox,
												XmNlabelType,					XmPIXMAP,
												XmNlabelPixmap,				userPixmap,
												XmNmappedWhenManaged,		false,
												XmNshadowThickness,			0,
												NULL);
	XtAddCallback (UserToggle,XmNvalueChangedCallback,(XtCallbackProc) _UI2DViewUserToggleValueCBK,this);
	if (_UI2DViewUserFunction != (UI2DViewUserFunction) NULL) XtManageChild (UserToggle);
	MeshOptionW = XtVaCreateManagedWidget ("UI2DViewMeshOption",xmToggleButtonGadgetClass,menuBar,
												XmNlabelType,					XmPIXMAP,
												XmNlabelPixmap,				meshPixmap,
												XmNshadowThickness,			0,
												NULL);
	XtAddCallback (MeshOptionW,XmNvalueChangedCallback,(XtCallbackProc) _UI2DViewMeshOptionCBK,this);
	XtVaSetValues (menuBar,	XmNmenuHelpWidget, MeshOptionW, NULL);

	ScaleW = XtVaCreateManagedWidget ("UI2DViewScale",xmScaleWidgetClass,MainFormW,
												XmNtopAttachment,				XmATTACH_WIDGET,
												XmNtopWidget,					menuBar,
												XmNleftAttachment,			XmATTACH_FORM,
												XmNleftOffset,					2,
												XmNbottomAttachment,			XmATTACH_FORM,
												XmNbottomOffset,				18,
												XmNorientation,				XmVERTICAL,
												XmNwidth,						16,
												NULL);
	XtAddCallback (ScaleW,XmNvalueChangedCallback,(XtCallbackProc) _UI2DViewScaleValueChangedCBK,this);
	scrolledWindow = XtVaCreateManagedWidget ("UI2DViewScrolledWindow",xmScrolledWindowWidgetClass,MainFormW,
												XmNtopAttachment,				XmATTACH_WIDGET,
												XmNtopWidget,					menuBar,
												XmNtopOffset,					2,
												XmNleftAttachment,			XmATTACH_WIDGET,
												XmNleftWidget,					ScaleW,
												XmNleftOffset,					3,
												XmNrightAttachment,			XmATTACH_FORM,
												XmNrightOffset,				3,
												XmNbottomAttachment,			XmATTACH_FORM,
												XmNbottomOffset,				3,
												XmNspacing,						2,
												NULL);
	HorScrollBarW = XtVaCreateManagedWidget ("UI2DViewHorScrollBar", xmScrollBarWidgetClass, scrolledWindow,
												XmNsliderSize,					100,
												XmNorientation,				XmHORIZONTAL,
												XmNheight,						16,
												NULL);
	XtAddCallback (HorScrollBarW,XmNvalueChangedCallback,(XtCallbackProc) _UI2DViewHorScrollBarValueChangedCBK,this);
	VerScrollBarW = XtVaCreateManagedWidget ("UI2DViewVerScrollBar", xmScrollBarWidgetClass, scrolledWindow,
												XmNsliderSize,					100,
												XmNorientation,				XmVERTICAL,
												XmNwidth,						16,
												NULL);
	XtAddCallback (VerScrollBarW,XmNvalueChangedCallback,(XtCallbackProc) _UI2DViewVerScrollBarValueChangedCBK,this);
	DrawingAreaW = XtVaCreateManagedWidget ("UI2DViewDrawingArea", xmDrawingAreaWidgetClass, scrolledWindow,
												XmNuserData,					this,
												XmNbackground,					UIColor (UIColorStandard,0),
												NULL);
	XtAddCallback (DrawingAreaW,XmNresizeCallback,(XtCallbackProc) _UI2DViewResizeCBK,this);
	XtAddEventHandler (DrawingAreaW,EnterWindowMask|LeaveWindowMask|PointerMotionMask|ButtonPressMask|ButtonReleaseMask, false,(XtEventHandler) _UI2DViewPointerEHR,this);
	XmScrolledWindowSetAreas(scrolledWindow,HorScrollBarW,VerScrollBarW,DrawingAreaW);

	_UI2DViewViewCursor  =  _UI2DViewViewCursor != (Cursor) NULL ? _UI2DViewViewCursor : XCreateFontCursor (XtDisplay (DrawingAreaW),XC_top_left_arrow),
	_UI2DViewUserCursor  =  _UI2DViewUserCursor != (Cursor) NULL ? _UI2DViewUserCursor : XCreateFontCursor (XtDisplay (DrawingAreaW),XC_crosshair);
	RegenCursor =  XCreateFontCursor (XtDisplay (DrawingAreaW),XC_watch);
	ActiveCursor = xswa.cursor = _UI2DViewViewCursor;
	XChangeWindowAttributes (XtDisplay (DrawingAreaW), XtWindow (DrawingAreaW), CWCursor, &xswa);

	XGetWindowAttributes (XtDisplay (DrawingAreaW),XtWindow (DrawingAreaW),&xwa);
	Background = xwa.backing_pixel;
	xswa.backing_store = Always;
	XChangeWindowAttributes (XtDisplay (DrawingAreaW),  XtWindow (DrawingAreaW),CWBackingStore,&xswa);
	InputMode (ZOOM_MODE);
	Size ();
	Set ();
	}
Пример #5
0
static Widget   _Uxbuild_parHeaderForm()
{
        Widget          _UxParent;


        /* Creation of parHeaderForm */
        _UxParent = UxParent;
        if ( _UxParent == NULL )
        {
                _UxParent = XtVaCreatePopupShell( "parHeaderForm_shell",
                        topLevelShellWidgetClass, UxTopLevel,
                        XmNshellUnitType, Xm100TH_FONT_UNITS,
                        XmNtitle, "parHeaderForm",
                        XmNiconName, "parHeaderForm",
                        NULL );

        }

        parHeaderForm = XtVaCreateManagedWidget( "parHeaderForm",
                        xmFormWidgetClass,
                        _UxParent,
                        XmNresizePolicy, XmRESIZE_ANY,
                        XmNunitType, Xm100TH_FONT_UNITS,
                        XmNmarginHeight, 0,
                        XmNmarginWidth, 0,
                        RES_CONVERT( XmNforeground, "Red" ),
                        NULL );
        UxPutContext( parHeaderForm, (char *) UxParHeaderFormContext );


        /* Creation of parHeaderRightForm */
        parHeaderRightForm = XtVaCreateManagedWidget( "parHeaderRightForm",
                        xmFormWidgetClass,
                        parHeaderForm,
                        XmNresizePolicy, XmRESIZE_ANY,
                        XmNunitType, Xm100TH_FONT_UNITS,
                        XmNallowOverlap, FALSE,
                        XmNshadowThickness, 0,
                        XmNrightAttachment, XmATTACH_FORM,
                        NULL );
        UxPutContext( parHeaderRightForm, (char *) UxParHeaderFormContext );


        /* Creation of parValueLabel */
        parValueLabel = XtVaCreateManagedWidget( "parValueLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "Value" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        XmNleftAttachment, XmATTACH_FORM,
                        NULL );
        UxPutContext( parValueLabel, (char *) UxParHeaderFormContext );


        /* Creation of parFixLabel */
        parFixLabel = XtVaCreateManagedWidget( "parFixLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "F/R" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNleftWidget, parValueLabel,
                        NULL );
        UxPutContext( parFixLabel, (char *) UxParHeaderFormContext );


        /* Creation of parLowLimitLabel */
        parLowLimitLabel = XtVaCreateWidget( "parLowLimitLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "Lower limit" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        NULL );
        UxPutContext( parLowLimitLabel, (char *) UxParHeaderFormContext );


        /* Creation of parUppLimitLabel */
        parUppLimitLabel = XtVaCreateWidget( "parUppLimitLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "Upper limit" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNleftWidget, parLowLimitLabel,
                        NULL );
        UxPutContext( parUppLimitLabel, (char *) UxParHeaderFormContext );


        /* Creation of parStepLabel */
        parStepLabel = XtVaCreateWidget( "parStepLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "Step" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        NULL );
        UxPutContext( parStepLabel, (char *) UxParHeaderFormContext );


        /* Creation of parEparabLabel */
        parEparabLabel = XtVaCreateWidget( "parEparabLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "Eparab" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        NULL );
        UxPutContext( parEparabLabel, (char *) UxParHeaderFormContext );


        /* Creation of parEminusLabel */
        parEminusLabel = XtVaCreateWidget( "parEminusLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "Eminus" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        NULL );
        UxPutContext( parEminusLabel, (char *) UxParHeaderFormContext );


        /* Creation of parEplusLabel */
        parEplusLabel = XtVaCreateWidget( "parEplusLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "Eplus" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNleftWidget, parEminusLabel,
                        NULL );
        UxPutContext( parEplusLabel, (char *) UxParHeaderFormContext );


        /* Creation of parGlobccLabel */
        parGlobccLabel = XtVaCreateWidget( "parGlobccLabel",
                        xmLabelWidgetClass,
                        parHeaderRightForm,
                        RES_CONVERT( XmNlabelString, "Globcc" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        NULL );
        UxPutContext( parGlobccLabel, (char *) UxParHeaderFormContext );


        /* Creation of parHeaderLeftForm */
        parHeaderLeftForm = XtVaCreateManagedWidget( "parHeaderLeftForm",
                        xmFormWidgetClass,
                        parHeaderForm,
                        XmNresizePolicy, XmRESIZE_ANY,
                        XmNunitType, Xm100TH_FONT_UNITS,
                        XmNallowOverlap, FALSE,
                        XmNshadowThickness, 0,
                        XmNleftAttachment, XmATTACH_FORM,
                        NULL );
        UxPutContext( parHeaderLeftForm, (char *) UxParHeaderFormContext );


        /* Creation of parNumberLabel */
        parNumberLabel = XtVaCreateManagedWidget( "parNumberLabel",
                        xmLabelWidgetClass,
                        parHeaderLeftForm,
                        RES_CONVERT( XmNlabelString, "No" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        NULL );
        UxPutContext( parNumberLabel, (char *) UxParHeaderFormContext );


        /* Creation of parNameLabel */
        parNameLabel = XtVaCreateManagedWidget( "parNameLabel",
                        xmLabelWidgetClass,
                        parHeaderLeftForm,
                        RES_CONVERT( XmNlabelString, "Name" ),
                        XmNrecomputeSize, FALSE,
                        RES_CONVERT( XmNforeground, "red" ),
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNleftWidget, parNumberLabel,
                        NULL );
        UxPutContext( parNameLabel, (char *) UxParHeaderFormContext );


        /* Creation of parTopSeparator */
        parTopSeparator = XtVaCreateManagedWidget( "parTopSeparator",
                        xmSeparatorGadgetClass,
                        parHeaderForm,
                        XmNseparatorType, XmSHADOW_ETCHED_OUT,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNrightAttachment, XmATTACH_FORM,
                        XmNtopAttachment, XmATTACH_WIDGET,
                        XmNtopWidget, parHeaderRightForm,
                        NULL );
        UxPutContext( parTopSeparator, (char *) UxParHeaderFormContext );


        XtAddCallback( parHeaderForm, XmNdestroyCallback,
                (XtCallbackProc) UxDestroyContextCB,
                (XtPointer) UxParHeaderFormContext);


        return ( parHeaderForm );
}
Пример #6
0
/*######################## popup_error_history() ########################*/
void
popup_error_history(int x_root, int y_root, int host_no)
{
   if (error_shell != NULL)
   {
      destroy_error_history();
   }

   if (fsa[host_no].error_history[0] != 0)
   {
      Widget   error_label,
               form;
      XmString x_string;
      int      display_height,
               display_width,
               error_list_length,
               i,
               length,
               lines,
               max_lines,
               max_length,
               over_hang,
               str_length;
      char     *error_list;

      /* Lets determine how many lines we are able to display. */
      display_height = DisplayHeight(display, DefaultScreen(display));
      max_lines = display_height / glyph_height;
   
      error_list_length = ERROR_HISTORY_LENGTH *
                          (5 + 1 + MAX_ERROR_STR_LENGTH + 1);
      if ((error_list = malloc(error_list_length)) == NULL)
      {
         (void)fprintf(stderr, "malloc() error : %s (%s %d)\n",
                       strerror(errno), __FILE__, __LINE__);
         exit(INCORRECT);
      }
      length = max_length = lines = 0;

      str_length = sprintf(error_list + length, "[%d] %s\n",
                           (int)fsa[host_no].error_history[0],
                           get_error_str(fsa[host_no].error_history[0]));
      if (str_length > max_length)
      {
         max_length = str_length;
      }
      length += str_length;
      lines++;
      for (i = 1; i < ERROR_HISTORY_LENGTH; i++)
      {
         if ((fsa[host_no].error_history[i] == 0) || (lines >= max_lines))
         {
            i = ERROR_HISTORY_LENGTH;
         }
         else
         {
            str_length = sprintf(error_list + length, "[%d] %s\n",
                                 (int)fsa[host_no].error_history[i],
                                 get_error_str(fsa[host_no].error_history[i]));
            if (str_length > max_length)
            {
               max_length = str_length;
            }
            length += str_length;
            lines++;
         }
      }

      error_shell = XtVaCreatePopupShell("error_history_shell",
                                      topLevelShellWidgetClass, appshell,
                                      XtNoverrideRedirect,      True,
                                      XtNallowShellResize,      True,
                                      XtNmappedWhenManaged,     False,
                                      XtNsensitive,             True,
                                      XtNwidth,                 1,
                                      XtNheight,                1,
                                      XtNborderWidth,           0,
                                      NULL);
      XtManageChild(error_shell);
      XtAddEventHandler(error_shell, ButtonPressMask | Button1MotionMask,
                        False, (XtEventHandler)eh_input, NULL);
      form = XtVaCreateWidget("error_box",
                              xmFormWidgetClass, error_shell, NULL);
      XtManageChild(form);

      display_width = DisplayWidth(display, DefaultScreen(display));
      over_hang = display_width - (x_root + (max_length * glyph_width));
      if (over_hang < 0)
      {
         x_root += over_hang;
      }
      over_hang = display_height - (y_root + (lines * glyph_height));
      if (over_hang < 0)
      {
         y_root += over_hang;
      }
      XMoveResizeWindow(display, XtWindow(error_shell),
                        x_root, y_root, max_length * glyph_width, lines * glyph_height);

      error_list[length - 1] = '\0';
      x_string = XmStringCreateLocalized(error_list);
      error_label = XtVaCreateWidget("error_label",
                                  xmLabelWidgetClass, form,
                                  XmNlabelString,     x_string,
                                  XtNbackground,      color_pool[WHITE],
                                  XtNforeground,      color_pool[BLACK],
                                  NULL);
      XtManageChild(error_label);
      XmStringFree(x_string);
      XtAddEventHandler(error_label, ButtonPressMask|LeaveWindowMask, False,
                        (XtEventHandler)destroy_error_history, NULL);
      XtPopup(error_shell, XtGrabNone);
      XRaiseWindow(display, XtWindow(error_shell));
      free(error_list);
   }
   else
   {
      destroy_error_history();
   }

   return;
}
Пример #7
0
static Widget   _Uxbuild_colorDialog()
{
        Widget  colorDialog_shell;

        colorDialog_shell = XtVaCreatePopupShell( "colorDialog_shell",
                        xmDialogShellWidgetClass, attributesFormDialog,
                        XmNx, 365,
                        XmNy, 317,
                        XmNwidth, 333,
                        XmNheight, 200,
                        XmNshellUnitType, XmPIXELS,
                        XmNtitle, "colorDialog",
                        NULL );

        colorDialog = XtVaCreateWidget( "colorDialog",
                        xmFormWidgetClass, colorDialog_shell,
                        RES_CONVERT( XmNdialogTitle, "Object Color Setting" ),
                        XmNautoUnmanage, FALSE,
                        XmNnoResize, TRUE,
                        XmNheight, 200,
                        XmNwidth, 333,
                        XmNunitType, XmPIXELS,
                        NULL );

        UxPutContext( colorDialog, (char *) UxColorDialogContext );

        separatorGadget7 = XtVaCreateManagedWidget( "separatorGadget7",
                        xmSeparatorGadgetClass, colorDialog,
                        XmNseparatorType, XmSHADOW_ETCHED_IN,
                        XmNtopAttachment, XmATTACH_NONE,
                        XmNrightOffset, 0,
                        XmNrightAttachment, XmATTACH_FORM,
                        XmNleftOffset, 0,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNbottomOffset, 50,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNheight, 20,
                        XmNwidth, 329,
                        XmNy, 436,
                        XmNx, 3,
                        NULL );

        UxPutContext( separatorGadget7, (char *) UxColorDialogContext );

        ApplyAttColorBut = XtVaCreateManagedWidget( "ApplyAttColorBut",
                        xmPushButtonGadgetClass, colorDialog,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNleftOffset, 10,
                        XmNbottomOffset, 10,
                        XmNbottomAttachment, XmATTACH_FORM,
                        RES_CONVERT( XmNlabelString, "Apply" ),
                        XmNheight, 30,
                        XmNwidth, 90,
                        XmNy, 376,
                        XmNx, 13,
                        NULL );

        UxPutContext( ApplyAttColorBut, (char *) UxColorDialogContext );

        ResetAttColorButton = XtVaCreateManagedWidget( "ResetAttColorButton",
                        xmPushButtonGadgetClass, colorDialog,
                        XmNleftWidget, ApplyAttColorBut,
                        XmNleftOffset, 10,
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNbottomOffset, 10,
                        XmNbottomAttachment, XmATTACH_FORM,
                        RES_CONVERT( XmNlabelString, "Reset" ),
                        XmNheight, 30,
                        XmNwidth, 86,
                        XmNy, 376,
                        XmNx, 147,
                        NULL );

        UxPutContext( ResetAttColorButton, (char *) UxColorDialogContext );

        CloseAttColorBut = XtVaCreateManagedWidget( "CloseAttColorBut",
                        xmPushButtonGadgetClass, colorDialog,
                        XmNleftWidget, ResetAttColorButton,
                        XmNleftOffset, 10,
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNbottomOffset, 10,
                        XmNbottomAttachment, XmATTACH_FORM,
                        RES_CONVERT( XmNlabelString, "Close" ),
                        XmNheight, 30,
                        XmNwidth, 90,
                        XmNy, 376,
                        XmNx, 284,
                        NULL );

        UxPutContext( CloseAttColorBut, (char *) UxColorDialogContext );

        frame3 = XtVaCreateManagedWidget( "frame3",
                        xmFrameWidgetClass, colorDialog,
                        XmNtopOffset, 5,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNrightOffset, 5,
                        XmNrightAttachment, XmATTACH_FORM,
                        XmNleftOffset, 5,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNheight, 78,
                        XmNwidth, 317,
                        XmNy, 100,
                        XmNx, 9,
                        NULL );

        UxPutContext( frame3, (char *) UxColorDialogContext );

        TargetRow = XtVaCreateManagedWidget( "TargetRow",
                        xmRowColumnWidgetClass, frame3,
                        XmNheight, 66,
                        XmNradioBehavior, TRUE,
                        XmNspacing, 0,
                        XmNpacking, XmPACK_NONE,
                        XmNorientation, XmHORIZONTAL,
                        XmNmarginWidth, 0,
                        XmNmarginHeight, 0,
                        XmNwidth, 313,
                        XmNy, 10,
                        XmNx, 2,
                        NULL );

        UxPutContext( TargetRow, (char *) UxColorDialogContext );

        SurfaceToggle = XtVaCreateManagedWidget( "SurfaceToggle",
                        xmToggleButtonGadgetClass, TargetRow,
                        RES_CONVERT( XmNlabelString, "Surface" ),
                        XmNheight, 1,
                        XmNwidth, 90,
                        XmNy, 7,
                        XmNx, 9,
                        NULL );

        UxPutContext( SurfaceToggle, (char *) UxColorDialogContext );

        StatToggle = XtVaCreateManagedWidget( "StatToggle",
                        xmToggleButtonGadgetClass, TargetRow,
                        RES_CONVERT( XmNlabelString, "Statistic box shadow" ),
                        XmNheight, 29,
                        XmNwidth, 154,
                        XmNy, 7,
                        XmNx, 130,
                        NULL );

        UxPutContext( StatToggle, (char *) UxColorDialogContext );

        ZoneToggle = XtVaCreateManagedWidget( "ZoneToggle",
                        xmToggleButtonGadgetClass, TargetRow,
                        RES_CONVERT( XmNlabelString, "Zone box shadow" ),
                        XmNheight, 20,
                        XmNwidth, 123,
                        XmNy, 41,
                        XmNx, 130,
                        NULL );

        UxPutContext( ZoneToggle, (char *) UxColorDialogContext );

        ContourToggle = XtVaCreateManagedWidget( "ContourToggle",
                        xmToggleButtonGadgetClass, TargetRow,
                        RES_CONVERT( XmNlabelString, "Contour" ),
                        XmNheight, 29,
                        XmNwidth, 188,
                        XmNy, 41,
                        XmNx, 9,
                        NULL );

        UxPutContext( ContourToggle, (char *) UxColorDialogContext );

        form6 = XtVaCreateManagedWidget( "form6",
                        xmFormWidgetClass, colorDialog,
                        XmNheight, 34,
                        XmNwidth, 260,
                        XmNy, 95,
                        XmNx, 7,
                        XmNresizePolicy, XmRESIZE_NONE,
                        NULL );

        UxPutContext( form6, (char *) UxColorDialogContext );

        form5 = XtVaCreateManagedWidget( "form5",
                        xmFormWidgetClass, form6,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNrightOffset, 0,
                        XmNrightAttachment, XmATTACH_FORM,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNheight, 34,
                        XmNwidth, 158,
                        XmNy, 94,
                        XmNx, 112,
                        XmNresizePolicy, XmRESIZE_NONE,
                        NULL );

        UxPutContext( form5, (char *) UxColorDialogContext );

        AttColorText = XtVaCreateManagedWidget( "AttColorText",
                        xmTextWidgetClass, form5,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNvalue, "1",
                        XmNheight, 33,
                        XmNwidth, 46,
                        XmNy, -1,
                        XmNx, 53,
                        NULL );

        UxPutContext( AttColorText, (char *) UxColorDialogContext );

        ColorUpArrow = XtVaCreateManagedWidget( "ColorUpArrow",
                        xmArrowButtonWidgetClass, form5,
                        XmNrightOffset, 0,
                        XmNrightAttachment, XmATTACH_FORM,
                        XmNleftWidget, AttColorText,
                        XmNleftOffset, 0,
                        XmNleftAttachment, XmATTACH_WIDGET,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNshadowThickness, 0,
                        XmNarrowDirection, XmARROW_RIGHT,
                        RES_CONVERT( XmNforeground, "#9f9f50" ),
                        XmNheight, 35,
                        XmNwidth, 50,
                        XmNy, 0,
                        XmNx, 97,
                        NULL );

        UxPutContext( ColorUpArrow, (char *) UxColorDialogContext );

        ColorDownArrow = XtVaCreateManagedWidget( "ColorDownArrow",
                        xmArrowButtonWidgetClass, form5,
                        XmNrightWidget, AttColorText,
                        XmNrightOffset, 0,
                        XmNrightAttachment, XmATTACH_WIDGET,
                        XmNleftOffset, 0,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNshadowThickness, 0,
                        XmNarrowDirection, XmARROW_LEFT,
                        RES_CONVERT( XmNforeground, "#9f9f50" ),
                        XmNheight, 35,
                        XmNwidth, 49,
                        XmNy, -1,
                        XmNx, 7,
                        NULL );

        UxPutContext( ColorDownArrow, (char *) UxColorDialogContext );

        textcolorlabel1 = XtVaCreateManagedWidget( "textcolorlabel1",
                        xmLabelGadgetClass, form6,
                        XmNtopAttachment, XmATTACH_FORM,
                        XmNleftOffset, 0,
                        XmNleftAttachment, XmATTACH_FORM,
                        XmNbottomAttachment, XmATTACH_FORM,
                        XmNalignment, XmALIGNMENT_BEGINNING,
                        RES_CONVERT( XmNlabelString, "Color Index :" ),
                        XmNheight, 24,
                        XmNwidth, 100,
                        XmNy, 96,
                        XmNx, 21,
                        NULL );

        UxPutContext( textcolorlabel1, (char *) UxColorDialogContext );

        XtAddCallback( colorDialog, XmNdestroyCallback,
                        UxFreeClientDataCB,
                        (XtPointer) UxColorDialogContext );

        XtVaSetValues(colorDialog,
                        XmNdefaultButton, ApplyAttColorBut,
                        NULL );



        return ( colorDialog );
}
Пример #8
0
/*----------------------------------------------------------------------*/
static Widget
create_frame_shell(Widget parent,String name)
{
    Widget	frame;
	Widget	form;
    Widget	docked_task_bar;
    Widget	dash_board;

	static Widget	floating_shell = NULL;
	static Boolean	first_instance = True;

    frame = XtVaCreatePopupShell(name,
								 xfeFrameShellWidgetClass,
								 parent,
								 NULL);

	XfeAddEditresSupport(frame);

    form = XtVaCreateManagedWidget("Form",
								   xmFormWidgetClass,
								   frame,
								   NULL);

	if (first_instance)
	{
		int			mask;
		int			func;
		
		
		Widget floating_task_bar;
		
		first_instance = False;
		
		mask = MWM_DECOR_BORDER | MWM_DECOR_TITLE | MWM_DECOR_MENU;
		func = MWM_FUNC_CLOSE | MWM_FUNC_MOVE;

		floating_shell =
			XtVaCreatePopupShell("FloatingShell",
								 xmDialogShellWidgetClass,
								 XfeAncestorFindApplicationShell(parent),
								 XmNvisual,				XfeVisual(parent),
								 XmNcolormap,			XfeColormap(parent),
								 XmNdepth,				XfeDepth(parent),
								 XmNmwmDecorations,		mask,
								 XmNmwmFunctions,		func,
								 XmNallowShellResize,	True,
								 XmNdeleteResponse,		XmDO_NOTHING,
								 NULL);

		
		floating_task_bar = XfeCreateLoadedTaskBar(floating_shell,
												   "FloatingTaskBar",
												   True,
												   "Task_",
												   NULL,
												   4,
												   NULL);
	}

    dash_board = XtVaCreateManagedWidget("DashBoard",
										 xfeDashBoardWidgetClass,
										 form,
										 NULL);

	XtAddCallback(dash_board,XmNdockCallback,XfeDockCallback,NULL);
	XtAddCallback(dash_board,XmNundockCallback,XfeUndockCallback,NULL);

    XtVaSetValues(dash_board,
				  XmNfloatingShell,	floating_shell,
				  NULL);
	
	/* Create the progress bar */
	XtVaCreateManagedWidget("ProgressBar",
							xfeProgressBarWidgetClass,
							dash_board,
							XmNusePreferredHeight,		True,
							XmNusePreferredWidth,		True,
							XmNshadowThickness,			1,
							XmNshadowType,				XmSHADOW_IN,
							XmNhighlightThickness,		0,
							XmNtraversalOn,				False,
							NULL);

    /* Create the status bar */
	XtVaCreateWidget("StatusBar",
					 xfeLabelWidgetClass,
					 dash_board,
					 XmNusePreferredHeight,		False,
					 XmNusePreferredWidth,		True,
					 XmNshadowThickness,		2,
					 XmNshadowType,				XmSHADOW_IN,
					 XmNhighlightThickness,		0,
					 XmNtraversalOn,			False,
					 NULL);
	
    /* Create the task bar */
	docked_task_bar = XfeCreateLoadedTaskBar(dash_board,
											 "DockedTaskBar",
											 False,
											 "T",
											 NULL,
											 4,
											 NULL);

	XtVaSetValues(docked_task_bar,
				  XmNorientation,			XmHORIZONTAL,
				  XmNusePreferredWidth,		True,
				  XmNusePreferredHeight,	True,
				  XmNhighlightThickness,	0,
				  XmNshadowThickness,		0,
				  XmNtraversalOn,			False,
				  NULL);
	
	return frame;
}
Пример #9
0
	void
x_plot_range_init()
{
	if( options.display_type == TrueColor )
		plot_range_popup_widget = XtVaCreatePopupShell(
			"Set plot_range",
			transientShellWidgetClass,
			topLevel,
			NULL );
	else
		plot_range_popup_widget = XtVaCreatePopupShell(
			"Set plot_range",
			transientShellWidgetClass,
			topLevel,
			NULL );

	plot_range_popupcanvas_widget = XtVaCreateManagedWidget(
		"plot_range_popupcanvas",
		formWidgetClass,
		plot_range_popup_widget,
		XtNborderWidth, 0,
		NULL);

	plot_range_auto_widget = XtVaCreateManagedWidget(
		"plot_range_auto_widget",	
		commandWidgetClass,	
		plot_range_popupcanvas_widget,
		XtNlabel, "Auto",
		XtNwidth, 60,
		NULL );

	plot_range_manual_widget = XtVaCreateManagedWidget(
		"plot_range_manual_widget",	
		commandWidgetClass,	
		plot_range_popupcanvas_widget,
		XtNlabel, "Manual",
		XtNwidth, 60,
		XtNfromHoriz, plot_range_auto_widget,
		NULL );

	plot_range_min_label_widget = XtVaCreateManagedWidget(
		"plot_range_min_label",	
		labelWidgetClass,	
		plot_range_popupcanvas_widget,
		XtNlabel, "Min:",
		XtNwidth, 60,
		XtNborderWidth, 0,
		XtNfromVert, plot_range_auto_widget,
		NULL );

	plot_range_min_text_widget = XtVaCreateManagedWidget(
		"plot_range_min_text",	
		asciiTextWidgetClass,	
		plot_range_popupcanvas_widget,
		XtNeditType, XawtextEdit,
		XtNfromHoriz, plot_range_min_label_widget,
		XtNfromVert, plot_range_auto_widget,
		XtNlength, 128,
		XtNwidth, MINMAX_TEXT_WIDTH,
		NULL );

	plot_range_max_label_widget = XtVaCreateManagedWidget(
		"plot_range_max_label",	
		labelWidgetClass,	
		plot_range_popupcanvas_widget,
		XtNlabel, "Max:",
		XtNborderWidth, 0,
		XtNwidth, 60,
		XtNfromVert, plot_range_min_label_widget,
		NULL );

	plot_range_max_text_widget = XtVaCreateManagedWidget(
		"plot_range_max_text",	
		asciiTextWidgetClass,	
		plot_range_popupcanvas_widget,
		XtNeditType, XawtextEdit,
		XtNwidth, MINMAX_TEXT_WIDTH,
		XtNfromVert, plot_range_min_text_widget,
		XtNfromHoriz, plot_range_max_label_widget,
		NULL );

	plot_range_ok_widget = XtVaCreateManagedWidget(
		"OK",
		commandWidgetClass,
		plot_range_popupcanvas_widget,
		XtNfromVert, plot_range_max_text_widget,
		NULL);

        XtAddCallback( plot_range_ok_widget, XtNcallback, 
		plot_range_popup_callback, (XtPointer)MESSAGE_OK);

	plot_range_cancel_widget = XtVaCreateManagedWidget(
			"Cancel",
			commandWidgetClass,
			plot_range_popupcanvas_widget,
			XtNfromHoriz, plot_range_ok_widget,
			XtNfromVert, plot_range_max_text_widget,
			NULL);

        XtAddCallback( plot_range_cancel_widget, XtNcallback,
			plot_range_popup_callback, (XtPointer)MESSAGE_CANCEL);
}