Exemplo n.º 1
0
/*ARGSUSED*/
static Boolean
XawListSetValues(Widget current, Widget request, Widget cnew,
		 ArgList args, Cardinal *num_args)
{
    ListWidget cl = (ListWidget)current;
    ListWidget rl = (ListWidget)request;
    ListWidget nl = (ListWidget)cnew;
    Bool redraw = False;
    XFontSetExtents *ext = XExtentsOfFontSet(nl->list.fontset);

    /* If the request height/width is different, lock it.  Unless its 0. If
       neither new nor 0, leave it as it was.  Not in R5 */
    if (XtWidth(nl) != XtWidth(cl))
	nl->list.freedoms |= WidthLock;
    if (XtWidth(nl) == 0)
	nl->list.freedoms &= ~WidthLock;

    if (XtHeight(nl) != XtHeight(cl))
	nl->list.freedoms |= HeightLock;
    if (XtHeight(nl) == 0)
	nl->list.freedoms &= ~HeightLock;

    if (nl->list.longest != cl->list.longest)
	nl->list.freedoms |= LongestLock;
    if (nl->list.longest == 0)
	nl->list.freedoms &= ~LongestLock;

    if (cl->list.foreground != nl->list.foreground ||
	cl->core.background_pixel != nl->core.background_pixel ||
	cl->list.font != nl->list.font) {
	XGCValues values;

	XGetGCValues(XtDisplay(current), cl->list.graygc, GCTile, &values);
	XmuReleaseStippledPixmap(XtScreen(current), values.tile);
	XtReleaseGC(current, cl->list.graygc);
	XtReleaseGC(current, cl->list.revgc);
	XtReleaseGC(current, cl->list.normgc);
	GetGCs(cnew);
	redraw = True;
    }

    if (cl->list.font != nl->list.font && cl->simple.international == False)
	nl->list.row_height = nl->list.font->max_bounds.ascent
			    + nl->list.font->max_bounds.descent
			    + nl->list.row_space;
    else if (cl->list.fontset != nl->list.fontset
	&& cl->simple.international == True)
	nl->list.row_height = ext->max_ink_extent.height + nl->list.row_space;

    /* ...If the above two font(set) change checkers above both failed, check
       if row_space was altered.  If one of the above passed, row_height will
       already have been re-calculated */
    else if (cl->list.row_space != nl->list.row_space) {
	if (cl->simple.international == True)
	    nl->list.row_height = ext->max_ink_extent.height + nl->list.row_space;
	else
	    nl->list.row_height = nl->list.font->max_bounds.ascent
				+ nl->list.font->max_bounds.descent
				+ nl->list.row_space;
    }

    if (XtWidth(cl) != XtWidth(nl) || XtHeight(cl) != XtHeight(nl)
	|| cl->list.internal_width != nl->list.internal_width
	|| cl->list.internal_height != nl->list.internal_height
	|| cl->list.column_space != nl->list.column_space
	|| cl->list.row_space != nl->list.row_space
	|| cl->list.default_cols != nl->list.default_cols
	|| (cl->list.force_cols != nl->list.force_cols
	    && rl->list.force_cols != nl->list.ncols)
	|| cl->list.vertical_cols != nl->list.vertical_cols
	|| cl->list.longest != nl->list.longest
	|| cl->list.nitems != nl->list.nitems
	|| cl->list.font != nl->list.font
	/* Equiv. fontsets might have different values, but the same fonts,
	   so the next comparison is sloppy but not dangerous  */
	|| cl->list.fontset != nl->list.fontset
	|| cl->list.list != nl->list.list) {
	CalculatedValues(cnew);
	Layout(cnew, WidthFree(nl), HeightFree(nl),
	       &nl->core.width, &nl->core.height);
	redraw = True;
    }

    if (cl->list.list != nl->list.list || cl->list.nitems != nl->list.nitems)
	nl->list.is_highlighted = nl->list.highlight = NO_HIGHLIGHT;

    if (cl->core.sensitive != nl->core.sensitive
	|| cl->core.ancestor_sensitive != nl->core.ancestor_sensitive) {
	nl->list.highlight = NO_HIGHLIGHT;
	redraw = True;
    }

    return (redraw);
}
Exemplo n.º 2
0
Widget
EngineOutputCreate (char *name, char *text)
{
    Arg args[16];
    Widget shell, layout, form, form2;
    Dimension bw_width, bw_height;
    int j;

    // get board width
    j = 0;
    XtSetArg(args[j], XtNwidth,  &bw_width);  j++;
    XtSetArg(args[j], XtNheight, &bw_height);  j++;
    XtGetValues(boardWidget, args, j);

    // define form within layout within shell.
    j = 0;
    XtSetArg(args[j], XtNresizable, True);  j++;
    shell =
#if TOPLEVEL
     XtCreatePopupShell(name, topLevelShellWidgetClass,
#else
      XtCreatePopupShell(name, transientShellWidgetClass,
#endif
			 shellWidget, args, j);
    layout =
      XtCreateManagedWidget(layoutName, formWidgetClass, shell,
			    layoutArgs, XtNumber(layoutArgs));
    // divide window vertically into two equal parts, by creating two forms
    form =
      XtCreateManagedWidget("form", formWidgetClass, layout,
			    formArgs, XtNumber(formArgs));
    form2 =
      XtCreateManagedWidget("form2", formWidgetClass, layout,
			    formArgs, XtNumber(formArgs));
    j = 0;
    XtSetArg(args[j], XtNfromVert,  (XtArgVal) form); j++;
    XtSetValues(form2, args, j);
    // make sure width is known in advance, for better placement of child widgets
    j = 0;
    XtSetArg(args[j], XtNwidth,     (XtArgVal) bw_width-16); j++;
    XtSetArg(args[j], XtNheight,    (XtArgVal) bw_height/2); j++;
    XtSetValues(shell, args, j);

    // fill up both forms with control elements
    PositionControlSet(0, shell, form,  bw_width);
    PositionControlSet(1, shell, form2, bw_width);

    XtRealizeWidget(shell);

    if(wpEngineOutput.width > 0) {
      engineOutputW = wpEngineOutput.width;
      engineOutputH = wpEngineOutput.height;
      engineOutputX = wpEngineOutput.x;
      engineOutputY = wpEngineOutput.y;
    }

    if (engineOutputX == -1) {
	int xx, yy;
	Window junk;

	engineOutputH = bw_height/2;
	engineOutputW = bw_width-16;

	XSync(xDisplay, False);
#ifdef NOTDEF
	/* This code seems to tickle an X bug if it is executed too soon
	   after xboard starts up.  The coordinates get transformed as if
	   the main window was positioned at (0, 0).
	   */
	XtTranslateCoords(shellWidget,
			  (bw_width - engineOutputW) / 2, 0 - engineOutputH / 2,
			  &engineOutputX, &engineOutputY);
#else  /*!NOTDEF*/
        XTranslateCoordinates(xDisplay, XtWindow(shellWidget),
			      RootWindowOfScreen(XtScreen(shellWidget)),
			      (bw_width - engineOutputW) / 2, 0 - engineOutputH / 2,
			      &xx, &yy, &junk);
	engineOutputX = xx;
	engineOutputY = yy;
#endif /*!NOTDEF*/
	if (engineOutputY < 0) engineOutputY = 0; /*avoid positioning top offscreen*/
    }
    j = 0;
    XtSetArg(args[j], XtNheight, engineOutputH);  j++;
    XtSetArg(args[j], XtNwidth, engineOutputW);  j++;
    XtSetArg(args[j], XtNx, engineOutputX);  j++;
    XtSetArg(args[j], XtNy, engineOutputY);  j++;
    XtSetValues(shell, args, j);

    return shell;
}
Exemplo n.º 3
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();
}
Exemplo n.º 4
0
static GC
newCache(XtermWidget xw, VTwin * cgsWin, CgsEnum cgsId, CgsCache * me)
{
    XGCValues xgcv;
    XtGCMask mask;

    THIS(font) = NEXT(font);
    THIS(cset) = NEXT(cset);
    THIS(fg) = NEXT(fg);
    THIS(bg) = NEXT(bg);

    memset(&xgcv, 0, sizeof(xgcv));
    xgcv.font = NEXT(font)->fs->fid;
    mask = (GCForeground | GCBackground | GCFont);

    switch (cgsId) {
    case gcNorm:
    case gcBold:
    case gcNormReverse:
    case gcBoldReverse:
#if OPT_WIDE_CHARS
    case gcWide:
    case gcWBold:
    case gcWideReverse:
    case gcWBoldReverse:
#endif
	mask |= (GCGraphicsExposures | GCFunction);
	xgcv.graphics_exposures = True;		/* default */
	xgcv.function = GXcopy;
	break;
#if OPT_BOX_CHARS
    case gcLine:
	mask |= (GCGraphicsExposures | GCFunction);
	xgcv.graphics_exposures = True;		/* default */
	xgcv.function = GXcopy;
	break;
    case gcDots:
	xgcv.fill_style = FillTiled;
	xgcv.tile =
	    XmuCreateStippledPixmap(XtScreen((Widget) xw),
				    THIS(fg),
				    THIS(bg),
				    xw->core.depth);
	THIS(tile) = xgcv.tile;
	mask = (GCForeground | GCBackground);
	mask |= (GCGraphicsExposures | GCFunction | GCTile | GCFillStyle);
	xgcv.graphics_exposures = True;		/* default */
	xgcv.function = GXcopy;
	break;
#endif
#if OPT_DEC_CHRSET
    case gcCNorm:
    case gcCBold:
	break;
#endif
    case gcVTcursNormal:	/* FALLTHRU */
    case gcVTcursFilled:	/* FALLTHRU */
    case gcVTcursReverse:	/* FALLTHRU */
    case gcVTcursOutline:	/* FALLTHRU */
	break;
#if OPT_TEK4014
    case gcTKcurs:		/* FALLTHRU */
	/* FIXME */
#endif
    case gcMAX:		/* should not happen */
	return 0;
    }
    xgcv.foreground = NEXT(fg);
    xgcv.background = NEXT(bg);

    THIS(gc) = XCreateGC(myDisplay(xw), myDrawable(xw, cgsWin), mask, &xgcv);
    TRACE(("getCgsGC(%s) created gc %p(%d)\n",
	   traceCgsEnum(cgsId), (void *) THIS(gc), ITEM()));

    THIS(used) = 0;
    return THIS(gc);
}
Exemplo n.º 5
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();
}
Exemplo n.º 6
0
void
AttachArea::initialize()
{

    // We're making the assumption here that this widget's parent`
    // is also a form

    XtWidgetGeometry size;
    Dimension parWid, parHeight;
    Dimension txt_w, txt_h;
    XmFontList fl;
    XmString xms;

    int         colorUse;
    short       act, inact, prim, second, text;
    XmPixelSet  pixels[XmCO_NUM_COLORS];


    _w = XtVaCreateManagedWidget (
			"AttachPane",
			xmFormWidgetClass, _parent, 
			NULL);

    // Get pixel data.
    XmeGetColorObjData(XtScreen(_parent), &colorUse, pixels, XmCO_NUM_COLORS,
		       &act, &inact, &prim, &second, &text);
    _foreground = pixels[text].fg;
    _background = pixels[text].sc;

    parWid = _myOwner->textEditor()->get_text_width();

    fl = _myOwner->textEditor()->get_text_fontList();
    xms = XmStringCreateLocalized("Xyb");
    XmStringExtent(fl, xms, &txt_w, &txt_h);
    parHeight = txt_h + Icon::maxIconHeight() + (2*VSPACE);

    _appBackground = _background;
    _appForeground = _foreground;

    _sw = XtVaCreateManagedWidget ( 
				    "AttachPane_ScrolledWindow", 
				    xmScrolledWindowWidgetClass, _w, 
				    XmNscrollingPolicy,  XmAPPLICATION_DEFINED,
				    XmNrightAttachment,  XmATTACH_FORM,
				    XmNleftAttachment,   XmATTACH_FORM,
				    XmNtopAttachment,    XmATTACH_FORM,
		    		    XmNshadowThickness, (Dimension)1,
				    XmNspacing, 2,
				    XmNwidth,	     parWid,
				    XmNheight,	     parHeight,
				    NULL);

    rowOfAttachmentsStatus = XtCreateManagedWidget("Attachments_Status",
				xmFormWidgetClass,
				_w, NULL, 0);

     XtVaSetValues(rowOfAttachmentsStatus,
  	XmNrightAttachment,	XmATTACH_FORM, 
  	XmNleftAttachment,	XmATTACH_FORM, 
 	XmNtopAttachment,       XmATTACH_WIDGET,
 	XmNtopWidget,	        _sw,
 	XmNtopOffset,		5,
	XmNbottomOffset,	5,
 	NULL );

    this->addToRowOfAttachmentsStatus();

    size.request_mode = CWHeight;
    XtQueryGeometry(rowOfAttachmentsStatus, NULL, &size);

    XtVaSetValues(
	rowOfAttachmentsStatus,
	XmNpaneMaximum, size.height,
	XmNpaneMinimum, size.height,
	NULL
    );

    _vsb = XtVaCreateManagedWidget("vsb", xmScrollBarWidgetClass, _sw,
		    XmNorientation, XmVERTICAL,
		    XmNsliderSize, 1,
		    XmNmaximum, 1,
		    XmNpageIncrement, 1,
		    NULL);

    XtAddCallback(
	_vsb, 
	XmNvalueChangedCallback,&AttachArea::valueChangedCallback,
	(XtPointer) this 
    );

    XtAddCallback(
	_vsb, 
	XmNdragCallback, &AttachArea::dragCallback,
	(XtPointer) this 
    );

    _clipWindow = XtVaCreateManagedWidget("AttachArea_clipWindow", 
		    xmDrawingAreaWidgetClass, _sw,
		    XmNresizePolicy, XmRESIZE_NONE,
		    XmNbackground, _background,
		    XmNwidth,	     parWid,
		    XmNheight,	     parHeight,
		    NULL);
    XmScrolledWindowSetAreas(_sw, NULL, _vsb, _clipWindow);

    XtManageChild(_clipWindow);
    XtManageChild(_vsb);
    XtManageChild(_sw);

    
    // Set RowCol to NULL here.
    // It gets set in the expose_all_attachments.

    _rc = NULL;

    CalcSizeOfAttachPane();

    installDestroyHandler();
}
Exemplo n.º 7
0
Arquivo: Simple.c Projeto: aosm/X11
/*ARGSUSED*/
static Boolean
XawSimpleSetValues(Widget current, Widget request, Widget cnew,
		   ArgList args, Cardinal *num_args)
{
    SimpleWidget s_old = (SimpleWidget)current;
    SimpleWidget s_new = (SimpleWidget)cnew;
    Bool new_cursor = False;

    /* this disables user changes after creation */
    s_new->simple.international = s_old->simple.international;

    if (XtIsSensitive(current) != XtIsSensitive(cnew))
	(*((SimpleWidgetClass)XtClass(cnew))->simple_class.change_sensitive)
	   (cnew);

    if (s_old->simple.cursor != s_new->simple.cursor)
	new_cursor = True;
	
    /*
     * We are not handling the string cursor_name correctly here
     */

    if (s_old->simple.pointer_fg != s_new->simple.pointer_fg ||
	s_old->simple.pointer_bg != s_new->simple.pointer_bg ||
	s_old->simple.cursor_name != s_new->simple.cursor_name) {
	ConvertCursor(cnew);
	new_cursor = True;
    }

    if (new_cursor && XtIsRealized(cnew)) {
	if (s_new->simple.cursor != None)
	    XDefineCursor(XtDisplay(cnew), XtWindow(cnew), s_new->simple.cursor);
	else
	    XUndefineCursor(XtDisplay(cnew), XtWindow(cnew));
      }

#ifndef OLDXAW
    if (s_old->core.background_pixmap != s_new->core.background_pixmap) {
	XawPixmap *opix, *npix;

	opix = XawPixmapFromXPixmap(s_old->core.background_pixmap,
				    XtScreen(s_old), s_old->core.colormap,
				    s_old->core.depth);
	npix = XawPixmapFromXPixmap(s_new->core.background_pixmap,
				    XtScreen(s_new), s_new->core.colormap,
				    s_new->core.depth);
	if ((npix && npix->mask) || (opix && opix->mask))
	    XawReshapeWidget(cnew, npix);
    }

    if (s_old->simple.tip != s_new->simple.tip) {
	if (s_old->simple.tip)
	    XtFree((XtPointer)s_old->simple.tip);
	if (s_new->simple.tip)
	    s_new->simple.tip = XtNewString(s_new->simple.tip);
    }

    if (s_old->simple.tip && !s_new->simple.tip)
	XawTipDisable(cnew);
    else if (!s_old->simple.tip && s_new->simple.tip)
	XawTipEnable(cnew);

    if (s_old->simple.display_list != s_new->simple.display_list)
	return (True);
#endif /* OLDXAW */

    return (False);
}
Exemplo n.º 8
0
Arquivo: xxx.c Projeto: Gilles86/afni
int main( int argc , char * argv[] )
{
        XtAppContext    app;            /* the application context */
        Display         *dpy;           /* display */
        Colormap        colormap;       /* created colormap */
        XVisualInfo     vinfo;          /* template for find visual */
        Visual          *vis ;          /* the Visual itself */
        XVisualInfo     *vinfo_list;    /* returned list of visuals */
        int             count;          /* number of matchs (only 1?) */
        int             vid , stat ;
        Widget          fred , fff , top ;

        if( argc < 2 ){ fprintf(stderr,"Usage: xxx visid\n") ; exit(0) ; }

        top = XtVaAppInitialize( &app , "xxx" , NULL , 0 , &argc,argv , NULL,NULL ) ;
        dpy = XtDisplay (top);

STATUS("XtVaAppInitialize") ;

        vid = strtol( argv[1] , NULL , 0 ) ;
        vinfo.visualid = (VisualID) vid ;
        vinfo_list = XGetVisualInfo (dpy, VisualIDMask, &vinfo, &count);
        if( count == 0 || vinfo_list == NULL ){
           fprintf(stderr,"no such visual\n");exit(1);
        }
        vinfo = vinfo_list[0] ;

STATUS("XGetVisualInfo") ;

        vid = vinfo.visualid ;
        vis = vinfo.visual ;

        if( vis != DefaultVisual(dpy,vinfo.screen) ){
           colormap = XCreateColormap( dpy, RootWindowOfScreen(XtScreen(top)) ,
                                       vis , AllocNone ) ;
STATUS("XCreateColormap") ;
        } else {
           colormap = DefaultColormap(dpy,vinfo.screen) ;
STATUS("DefaultColormap") ;
        }

        XtVaSetValues( top ,
                          XtNborderColor , 0 ,
                          XtNbackground  , 0 ,
                          XtNdepth       , vinfo.depth ,
                          XtNcolormap    , colormap ,
                          XtNvisual      , vis ,
                       NULL ) ;

STATUS("XtVaSetValues") ;

        fff = XtVaCreateWidget( "dialog" , xmFormWidgetClass , top ,
                                   XmNborderWidth , 0 ,
                                NULL ) ;

STATUS("XtVaCreateWidget") ;

#ifndef LABEL_ARG
#define LABEL_ARG(str) \
  XtVaTypedArg , XmNlabelString , XmRString , (str) , strlen(str)+1
#endif

        fred = XtVaCreateManagedWidget( "dialog" , xmPushButtonWidgetClass , fff ,
                                          LABEL_ARG("Death") ,
                                          XmNtopAttachment    , XmATTACH_FORM ,
                                          XmNleftAttachment   , XmATTACH_FORM ,
                                          XmNrightAttachment  , XmATTACH_FORM ,
                                         NULL ) ;
        XtAddCallback( fred , XmNactivateCallback , fred_CB , NULL ) ;

STATUS("XtVaCreateManagedWidget: button") ;

        fred = XtVaCreateManagedWidget( "dialog" , xmDrawingAreaWidgetClass , fff ,
                                          XmNtopAttachment    , XmATTACH_WIDGET ,
                                          XmNtopWidget        , fred ,
                                          XmNleftAttachment   , XmATTACH_FORM ,
                                          XmNrightAttachment  , XmATTACH_FORM ,
                                          XmNbottomAttachment , XmATTACH_FORM ,
                                        NULL ) ;

        XtAddCallback( fred , XmNexposeCallback , elvis_CB , NULL ) ;

STATUS("XtVaCreateManagedWidget: drawing area") ;

        xim_ww = xim_hh = 77 ;

        XtVaSetValues( top ,
                         XmNwidth , xim_ww ,
                         XmNheight , xim_hh+40 ,
                       NULL ) ;

        XtManageChild(fff) ;
        XtRealizeWidget(top);

STATUS("XtVaCreateManagedWidget: realize") ;

        XtAppMainLoop(app);

        exit(0); /* never reached */
}
Exemplo n.º 9
0
int main(int argc,char* argv[])
{
	XtAppContext app;
	int               sig_Number;
	int               sig_Signal[] =
	{
		SIGHUP,
		SIGINT,
		SIGQUIT,
		SIGILL,
		SIGTRAP,
#if defined(SIGIOT)
		SIGIOT,
#endif
		SIGABRT,
#if defined(SIGEMT)
		SIGEMT,
#endif
		SIGFPE,
		SIGBUS,
		SIGSEGV,
#if defined(SIGSYS)
		SIGSYS,
#endif
		SIGTERM,
#if defined(SIGXCPU)
		SIGXCPU,
#endif
#if defined(SIGXFSZ)
		SIGXFSZ,
#endif
#if defined(SIGDANGER)
		SIGDANGER,
#endif
		-1
	};
	Widget            app_App;
	Display*          dpy;
	Window            win_Root;
	XWindowAttributes attr_Win;
	XGCValues         gc_ValFore;
	XGCValues         gc_ValBack;
	GC                gc_GcFore;
	GC                gc_GcBack;
	XFontStruct*      font_Font;
	char*             font_List[] =
	{
		"-*-character-*-r-*-*-*-600-*-*-p-*-*-*",
		"-*-helvetica-*-r-*-*-*-600-*-*-p-*-*-*",
		"-*-lucida-*-r-*-*-*-600-*-*-p-*-*-*",
		"-*-*-*-r-*-sans-*-600-*-*-p-*-*-*",
		"-*-*-*-r-*-*-*-600-*-*-m-*-*-*",
		"-*-helvetica-*-r-*-*-*-240-*-*-p-*-*-*",
		"-*-lucida-*-r-*-*-*-240-*-*-p-*-*-*",
		"-*-*-*-r-*-sans-*-240-*-*-p-*-*-*",
		"-*-*-*-r-*-*-*-240-*-*-m-*-*-*",
		"fixed",
		NULL
	};
	int               font_Index;
	int               text_Length;
	int               text_X;
	int               text_Y;
	int               text_Width;
	int               text_Height;
	char*             text_List[XSUBLIM_TEXT_COUNT];
	int               text_Used[XSUBLIM_TEXT_COUNT];
	char              text_Text[XSUBLIM_TEXT_LENGTH+1];
	char*             text_Phrase;
	char*             text_Word;
	int               text_Index;
	int               text_Item;
	int               text_Count;
	struct
	{
		int outline_X;
		int outline_Y;
	}                 text_Outline[] =
	{
		{ -1,-1 },
		{  1,-1 },
		{ -1, 1 },
		{  1, 1 },
		{  0, 0 }
	};
	int               text_OutlineIndex;
	XImage*           image_Image = NULL;
	int               image_X = 0;
	int               image_Y = 0;
	int               image_Width = 0;
	int               image_Height = 0;
	int               arg_Count;
	int               arg_FlagCenter;
	int               arg_FlagOutline;
	int               arg_FlagScreensaver;
	int               arg_FlagRandom;
	int               arg_DelayShow;
	int               arg_DelayWord;
	int               arg_DelayPhraseMin;
	int               arg_DelayPhraseMax;
	char*             arg_Text;
	char*             arg_Source;

	/* Set-up ---------------------------------------------------------- */

	/* Catch signals */
	Xsublim_Sig_Last = -1;
	for (sig_Number = 0;sig_Signal[sig_Number] != -1;sig_Number++)
	{
		signal(sig_Number,xsublim_Sig_Catch);
	}

	/* Randomize -- only need to do this here because this program
           doesn't use the `screenhack.h' or `lockmore.h' APIs. */
# undef ya_rand_init
        ya_rand_init (0);

	/* Handle all the X nonsense */
#if defined(__sgi)
	SgiUseSchemes("none");
#endif
	for (arg_Count = 0;options[arg_Count].option != NULL;arg_Count++)
	{
		;
	}
	app_App = XtAppInitialize(&app,progclass,options,arg_Count,&argc,argv,
	 defaults,0,0);

        /* jwz */
        if (argc > 1)
          {
            int x = 18;
            int end = 78;
            int i;
            int count = (sizeof(options)/sizeof(*options))-1;
            fprintf(stderr, "Unrecognised option: %s\n", argv[1]);
            fprintf (stderr, "Options include: ");
            for (i = 0; i < count; i++)
              {
                char *sw = options [i].option;
                Bool argp = (options [i].argKind == XrmoptionSepArg);
                int size = strlen (sw) + (argp ? 6 : 0) + 2;
                if (x + size >= end)
                  {
                    fprintf (stderr, "\n\t\t ");
                    x = 18;
                  }
                x += size;
                fprintf (stderr, "%s", sw);
                if (argp) fprintf (stderr, " <arg>");
                if (i != count-1) fprintf (stderr, ", ");
              }
            fprintf (stderr, ".\n");
            exit (-1);
          }

	dpy = XtDisplay(app_App);
	XtGetApplicationNameAndClass(dpy,&progname,&progclass);
	win_Root = RootWindowOfScreen(XtScreen(app_App));
	XtDestroyWidget(app_App);

	/* Get the arguments */
	arg_FlagCenter = get_boolean_resource(dpy, XSUBLIM_ARG_CENTER,"Boolean");
	arg_FlagOutline = get_boolean_resource(dpy, XSUBLIM_ARG_OUTLINE,"Boolean");
	arg_FlagScreensaver = get_boolean_resource(dpy, XSUBLIM_ARG_SCREENSAVER,
	 "Boolean");
	arg_FlagRandom = get_boolean_resource(dpy, XSUBLIM_ARG_RANDOM,"Boolean");
	arg_DelayShow = get_integer_resource(dpy, XSUBLIM_ARG_DELAYSHOW,"Integer");
	arg_DelayWord = get_integer_resource(dpy, XSUBLIM_ARG_DELAYWORD,"Integer");
	arg_DelayPhraseMin = get_integer_resource(dpy, XSUBLIM_ARG_DELAYPHRASEMIN,
	 "Integer");
	arg_DelayPhraseMax = get_integer_resource(dpy, XSUBLIM_ARG_DELAYPHRASEMAX,
	 "Integer");
	if (arg_DelayPhraseMax < arg_DelayPhraseMin)
	{
		arg_DelayPhraseMax = arg_DelayPhraseMin;
	}

	/* Get the phrases */
	text_Index = 0;
	text_Item = 0;
	text_Count = 0;
	memset(text_Used,0,sizeof(text_Used));
	arg_Source = get_string_resource(dpy, XSUBLIM_ARG_FILE,"Filename");
	if (arg_Source != NULL)
	{
		FILE*       file_Fs;
		struct stat file_Stat;

		file_Fs = fopen(arg_Source,"rb");
		if (file_Fs == NULL)
		{
			fprintf(stderr,"%s: Could not open '%s'\n",progname,
			 arg_Source);
			exit(-1);
		}
		if (fstat(fileno(file_Fs),&file_Stat) != 0)
		{
			fprintf(stderr,"%s: Could not stat '%s'\n",progname,
			 arg_Source);
			exit(-1);
		}
		arg_Text = calloc(1,file_Stat.st_size+1);
		if (arg_Text != NULL)
		{
			if (fread(arg_Text,file_Stat.st_size,1,file_Fs) != 1)
			{
				fprintf(stderr,"%s: Could not read '%s'\n",
				 progname,arg_Source);
				exit(-1);
			}
		}
		fclose(file_Fs);
	}
	else
	{
		arg_Source = get_string_resource(dpy, XSUBLIM_ARG_PROGRAM,
		 "Executable");
		if (arg_Source != NULL)
		{
			char* exe_Command = calloc(1,strlen(arg_Source)+10);
			FILE* exe_Fs;

			if (exe_Command == NULL)
			{
				fprintf(stderr,
				 "%s: Could not allocate space for '%s'\n",
				 progname,arg_Source);
				exit(-1);
			}
			sprintf(exe_Command,"( %s ) 2>&1",arg_Source);

			exe_Fs = popen(exe_Command,"r");
			if (exe_Fs == NULL)
			{
				fprintf(stderr,"%s: Could not run '%s'\n",
				 progname,arg_Source);
				exit(-1);
			}
			arg_Text = calloc(1,XSUBLIM_PROGRAM_SIZE);
			if (arg_Text != NULL)
			{
				if (fread(arg_Text,1,XSUBLIM_PROGRAM_SIZE,
				 exe_Fs) <= 0)
				{
					fprintf(stderr,
					 "%s: Could not read output of '%s'\n",
					 progname,arg_Source);
					exit(-1);
				}
				if (
				 strstr(arg_Text,": not found") ||
				 strstr(arg_Text,": Not found") ||
				 strstr(arg_Text,": command not found") ||
				 strstr(arg_Text,": Command not found"))
				{
					fprintf(stderr,
					 "%s: Could not find '%s'\n",
					 progname,arg_Source);
					exit(-1);
				}
			}
			fclose(exe_Fs);
		}
		else
		{
			arg_Text =
			 get_string_resource(dpy, XSUBLIM_ARG_PHRASES,"Phrases");
			if (arg_Text != NULL)
			{
				arg_Text = strdup(arg_Text);
			}
		}
	}
	if (arg_Text != NULL)
	{
		while (((text_Phrase = strtok(arg_Text,"\n")) != NULL) &&
		 (text_Count < XSUBLIM_TEXT_COUNT))
		{
			arg_Text = NULL;
			text_List[text_Count] = text_Phrase;
			text_Count++;
		}
		text_List[text_Count] = NULL;
	}
	if (text_Count == 0)
	{
		fprintf(stderr,"%s: No text to display\n",progname);
		exit(-1);
	}

	/* Load the font */
	font_Font = load_font_retry(dpy,
	 get_string_resource(dpy, XSUBLIM_ARG_FONT,"Font"));
	font_Index = 0;
	while ((font_Font == NULL) && (font_List[font_Index] != NULL))
	{
		font_Font = load_font_retry(dpy,font_List[font_Index]);
		font_Index++;
	}
	if (font_Font == NULL)
	{
		fprintf(stderr,"%s: Couldn't load a font\n",progname);
		exit(-1);
	}

	/* Create the GCs */
	XGetWindowAttributes(dpy,win_Root,&attr_Win);
	gc_ValFore.font = font_Font->fid;
	gc_ValFore.foreground = get_pixel_resource(dpy,
                                                   attr_Win.colormap,
                                                   "foreground","Foreground");
	gc_ValFore.background = get_pixel_resource(dpy,
                                                   attr_Win.colormap,
                                                   "background","Background");
	gc_ValFore.subwindow_mode = IncludeInferiors;
	gc_GcFore = XCreateGC(dpy,win_Root,
	 (GCFont|GCForeground|GCBackground|GCSubwindowMode),&gc_ValFore);
	gc_ValBack.font = font_Font->fid;
	gc_ValBack.foreground = get_pixel_resource(dpy,
                                                   attr_Win.colormap,
                                                   "background","Background");
	gc_ValBack.background = get_pixel_resource(dpy,
                                                   attr_Win.colormap,
                                                   "foreground","Foreground");
	gc_ValBack.subwindow_mode = IncludeInferiors;
	gc_GcBack = XCreateGC(dpy,win_Root,
	 (GCFont|GCForeground|GCBackground|GCSubwindowMode),&gc_ValBack);

	/* Loop ------------------------------------------------------------ */
	while (Xsublim_Sig_Last == -1)
	{
		/* Once-per-phrase stuff ----------------------------------- */

		/* If we're waiting for a screensaver... */
		if (arg_FlagScreensaver != FALSE)
		{
			/* Find the screensaver's window */
			win_Root = xsublim_Ss_GetWindow(dpy);
			if (win_Root == 0)
			{
				usleep(30000000);
				continue;
			}
		}

		/* Pick the next phrase */
		if (arg_FlagRandom != FALSE)
		{
			text_Item = random()%text_Count;
			text_Index = 0;
		}
		while (text_Used[text_Item] != FALSE)
		{
			text_Index++;
			text_Item++;
			if (text_Index == text_Count)
			{
				text_Index = 0;
				memset(text_Used,0,sizeof(text_Used));
			}
			if (text_List[text_Item] == NULL)
			{
				text_Item = 0;
			}
		}
		text_Used[text_Item] = TRUE;
		strncpy(text_Text,text_List[text_Item],
		 XSUBLIM_TEXT_LENGTH);
		text_Phrase = text_Text;

		/* Run through the phrase */
		while (((text_Word = strtok(text_Phrase," \t")) != NULL) &&
		 (Xsublim_Sig_Last == -1))
		{
			text_Phrase = NULL;

			/* Once-per-word stuff ----------------------------- */

			/* Find the text's position */
			XGetWindowAttributes(dpy,win_Root,&attr_Win);
			text_Length = strlen(text_Word);
			text_Width = XTextWidth(font_Font,text_Word,
			 text_Length)+XSUBLIM_TEXT_OUTLINE*2;
			text_Height = font_Font->ascent+font_Font->descent+1+
			 XSUBLIM_TEXT_OUTLINE*2;
			if (arg_FlagCenter == FALSE)
			{
				text_X = random()%(attr_Win.width-text_Width);
				text_Y = random()%(attr_Win.height-
				 text_Height);
			}
			else
			{
				text_X = (attr_Win.width/2)-(text_Width/2);
				text_Y = (attr_Win.height/2)-(text_Height/2);
			}

			/* Find the image's position (and pad it out slightly,
			   otherwise bits of letter get left behind -- are
			   there boundry issues I don't know about?) */
			image_X = text_X-16;
			image_Y = text_Y;
			image_Width = text_Width+32;
			image_Height = text_Height;
			if (image_X < 0)
			{
				image_X = 0;
			}
			if (image_Y < 0)
			{
				image_Y = 0;
			}
			if (image_X+image_Width > attr_Win.width)
			{
				image_Width = attr_Win.width-image_X;
			}
			if (image_Y+image_Height > attr_Win.height)
			{
				image_Height = attr_Win.height-image_Y;
			}

			/* Influence people for our own ends --------------- */

			/* Grab the server -- we can't let anybody draw over
			   us */
			XSync(dpy,FALSE);
			XGrabServer(dpy);
			XSync(dpy,FALSE);

			/* Set up an error handler that ignores BadMatches --
			   since the screensaver can take its window away at
			   any time, any call that uses it might choke */
			Xsublim_Sh_Status = 0;
			Xsublim_Sh_Handler =
			 XSetErrorHandler(xsublim_Sh_Handler);

			/* Save the current background */
			image_Image = XGetImage(dpy,win_Root,image_X,
			 image_Y,image_Width,image_Height,~0L,ZPixmap);

			/* If we've successfully saved the background... */
			if (image_Image != NULL)
			{
				if (Xsublim_Sh_Status == 0)
				{
					/* Draw the outline */
					if (arg_FlagOutline != FALSE)
					{
						for (text_OutlineIndex = 0;
						 text_Outline[
						 text_OutlineIndex].outline_X
						 != 0;text_OutlineIndex++)
						{
							/* Y'know, eight
							   character tabs and
							   descriptive variable
							   names become
							   annoying at some
							   point... */
							XDrawString(
							 dpy,
							 win_Root,gc_GcBack,
							 text_X+text_Outline[
							 text_OutlineIndex].
							 outline_X*
							 XSUBLIM_TEXT_OUTLINE,
							 text_Y+
							 (font_Font->ascent)+
							 text_Outline[
							 text_OutlineIndex].
							 outline_Y*
							 XSUBLIM_TEXT_OUTLINE,
							 text_Word,
							 text_Length);
						}
					}

					/* Draw the word */
					XDrawString(dpy,win_Root,
					 gc_GcFore,text_X,
					 text_Y+(font_Font->ascent),text_Word,
					 text_Length);
				}
				if (Xsublim_Sh_Status == 0)
				{
					/* Wait a bit */
					XSync(dpy,FALSE);
					if (Xsublim_Sig_Last == -1)
					{
						usleep(arg_DelayShow);
					}
	
					/* Restore the background */
					XPutImage(dpy,win_Root,
					 gc_GcFore,image_Image,0,0,image_X,
					 image_Y,image_Width,image_Height);
				}

				/* Free the image */
				XDestroyImage(image_Image);
			}

			/* Restore the error handler, ungrab the server */
                        XSync(dpy,FALSE);
			XSetErrorHandler(Xsublim_Sh_Handler);
			XUngrabServer(dpy);
                        XSync(dpy,FALSE);

			/* Pause between words */
			if (Xsublim_Sig_Last == -1)
			{
				usleep(arg_DelayWord);
			}
		}

		/* Pause between phrases */
		if (Xsublim_Sig_Last == -1)
		{
			usleep(random()%(arg_DelayPhraseMax-
			 arg_DelayPhraseMin+1)+arg_DelayPhraseMin);
		}
	}

	/* Exit ------------------------------------------------------------ */
	for (sig_Number = 0;sig_Signal[sig_Number] != -1;sig_Number++)
	{
		signal(sig_Number,SIG_DFL);
	}
	kill(getpid(),Xsublim_Sig_Last);

	return 0;
}
Exemplo n.º 10
0
/*
 * Procedure Initialize() is called during the widget creation
 * process.  Initialize() load fonts and calculates window geometry.
 * The request parameter is filled in by parents to this widget.  The
 * wnew parameter is the request parameter plus data filled in by this
 * widget. All changes should be done to the wnew parameter.
 */
static void Initialize(AngbandWidget request, AngbandWidget wnew)
{
    Display *dpy = XtDisplay(wnew);

    int depth = DefaultDepthOfScreen(XtScreen((Widget) wnew));

    XGCValues gcv;
    TopLevelShellWidget parent =
        (TopLevelShellWidget)XtParent((Widget) wnew);
    int i;

    /* Default background pixel */
    unsigned long bg = create_pixel(dpy,
                                    angband_color_table[0][1],
                                    angband_color_table[0][2],
                                    angband_color_table[0][3]);

    /* Default foreground pixel */
    unsigned long fg = create_pixel(dpy,
                                    angband_color_table[1][1],
                                    angband_color_table[1][2],
                                    angband_color_table[1][3]);

    /* Ignore this parameter */
    (void) request;

    /* Fix the background color */
    wnew->core.background_pixel = bg;

    /* Get some information about the font */
    wnew->angband.fnt = getFont(wnew, wnew->angband.font, TRUE);
    wnew->angband.fontheight = wnew->angband.fnt->ascent +
                               wnew->angband.fnt->descent;
    wnew->angband.fontwidth = wnew->angband.fnt->max_bounds.width;
    wnew->angband.fontascent = wnew->angband.fnt->ascent;

    /* Create and initialize the graphics contexts */ /* GXset? */
    gcv.font = wnew->angband.fnt->fid;
    gcv.graphics_exposures = FALSE;
    gcv.background = bg;

    for (i = 0; i < NUM_COLORS; i++)
    {
        unsigned long pixel;

        /* Acquire Angband colors */
        wnew->angband.color[i][0] = angband_color_table[i][0];
        wnew->angband.color[i][1] = angband_color_table[i][1];
        wnew->angband.color[i][2] = angband_color_table[i][2];
        wnew->angband.color[i][3] = angband_color_table[i][3];

        if (depth > 1)
        {
            /* Create pixel */
            pixel = create_pixel(dpy,
                                 wnew->angband.color[i][1],
                                 wnew->angband.color[i][2],
                                 wnew->angband.color[i][3]);
        }
        else
        {
            /* Use background or foreground */
            pixel = ((i == 0) ? bg : fg);
        }

        gcv.foreground = pixel;

        /* Copy */
        gcv.function = 3;

        wnew->angband.gc[i] = XtGetGC((Widget)wnew,
                                      (GCFont | GCForeground | GCFunction |
                                       GCBackground | GCGraphicsExposures),
                                      &gcv);
    }

    /* Create a special GC for highlighting */
    gcv.foreground = (BlackPixelOfScreen(XtScreen((Widget)wnew)) ^
                      WhitePixelOfScreen(XtScreen((Widget)wnew)));
    gcv.background = 0;

    gcv.function = GXxor;
    wnew->angband.gc[COLOR_XOR] = XtGetGC((Widget)wnew,
                                          (GCFunction | GCForeground | GCBackground |
                                           GCGraphicsExposures),
                                          &gcv);

    /* Calculate window geometry */
    wnew->core.height = (wnew->angband.start_rows * wnew->angband.fontheight +
                         2 * wnew->angband.internal_border);
    wnew->core.width = (wnew->angband.start_columns * wnew->angband.fontwidth +
                        2 * wnew->angband.internal_border);

    /* We need to be able to resize the Widget if the user wants to */
    /* change font on the fly! */
    parent->shell.allow_shell_resize = TRUE;

    /* Calculates all the size hints */
    calculateSizeHints(wnew);
}
Exemplo n.º 11
0
int
main (int argc, char **argv)
{
  enum { PASS, SPLASH, TTY } which;
  Widget toplevel_shell = 0;
  saver_screen_info ssip;
  saver_info sip;
  saver_info *si = &sip;
  saver_preferences *p = &si->prefs;
  struct passwd *pw;

  memset(&sip, 0, sizeof(sip));
  memset(&ssip, 0, sizeof(ssip));

  si->nscreens = 1;
  si->screens = si->default_screen = &ssip;
  ssip.global = si;

  global_si_kludge = si;
  real_stderr = stderr;
  real_stdout = stdout;

  si->version = (char *) malloc (5);
  memcpy (si->version, screensaver_id + 17, 4);
  progname = argv[0];
  {
    char *s = strrchr(progname, '/');
    if (*s) strcpy (progname, s+1);
  }

  if (argc != 2) goto USAGE;
  else if (!strcmp (argv[1], "pass"))   which = PASS;
  else if (!strcmp (argv[1], "splash")) which = SPLASH;
  else if (!strcmp (argv[1], "tty"))    which = TTY;
  else
    {
    USAGE:
      fprintf (stderr, "usage: %s [ pass | splash | tty ]\n", progname);
      exit (1);
    }

#ifdef NO_LOCKING
  if (which == PASS || which == TTY)
    {
      fprintf (stderr, "%s: compiled with NO_LOCKING\n", progname);
      exit (1);
    }
#endif

#ifndef NO_LOCKING
  /* before hack_uid() for proper permissions */
  lock_priv_init (argc, argv, True);

  hack_uid (si);

  if (! lock_init (argc, argv, True))
    {
      si->locking_disabled_p = True;
      si->nolock_reason = "error getting password";
    }
#endif

  progclass = "XScreenSaver";

  if (which != TTY)
    {
      toplevel_shell = XtAppInitialize (&si->app, progclass, 0, 0,
                                        &argc, argv, fallback,
                                        0, 0);

      si->dpy = XtDisplay (toplevel_shell);
      p->db = XtDatabase (si->dpy);
      si->default_screen->toplevel_shell = toplevel_shell;
      si->default_screen->screen = XtScreen(toplevel_shell);
      si->default_screen->default_visual =
        si->default_screen->current_visual =
        DefaultVisualOfScreen(si->default_screen->screen);
      si->default_screen->screensaver_window =
        RootWindowOfScreen(si->default_screen->screen);
      si->default_screen->current_depth =
        visual_depth(si->default_screen->screen,
                     si->default_screen->current_visual);

      ssip.width = WidthOfScreen(ssip.screen);
      ssip.height = HeightOfScreen(ssip.screen);

      db = p->db;
      XtGetApplicationNameAndClass (si->dpy, &progname, &progclass);

      load_init_file (si->dpy, &si->prefs);
    }

  p->verbose_p = True;

  pw = getpwuid (getuid ());
  si->user = strdup (pw->pw_name);

/*  si->nscreens = 0;
  si->screens = si->default_screen = 0; */

  while (1)
    {
#ifndef NO_LOCKING
      if (which == PASS)
        {
	  si->unlock_cb = gui_auth_conv;
          si->auth_finished_cb = auth_finished_cb;

	  xss_authenticate(si, True);

          if (si->unlock_state == ul_success)
            fprintf (stderr, "%s: authentication succeeded\n", progname);
          else
            fprintf (stderr, "%s: authentication FAILED!\n", progname);

          XSync(si->dpy, False);
          fprintf (stderr, "\n######################################\n\n");
          sleep (3);
        }
      else
#endif
      if (which == SPLASH)
        {
          XEvent event;
          make_splash_dialog (si);
          XtAppAddTimeOut (si->app, p->splash_duration + 1000,
                           idle_timer, (XtPointer) si);
          while (si->splash_dialog)
            {
              XtAppNextEvent (si->app, &event);
              if (event.xany.window == si->splash_dialog)
                handle_splash_event (si, &event);
              XtDispatchEvent (&event);
            }
          XSync (si->dpy, False);
          sleep (1);
        }
#ifndef NO_LOCKING
      else if (which == TTY)
        {
          si->unlock_cb = text_auth_conv;

          printf ("%s: Authenticating user %s\n", progname, si->user);
          xss_authenticate(si, True);

          if (si->unlock_state == ul_success)
            printf ("%s: Ok!\n", progname);
          else
            printf ("%s: Wrong!\n", progname);
        }
#endif
      else
        abort();
    }

  free(si->user);
}
Exemplo n.º 12
0
void
CreateHelpPopup ( Widget parent )
{
	Widget		pane, rowcol, b;
	Pixmap		pixmap;
	Pixel		fg, bg;
	Arg		args[15];
	int		n, error, verbose;
	char		*startuptextH;
	char		*file, *dpath, *icon_file;


	verbose = GetVerboseLevel();
	if( verbose > VERBOSE_0 )
	    printf ("CreateHelpPopup\n" );

/*
 *	Define home page file.
 */
	dpath = GetConfigValue ("GarpHTML");
	file = builddirpath ( dpath, home_html );
	if ( file == NULL ) {
	    printf ("*** CreateHelpPopup: HTML homepage is undefined ... exiting\n" );
	    exit ( 1 );
	}
/*
 *	Create widgets for help dialog.
 */
	n = 0;
	XtSetArg( args[n], XmNallowOverlap, False);                  n++;
	XtSetArg( args[n], XmNdialogStyle, XmDIALOG_MODELESS);       n++;
	XtSetArg( args[n], XmNautoUnmanage, False);                  n++;
	XtSetArg( args[n], XmNwidth, 500); n++;
	XtSetArg( args[n], XmNheight, 700); n++;

	help.dialog = XmCreateFormDialog(parent,"help_dialog",args,n);

	rowcol = XtVaCreateManagedWidget ( "rowcol",
			xmRowColumnWidgetClass, help.dialog,
			XmNorientation, XmHORIZONTAL,
			NULL );

	XtVaGetValues ( rowcol,
			XmNforeground, &fg,
			XmNbackground, &bg,
			NULL );
/*
 *	Exit button.
 */
	icon_file = (char *) GetIcon ("exit.xbm");
	pixmap = XmGetPixmap ( XtScreen ( rowcol ), icon_file, fg, bg );
	b = XtVaCreateManagedWidget ( "b",
			xmDrawnButtonWidgetClass, rowcol,
			XmNlabelType, XmPIXMAP,
			XmNlabelPixmap, pixmap,
			NULL );
	XtAddCallback ( b, XmNactivateCallback, ExitHTMLCB, NULL );
	Free ( icon_file );

/*
 *	Home button.
 */
	icon_file = (char *) GetIcon ("icon11.xbm");
	pixmap = XmGetPixmap ( XtScreen ( rowcol ), icon_file, fg, bg );
	b = XtVaCreateManagedWidget ( "b",
			xmDrawnButtonWidgetClass, rowcol,
			XmNlabelType, XmPIXMAP,
			XmNlabelPixmap, pixmap,
			NULL );
	XtAddCallback ( b, XmNactivateCallback, HomeHTMLCB, NULL );
	Free ( icon_file );

/*
 *	Back button.
 */
	icon_file = (char *) GetIcon ("icon09.xbm");
	pixmap = XmGetPixmap ( XtScreen ( rowcol ), icon_file, fg, bg );
	b = XtVaCreateManagedWidget ( "b",
			xmDrawnButtonWidgetClass, rowcol,
			XmNlabelType, XmPIXMAP,
			XmNlabelPixmap, pixmap,
			NULL );
	XtAddCallback ( b, XmNactivateCallback, BackHTMLCB, NULL );
	Free ( icon_file );

/*
 *	Forward button.
 */
	icon_file = (char *) GetIcon ("icon09.xbm");
	pixmap = XmGetPixmap ( XtScreen ( rowcol ), icon_file, fg, bg );
	b = XtVaCreateManagedWidget ( "b",
			xmDrawnButtonWidgetClass, rowcol,
			XmNlabelType, XmPIXMAP,
			XmNlabelPixmap, pixmap,
			NULL );
	XtAddCallback ( b, XmNactivateCallback, ForwardHTMLCB, NULL );
	Free ( icon_file );

/*
 *	Pane widget to contain html widget.
 */
	pane = XtVaCreateWidget("help_pane",
			xmPanedWindowWidgetClass,
			help.dialog,
			XmNtopAttachment, XmATTACH_WIDGET,
			XmNtopWidget, rowcol,
			XmNleftAttachment, XmATTACH_FORM,
			XmNrightAttachment, XmATTACH_FORM,
			XmNbottomAttachment, XmATTACH_FORM,
			NULL);

/*
 *	HTML widget.
 */
	help.htlmWid = XtVaCreateWidget( "htlmWid",
			htmlWidgetClass,
			pane,
			XmNresizePolicy, XmRESIZE_ANY,
			WbNpointerMotionCallback, CrossingAnchorCB,
			WbNresolveImageFunction, *html_ImageResolve,
			XmNshadowThickness, 2,
			WbNverticalScrollOnRight, True,
			XmNwidth, 800,
			XmNheight, 600,
			NULL);

	XtAddCallback ( help.htlmWid, WbNanchorCallback, HTMLRefCB, NULL );

	
	XtManageChild ( help.htlmWid );
	startuptextH = ReadHyperTextFile ( file, &error );
	HTMLSetText ( help.htlmWid, startuptextH, NULL, NULL, 0, 0, NULL );
	XtFree ( startuptextH );

	XtManageChild(pane);

	Free ( dpath );
	Free ( file );
}
Exemplo n.º 13
0
int main (int argc, char **argv)
{
#ifdef USE_XPM
Pixmap open,closed, file_open, file_closed; 
Pixel bg;
XpmColorSymbol transparent;
XpmAttributes attrib;
#endif

	toplevel = XtAppInitialize(&app_con,"XltListTreeDemo",NULL,0,
				&argc,argv,NULL,NULL,0);

#ifdef USE_XPM
        XtVaGetValues(toplevel,
                XtNbackground,  &bg,
                NULL);
        transparent.name=NULL;
        transparent.value="#FFFFFFFFFFFF";
        transparent.pixel=bg;
        attrib.colorsymbols=&transparent;
        attrib.valuemask=XpmColorSymbols;
        attrib.numsymbols=1;
	XpmCreatePixmapFromData(XtDisplay(toplevel),
		RootWindowOfScreen(XtScreen(toplevel)),
		folderopen_xpm,&open,NULL,&attrib);
	XpmCreatePixmapFromData(XtDisplay(toplevel),
		RootWindowOfScreen(XtScreen(toplevel)),
		folder_xpm,&closed,NULL,&attrib);
	XpmCreatePixmapFromData(XtDisplay(toplevel),
		RootWindowOfScreen(XtScreen(toplevel)),
		fileopen_xpm,&file_open,NULL,&attrib);
	XpmCreatePixmapFromData(XtDisplay(toplevel),
		RootWindowOfScreen(XtScreen(toplevel)),
		fileclosed_xpm,&file_closed,NULL,&attrib);
	XpmCreatePixmapFromData(XtDisplay(toplevel),
		RootWindowOfScreen(XtScreen(toplevel)),
		test_xpm,&testPix,NULL,&attrib);
#endif
#if OLD_WAY
	tree = XtVaCreateManagedWidget("tree",listtreeWidgetClass,toplevel,
		XtNfont,	XLoadQueryFont(XtDisplay(toplevel),"-adobe-helvetica-medium-r-normal--*-100-*"),
		XtNheight,      	(Dimension)200,
		XtNwidth,		(Dimension)150,
	        XtNhorizontalSpacing,   5,
	        XtNverticalSpacing,     5,
		XtNhighlightPath,       True,
#ifdef USE_XPM
		XtNbranchPixmap,	closed,
		XtNbranchOpenPixmap,	open,
		XtNleafPixmap,		file_closed,
		XtNleafOpenPixmap,	file_open,
#else
/*		XtNbranchPixmap,	NULL,*/
/*		XtNbranchOpenPixmap,	NULL,*/
/*		XtNleafPixmap,		NULL,*/
/*		XtNleafOpenPixmap,	NULL,*/
/*		XtNindent,		(int)5,*/
#endif
		NULL,0);
#else
        tree=XmCreateScrolledListTree(toplevel,"tree",NULL,0);
        XtVaSetValues(tree,
          XtNheight,      	(Dimension)200,
          XtNwidth,		(Dimension)150,
          XltNhorizontalSpacing,   5,
          XltNverticalSpacing,     5,
          XltNhighlightPath,       True,
#ifdef USE_XPM
          XltNbranchPixmap,	closed,
          XltNbranchOpenPixmap,	open,
          XltNleafPixmap,		file_closed,
          XltNleafOpenPixmap,	file_open,
#else
/*		XtNbranchPixmap,	NULL,*/
/*		XtNbranchOpenPixmap,	NULL,*/
/*		XtNleafPixmap,		NULL,*/
/*		XtNleafOpenPixmap,	NULL,*/
/*		XtNindent,		(int)5,*/
#endif
          NULL);
        XtManageChild(tree);
        
#endif
	Init(tree);
	XtAddCallback(tree,XltNhighlightCallback, HighlightCallback, (XtPointer) NULL);
	XtAddCallback(tree,XltNactivateCallback, ActivateCallback, (XtPointer) NULL);
	XtAddCallback(tree,XltNmenuCallback, MenuCallback, (XtPointer) NULL);

	XtRealizeWidget(toplevel);

	XtAppMainLoop(app_con);
	return(0);
}
Exemplo n.º 14
0
Arquivo: Label.c Projeto: aosm/X11libs
static Boolean
XawLabelSetValues(Widget current, Widget request, Widget cnew,
		  ArgList args, Cardinal *num_args)
{
    LabelWidget curlw = (LabelWidget)current;
    LabelWidget reqlw = (LabelWidget)request;
    LabelWidget newlw = (LabelWidget)cnew;
    unsigned int i;
    Boolean was_resized = False, redisplay = False, checks[NUM_CHECKS];

    for (i = 0; i < NUM_CHECKS; i++)
	checks[i] = False;

    for (i = 0; i < *num_args; i++) {
	if (streq(XtNbitmap, args[i].name))
	    checks[PIXMAP] = True;
	else if (streq(XtNwidth, args[i].name))
	    checks[WIDTH] = True;
	else if (streq(XtNheight, args[i].name))
	    checks[HEIGHT] = True;
    }

    if (newlw->label.label == NULL)
	newlw->label.label = newlw->core.name;

    /*
     * resize on bitmap change
     */
    if (curlw->label.left_bitmap != newlw->label.left_bitmap)
	was_resized = True;

    if (curlw->label.encoding != newlw->label.encoding)
	was_resized = True;

    if (curlw->simple.international 
	&& curlw->label.fontset != newlw->label.fontset)
	was_resized = True;

    if (curlw->label.label != newlw->label.label) {
	if (curlw->label.label != curlw->core.name)
	    XtFree((char *)curlw->label.label);

	if (newlw->label.label != newlw->core.name)
	    newlw->label.label = XtNewString(newlw->label.label);

	was_resized = True;
    }

    if (was_resized || (curlw->label.font != newlw->label.font) ||
        curlw->label.justify != newlw->label.justify || checks[PIXMAP]) {
	SetTextWidthAndHeight(newlw);
	was_resized = True;
    }

    /* recalculate the window size if something has changed */
    if (newlw->label.resize && was_resized) {
	if (XtHeight(curlw) == XtHeight(reqlw) && !checks[HEIGHT])
	    XtHeight(newlw) = newlw->label.label_height +
			      (newlw->label.internal_height << 1);

	set_bitmap_info(newlw);

	if (XtWidth(curlw) == XtWidth(reqlw) && !checks[WIDTH])
	    XtWidth(newlw) = newlw->label.label_width + LEFT_OFFSET(newlw) +
			     (newlw->label.internal_width << 1);
    }

    if (curlw->label.foreground		!= newlw->label.foreground
	|| curlw->core.background_pixel != newlw->core.background_pixel
	|| curlw->label.font->fid	!= newlw->label.font->fid) {
	/* The Fontset is not in the GC - don't make a new GC if FS changes! */
	XtReleaseGC(cnew, curlw->label.normal_GC);
	XtReleaseGC(cnew, curlw->label.gray_GC);
	XmuReleaseStippledPixmap(XtScreen(current), curlw->label.stipple);
	GetNormalGC(newlw);
	GetGrayGC(newlw);
	redisplay = True;
    }

    if (curlw->label.label_x != newlw->label.label_x ||
        curlw->label.label_y != newlw->label.label_y)
	redisplay = True;

    if (curlw->label.internal_width != newlw->label.internal_width
	|| curlw->label.internal_height != newlw->label.internal_height
	|| was_resized) {
	/* Resize() will be called if geometry changes succeed */
	Position dx, dy;

	_Reposition(newlw, XtWidth(curlw), XtHeight(curlw), &dx, &dy);
    }

      return (was_resized || redisplay ||
	      XtIsSensitive(current) != XtIsSensitive(cnew));
}
Exemplo n.º 15
0
Arquivo: popup.c Projeto: aosm/X11
void
PopupPopup(Widget parent, Widget popup, Bool transient, Bool first_time,
    int offset_x, int offset_y, String delAction)
{
    if (!transient && !first_time)
    {
	/*
	 * For non-transient windows, if this isn't the first time
	 * it's being popped up, just pop it up in the old position.
	 */

	XtPopup (popup, XtGrabNone);
	return;
    }
    else
    {
	Position parent_x, parent_y;
	Position root_x, root_y;
	Position popup_x, popup_y;
	Dimension parent_width, parent_height, parent_border;
	Dimension popup_width, popup_height, popup_border;
	char geom[16];
	Bool repos = 0;

	/*
	 * The window we pop up must be visible on the screen.  We first
	 * try to position it at the desired location (relative to the
	 * parent widget).  Once we are able to compute the popup's
	 * geometry (after it's realized), we can determine if we need
	 * to reposition it.
	 */

	XtVaGetValues (parent,
	    XtNx, &parent_x,
	    XtNy, &parent_y,
	    XtNwidth, &parent_width,
	    XtNheight, &parent_height,
	    XtNborderWidth, &parent_border,
	    NULL);

	XtTranslateCoords (parent, parent_x, parent_y, &root_x, &root_y);

	popup_x = root_x + offset_x;
	popup_y = root_y + offset_y;

	if (transient)
	{
	    XtVaSetValues (popup,
	        XtNx, popup_x,
	        XtNy, popup_y,
                NULL);
	}
	else
	{
	    sprintf (geom, "+%d+%d", popup_x, popup_y);

	    XtVaSetValues (popup,
	        XtNgeometry, geom,
                NULL);
	}

	if (first_time)
	{
	    /*
	     * Realize it for the first time
	     */

	    XtRealizeWidget (popup);


	    /*
	     * Set support for WM_DELETE_WINDOW
	     */

	    (void) SetWM_DELETE_WINDOW (popup, delAction);
	}

	/*
	 * Now make sure it's visible.
	 */

	XtVaGetValues (popup,
	    XtNwidth, &popup_width,
	    XtNheight, &popup_height,
	    XtNborderWidth, &popup_border,
	    NULL);

	popup_border <<= 1;

	if ((int) (popup_x + popup_width + popup_border) >
	    WidthOfScreen (XtScreen (topLevel)))
	{
	    popup_x = WidthOfScreen (XtScreen (topLevel)) -
		popup_width - popup_border - parent_width - parent_border;

	    repos = 1;
	}

	if ((int) (popup_y + popup_height + popup_border) >
	    HeightOfScreen (XtScreen (topLevel)))
	{
	    popup_y = HeightOfScreen (XtScreen (topLevel)) -
		popup_height - popup_border - parent_height - parent_border;

	    repos = 1;
	}

	if (repos)
	{
	    if (transient)
	    {
		XtVaSetValues (popup,
	            XtNx, popup_x,
	            XtNy, popup_y,
                    NULL);
	    }
	    else
	    {
		/*
		 * The only way we can reposition a non-transient
		 * is by unrealizing it, setting the position, then
		 * doing a realize.
		 */

		XtUnrealizeWidget (popup);

		sprintf (geom, "+%d+%d", popup_x, popup_y);

		XtVaSetValues (popup,
	            XtNgeometry, geom,
                    NULL);

		XtRealizeWidget (popup);

		(void) SetWM_DELETE_WINDOW (popup, delAction);
	    }
	}

	XtPopup (popup, XtGrabNone);
    }
}
Exemplo n.º 16
0
/*
 * ------------------------------------------------------------------------
 * Name: PdmShellCreate
 *
 * Description:
 *
 *     This function creates a top level application shell.
 *
 * Return value:
 *
 *     0 if successful; a PDM_EXIT code if not.
 *
 */
static int
PdmShellCreate(PdmShell* me,
	       const String* fallback_resources,
	       int* argc_in_out, String* argv_in_out)
{
    String app_class;
    String app_name;
    XmPixelSet pixelSets[XmCO_NUM_COLORS];
    XrmClass class_list[3];
    XrmDatabase db;
    XrmName name_list[3];
    XrmRepresentation rep_type;
    XrmValue value;
    int decor;
    int funcs;
    short secondary_id;
    /*
     * create the application context and open the video display
     */
    XtToolkitInitialize();
    XtSetLanguageProc((XtAppContext)NULL, (XtLanguageProc)NULL,
		      (XtPointer)NULL);
    me->app_context = XtCreateApplicationContext();

    XtAppSetFallbackResources(me->app_context, (String*)fallback_resources);

    me->display =
	XtOpenDisplay(me->app_context, (String)NULL,
		      (String)NULL, "Dtpdm",
		      PdmOptions, XtNumber(PdmOptions),
		      argc_in_out, argv_in_out);
    if((Display*)NULL == me->display)
	return PDM_EXIT_VXAUTH;
    XtGetApplicationNameAndClass(me->display, &app_name, &app_class);
    /*
     * the fallback resources are only intended for the video display, so
     * remove them from the application context
     */
    XtAppSetFallbackResources(me->app_context, (String*)NULL);
    /*
     * get the parent video window id from the display's resource database
     */
    db = XtDatabase(me->display);
    name_list[0] = XrmStringToQuark(app_name);
    name_list[1] = XrmStringToQuark("parentWindowStr");
    name_list[2] = NULLQUARK;
    class_list[0] = XrmStringToQuark(app_class);
    class_list[1] = XrmStringToQuark("ParentWindowStr");
    class_list[2] = NULLQUARK;
    XrmQGetResource(db, name_list, class_list, &rep_type, &value);
    if(!value.addr) return PDM_EXIT_ERROR;
    me->parent_window = (Window)strtoul((char*)value.addr, (char**)NULL, 0);
    /*
     * obtain the parent video window's attributes
     */
    if(!XGetWindowAttributes(me->display, me->parent_window, &me->parent_attr))
	return PDM_EXIT_ERROR;
    /*
     * register interest in the DestroyNotify event for the parent window
     */
    XSelectInput(me->display, me->parent_window, StructureNotifyMask);
    /*
     * create the application shell
     */
    decor = MWM_DECOR_ALL | MWM_DECOR_RESIZEH | MWM_DECOR_MINIMIZE
	| MWM_DECOR_MAXIMIZE;
    funcs = MWM_FUNC_ALL | MWM_FUNC_RESIZE | MWM_FUNC_MINIMIZE
	| MWM_FUNC_MAXIMIZE;
    me->widget = 
	XtVaAppCreateShell(app_name, app_class,
			   applicationShellWidgetClass,
			   me->display,
			   XmNdeleteResponse, XmDESTROY,
			   XmNmappedWhenManaged, False,
			   XmNmwmDecorations, decor,
			   XmNmwmFunctions, funcs,
			   XmNmwmInputMode,MWM_INPUT_PRIMARY_APPLICATION_MODAL,
			   XmNscreen, me->parent_attr.screen,
			   XmNtransient, True,
			   NULL);
    /*
     * pick up the secondary color set, so that the PDM presents the same
     * colors as a secondary window. (the XmColorObj is created by the
     * the XmDisplay object, which is created when the app shell is
     * created)
     */
    if(XmeGetColorObjData(XtScreen(me->widget), (int*)NULL,
			  pixelSets, XmCO_NUM_COLORS,
			  (short*)NULL, (short*)NULL, (short*)NULL,
			  &secondary_id, (short*)NULL))
    {
	/*
	 * In the Xrm database, reassign primary color resource values
	 * with the corresponding secondary color values. This will cause
	 * subsequently created widgets that utilize colors from the
	 * primary set to actually present secondary colors.
	 */
	db = XtScreenDatabase(XtScreen(me->widget));
	value.size = sizeof(Pixel);
	value.addr = (char*)&pixelSets[secondary_id].bg;
	XrmPutResource (&db, "*background", "Pixel", &value);
	XrmPutResource (&db, "*frameBackground", "Pixel", &value);
	value.addr = (char*)&pixelSets[secondary_id].fg;
	XrmPutResource (&db, "*foreground", "Pixel", &value);
	XrmPutResource (&db, "*backPageForeground", "Pixel", &value);
	value.addr = (char*)&pixelSets[secondary_id].bs;
	XrmPutResource (&db, "*bottomShadowColor", "Pixel", &value);
	value.addr = (char*)&pixelSets[secondary_id].ts;
	XrmPutResource (&db, "*topShadowColor", "Pixel", &value);
    }
    /*
     * get the application resources
     */
    XtGetApplicationResources(me->widget, me,
			      PdmResources, XtNumber(PdmResources),
			      NULL, 0);
    /*
     * return
     */
    return 0;
}
Exemplo n.º 17
0
void set_config()
{
  int found = True;
  Pixel pix_val;
  Display *disp;
  XColor xcolor;
  XColor spare;
  Colormap defcmap;
  char *bufptr, name[40], buf[80];
  char path[128];
  FILE *fd;

  disp = XtDisplay(overview_shell);
  defcmap = DefaultColormapOfScreen(XtScreen(overview_shell));

  if (XAllocNamedColor(disp, defcmap, "black", &xcolor, &spare) != 0)
  {
    DEFAULT_FG = xcolor.pixel; 
  }
  else
  {
    fprintf(stderr, "unable to allocate color 'black'\n");
  }

  if (XAllocNamedColor(disp, defcmap, "whitesmoke", &xcolor, &spare) != 0)
  {
    DEFAULT_BG = xcolor.pixel; 
  }
  else
  {
    fprintf(stderr, "unable to allocate color 'whitesmoke'\n");
  }

  if (XAllocNamedColor(disp, defcmap, "green", &xcolor, &spare) != 0)
  {
    SELECT_COLOR = xcolor.pixel; 
    RBAND_COLOR = xcolor.pixel; 
  }
  else
  {
    fprintf(stderr, "unable to allocate color 'green'\n");
  }

  if (XAllocNamedColor(disp, defcmap, "black", &xcolor, &spare) != 0)
  {
    CANVAS_COLOR = xcolor.pixel; 
  }
  else
  {
    fprintf(stderr, "unable to allocate color 'black'\n");
  }

  if (XAllocNamedColor(disp, defcmap, "red", &xcolor, &spare) != 0)
  {
    GRID_COLOR = xcolor.pixel; 
  }
  else
  {
    fprintf(stderr, "unable to allocate color 'red'\n");
  }


  sprintf(path, "./xregion.config");

  if ((fd = fopen(path,"r")) == NULL)
  {
    fprintf(stderr,"config file '%s' not found, using default colors\n", path);
    found = False;
  }
 
  while (found && fgets(buf, sizeof(buf), fd) != NULL)
  {
    if (buf[0] == '#') continue; /* a comment */
    
    bufptr = strtok(buf, " ");
    if (bufptr)
    {
      strcpy(name, bufptr);
    } 

    bufptr = strtok(NULL, "\n");
    if (bufptr)
    {
      if (XAllocNamedColor(disp, defcmap, bufptr, &xcolor, &spare) == 0)
      {
        strcat(name, " Not Allocated"); 
      }
      else
      {
        pix_val = xcolor.pixel;
      } 
    } 
   
    if (strstr(name, "Not"))
    {
      fprintf(stderr, "%s: check color name '%s'\n", name, bufptr);
    }
    else if (strstr(name, "foreground"))
    {
      DEFAULT_FG = pix_val; 
    }
    else if (strstr(name, "background")) 
    {
      DEFAULT_BG = pix_val; 
    } 
    else if (strstr(name, "selection")) 
    {
      SELECT_COLOR = pix_val; 
    } 
    else if (strstr(name, "rubberband")) 
    {
      RBAND_COLOR = pix_val; 
    }
    else if (strstr(name, "grid")) 
    {
      GRID_COLOR = pix_val; 
    }
    else if (strstr(name, "canvas")) 
    {
      CANVAS_COLOR = pix_val; 
    }
    else
    {
       fprintf(stderr, "Unknown entry: '%s'\n", name);
    }

  }

  fclose(fd);
}
Exemplo n.º 18
0
/*
 * CREATE PIXMAPS FOR THE BUTONS
 */
void CreatePixmaps(Widget parent)
{
  /*
   * 
   * BITMAPS 
   */
    #include "BITMAPS/back.xbm"
    #include "BITMAPS/next.xbm"
    #include "BITMAPS/prev.xbm"
    #include "BITMAPS/restart.xbm"
    #include "BITMAPS/fwd.xbm"
    #include "BITMAPS/pause.xbm"
    #include "BITMAPS/quit.xbm"
    #include "BITMAPS/timidity.xbm"

    Display *disp;
    Drawable d;
    Pixel fg,bg;
    int ac;
    Arg al[20];
    unsigned int depth=DefaultDepthOfScreen(XtScreen(toplevel));

    ac = 0;
    XtSetArg(al[ac], XmNbackground, &bg); ac++;
    XtSetArg(al[ac], XmNforeground, &fg); ac++;
    XtGetValues(parent, al, ac);

    disp=XtDisplay(toplevel);
    d=RootWindowOfScreen(XtScreen(toplevel));
    
    backPixmap = XCreatePixmapFromBitmapData(disp, d,
					     back_bits, back_width, back_height,
					     fg, bg,depth);
    fwdPixmap = XCreatePixmapFromBitmapData( disp, d,
					     fwd_bits, fwd_width, fwd_height,
					     fg, bg,depth);
    pausePixmap = XCreatePixmapFromBitmapData(disp, d,
					pause_bits, pause_width, pause_height,
					fg, bg,depth);
    
    restartPixmap = XCreatePixmapFromBitmapData(disp, d,
					  restart_bits, restart_width, restart_height,
					  fg, bg,depth);
    
    nextPixmap  = XCreatePixmapFromBitmapData(disp, d,
					next_bits, next_width, next_height,
					fg, bg,depth);
    
    prevPixmap  = XCreatePixmapFromBitmapData(disp, d,
					prev_bits, prev_width, prev_height,
					fg, bg,depth);
    
    quitPixmap  = XCreatePixmapFromBitmapData(disp, d,
					quit_bits, quit_width, quit_height,
					fg, bg,depth);

    timidityPixmap  = XCreatePixmapFromBitmapData(disp, d,
						  timidity_bits, timidity_width, timidity_height,
						  WhitePixelOfScreen(XtScreen(toplevel)),
						  BlackPixelOfScreen(XtScreen(toplevel)),depth);
}
Exemplo n.º 19
0
static Pixmap get_pixmap (Widget   w,
                          char    *name,
                          Boolean  notLast)
{	static char *names = (char *) NULL;
	static int nFailures = 0;
	Pixmap result;

	result = XmGetPixmap(XtScreen(w),
			name,
			BlackPixelOfScreen(XtScreen(root)),
		WhitePixelOfScreen(XtScreen(root)));
	if(result == XmUNSPECIFIED_PIXMAP) { /* try in PPHOME/bitmaps */
		char * alt_name = (char*) XtMalloc(
			strlen(BITMAP_TMPL)  +
			strlen(pp_home) +
			strlen(name) + 1);
		sprintf(alt_name, BITMAP_TMPL, pp_home, name);
		result = XmGetPixmap(XtScreen(w),
				alt_name,
				BlackPixelOfScreen(XtScreen(root)),
				WhitePixelOfScreen(XtScreen(root)));
		XtFree(alt_name);
	}
	if (result == XmUNSPECIFIED_PIXMAP) {
		nFailures++;
		if (nFailures == 1) {
			names = XtMalloc(template_table_bitmaps_size +
			                 (template_table_size * 4) + 4);
			if (names) {
				sprintf(names, "\"%s\"", name);
			}
			else {
				nFailures = 0;
			}
		}
		else {
			char *newNames;
			newNames = XtMalloc(template_table_bitmaps_size +
			                    (template_table_size * 4) + 4);
			if (newNames) {
				sprintf(newNames,
				        "\"%s\"%s %s",
				        name,
				        (nFailures == 2) ? " and" : ",",
				        names);
				strcpy(names, newNames);
				XtFree(newNames);
			}
			else {
				nFailures--;
			}
		}
	}
	if (! notLast && nFailures > 0) {
		char *msg;
		msg = XtMalloc(strlen(names) + strlen(bad_pixmap_msg));
		if (msg) {
			sprintf(msg,
			        bad_pixmap_msg,
			        (nFailures == 1) ? ""   : "s",
			        names,
			        (nFailures == 1) ? "a " : "",
			        (nFailures == 1) ? ""   : "s",
			        (nFailures == 1) ? "a " : "",
			        (nFailures == 1) ? ""   : "s");
			ok_dialog(w, msg);
			XtFree(msg);
		} else {
			ok_dialog(w, bad_pixmap_nomalloc_msg);
		}

		XtFree(names);
		names = (char *) NULL;
		nFailures = 0;
	}

	return result;
}
Exemplo n.º 20
0
Arquivo: misc.c Projeto: aosm/X11apps
FILE *
Format(ManpageGlobals * man_globals, char * entry)
{
  FILE * file = NULL;
#ifdef HAS_MKSTEMP
  int fd;
#endif
  Widget manpage = man_globals->manpagewidgets.manpage;
  char cmdbuf[BUFSIZ], tmp[BUFSIZ], filename[BUFSIZ], error_buf[BUFSIZ];
  char path[BUFSIZ], sect[BUFSIZ];
  XEvent event;
  Position x,y;			/* location to pop up the
				   "would you like to save" widget. */

#ifndef HAS_MKSTEMP
  if ( !UncompressUnformatted(man_globals, entry, filename) ) {
#else
  if ( !UncompressUnformatted(man_globals, entry, filename, &file) ) {
#endif
    /* We Really could not find it, this should never happen, yea right. */
    snprintf(error_buf, sizeof(error_buf),
	     "Could not open manual page, %s", entry);
    PopupWarning(man_globals, error_buf);
    XtPopdown( XtParent(man_globals->standby) );
    return(NULL);
  }

#ifndef HAS_MKSTEMP
  if ((file = fopen(filename, "r")) != NULL) {
#else
  if (file != NULL) {
#endif
    char line[BUFSIZ];

    if (fgets(line, sizeof(line), file) != NULL) {
	if (strncmp(line, ".so ", 4) == 0) {
	  line[strlen(line) - 1] = '\0';
	  fclose(file);
	  unlink(filename);
	  if (line[4] != '/') {
	    char *ptr = NULL;

	    strcpy(tmp, entry);
	    if ((ptr = rindex(tmp, '/')) != NULL) {
	      *ptr = '\0';
	      if ((ptr = rindex(tmp, '/')) != NULL)
		ptr[1] = '\0';
	    }
	  }
	  else
	    *tmp = '\0';
	  snprintf(filename, sizeof(filename), "%s%s", tmp, line + 4);

	  return (Format(man_globals, filename));
	}
    }
    fclose(file);
  }

  Popup(XtParent(man_globals->standby), XtGrabExclusive);
  while ( !XCheckTypedWindowEvent(XtDisplay(man_globals->standby),
				  XtWindow(man_globals->standby),
				  Expose, &event) );
  XtDispatchEvent( &event );
  XFlush(XtDisplay(man_globals->standby));

  strcpy(tmp,MANTEMP);		          /* Get a temp file. */
#ifndef HAS_MKSTEMP
  (void) mktemp(tmp);
#else
  fd = mkstemp(tmp);
  file = fdopen(fd, "r");
#endif
  strcpy(man_globals->tempfile, tmp);

  ParseEntry(entry, path, sect, NULL);

#ifndef HANDLE_ROFFSEQ
#ifndef HAS_MKSTEMP
  snprintf(cmdbuf, sizeof(cmdbuf), "cd %s ; %s %s %s > %s %s", path, TBL,
	  filename, FORMAT, man_globals->tempfile, "2> /dev/null");
#else
  snprintf(cmdbuf, sizeof(cmdbuf), "cd %s ; %s %s %s >> %s %s", path, TBL,
	  filename, FORMAT, man_globals->tempfile, "2> /dev/null");
#endif
#else
  /* Handle more flexible way of specifying the formatting pipeline */
  if (! ConstructCommand(cmdbuf, path, filename, man_globals->tempfile)) {
     sprintf(error_buf, "Constructed command was too long!");
     PopupWarning(man_globals, error_buf);
     file = NULL;
  }
  else
#endif /* HANDLE_ROFFSEQ */

  if(system(cmdbuf) != 0) {	/* execute search. */
    snprintf(error_buf, sizeof(error_buf),
	    "Something went wrong trying to run the command: %s", cmdbuf);
    PopupWarning(man_globals, error_buf);
    file = NULL;
  }
  else {
#ifndef HAS_MKSTEMP
    if ((file = fopen(man_globals->tempfile,"r")) == NULL) {
      sprintf(error_buf, "Something went wrong in retrieving the %s",
	      "temp file, try cleaning up /tmp");
      PopupWarning(man_globals, error_buf);
    }
    else {
#endif

      XtPopdown( XtParent(man_globals->standby) );

      if ( (man_globals->save == NULL) ||
	   (man_globals->manpagewidgets.manpage == NULL) )
	unlink(man_globals->tempfile);
      else {
	char * ptr, catdir[BUFSIZ];

	/*
	 * If the catdir is writeable then ask the user if he/she wants to
	 * write the man page to it.
	 */

	strcpy(catdir, man_globals->save_file);
	if ( (ptr = rindex(catdir, '/')) != NULL) {
	  *ptr = '\0';

	  if ( access(catdir, W_OK) != 0 )
	    unlink(man_globals->tempfile);
	  else {
	    x = (Position) Width(man_globals->manpagewidgets.manpage)/2;
	    y = (Position) Height(man_globals->manpagewidgets.manpage)/2;
	    XtTranslateCoords(manpage, x, y, &x, &y);
	    PositionCenter( man_globals->save, (int) x, (int) y, 0, 0, 0, 0);
	    XtPopup( man_globals->save, XtGrabExclusive);
	  }
	}
	else
	  unlink(man_globals->tempfile);
      }
#ifndef HAS_MKSTEMP
    }
#endif
  }

 /*
  * If the original was compressed or in another format, delete temporary file.
  */
  if (man_globals->deletetempfile) 
    unlink(filename);

  return(file);
}

#ifdef HANDLE_ROFFSEQ
/*      Function Name: ConstructCommand
 *      Description: Constructs the pipeline of commands necessary to format
 *                   a manual page.
 *      Arguments: cmdbuf - the buffer into which to write the command
 *                 path - the directory in which the original man page resides
 *                 filename - the (uncompressed) manpage source file
 *                 tempfile - the name of a temporary file to direct the final
 *                  output of the pipeline into
 *      Returns: TRUE if the command fit into the buffer, FALSE if it would
 *               be too long (more than BUFSIZ characters)
 */
static Boolean
ConstructCommand(cmdbuf, path, filename, tempfile)
   char *cmdbuf, *path, *filename, *tempfile;
{
   /* The original code did the following to produce a command line:
    *   sprintf(cmdbuf,"cd %s ; %s %s %s > %s %s", path, TBL,
    *      filename, FORMAT, man_globals->tempfile, "2> /dev/null");
    * We are more flexible and follow more or less the algorithm used
    * by the Linux man command:
    *  + Obtain a string of letters from the following sources in order
    *    of preference:
    *    + a command line option (not implemented in xman; it's probably not
    *      useful)
    *    + the first line of the manpage source, if it is of the form:
    *      '\" <string>
    *    + the MANROFFSEQ environment variable
    *    + a default string; this is "".
    *  + Interpret the string as a pipeline of filters:
    *    + e = eqn   g = grap   p = pic   t = tbl   v = vgrind   r = refer
    *  + zsoelim is always run as the first preprocessor in any case.
    *
    * Strictly speaking we should save a catpage iff the string comes
    * from the file or is the default.
    *
    * You'll notice that we format a man page into ASCII text output and then
    * attempt to interpret things like L^HL as bold and so forth. This
    * is so obviously the Wrong Thing it's untrue.
    */
   char *c = cmdbuf;           /* current posn in buffer */
   int left = BUFSIZ;          /* space left in buffer */
   int used;
   char *fmt;
   FILE *file;
   char fmtbuf[128];
   int gotfmt = 0;             /* set to 1 if we got a directive from source */
   char *fname = NULL;
#ifdef __UNIXOS2__
   int i;
#endif

   fmt = NULL;
   /* If you have a command line option that gives a setting for fmt,
      set it here. */

   if (!fmt) {
      /* This is the tricky bit: extract a format string from the source file
       * Annoyingly, filename might be relative or absolute. We cheat and
       * use system to get the thing to a known absoute filename.
       */
      if (filename[0] == '/') {
         fname = filename;
      } else {
         fname = malloc(strlen(path) + 1 + strlen(filename) + 1);
         if (!fname)
            return FALSE;
         sprintf(fname, "%s/%s", path, filename);
      }
      if ((file = fopen(fname, "r")) &&
          (fgets(fmtbuf, sizeof(fmtbuf), file)) &&
          (!memcmp(fmtbuf, "'\\\" ", 4))) {
                              /* that's squote-backslash-dquote-space */
         int len;
         fmt = fmtbuf + 3;
         len = strlen(fmt);
         if (len && (fmt[len-1] == '\n')) {
            fmt[len-1] = 0;
            gotfmt++;
         }
      }
      if (fname && fname != filename)
         free(fname);
      if (!gotfmt)                                /* not there or some error */
      {
         fmt = getenv("MANROFFSEQ");
      }
   }

   if (!fmt)
   {
      fmt = DEFAULT_MANROFFSEQ;
   }


   /* Start with the first fixed part of the command line */
#ifdef __UNIXOS2__
   for (i = 0; i < strlen(path); i++) {
     if (path[i] == '/')
       path[i] = '\\';
   }
   used = snprintf(c, left, "cd %s & %s %s ", path, ZSOELIM, filename);
#else
   used = snprintf(c, left, "cd %s; %s %s ", path, ZSOELIM, filename);
#endif
   left -= used;
   c += used;
   if (left <= 1)
      return (FALSE);

   /* Now add preprocessors of the form '| processor' */
   for ( ; *fmt; fmt++)
   {
      char *filter;
      switch (*fmt)
      {
         case 'e':
            filter = EQN;
            break;
         case 'g':
            filter = GRAP;
            break;
         case 'p':
            filter = PIC;
            break;
         case 't':
            filter = TBL;
            break;
         case 'v':
            filter = VGRIND;
            break;
         case 'r':
            filter = REFER;
            break;
         default:
            filter = NULL;
            break;
      }
      if (filter)
      {
         used = snprintf(c, left, " | %s ", filter);
         left -= used;
         c += used;
         if (left <= 1)
            return (FALSE);
      }
   }

   /* Now add the fixed trailing part 'formatprog > tempfile 2> /dev/null' */
#ifdef __UNIXOS2__
   used = snprintf(c, left, " | %s > %s 2>NUL", FORMAT, tempfile);
#else
#ifndef HAS_MKSTEMP
   used = snprintf(c, left, " | %s > %s 2>/dev/null", FORMAT, tempfile);
#else
   used = snprintf(c, left, " | %s >> %s 2>/dev/null", FORMAT, tempfile);
#endif
#endif /* __UNIXOS2__ */
   left -= used;
   if (left <= 1)
      return (FALSE);

   return (TRUE);
}
#endif /* HANDLE_ROFFSEQ */

/*	Function Name: UncompressUnformatted
 *	Description: Finds an uncompressed unformatted manual page.
 *	Arguments: man_globals - the psuedo global structure.
 *                 entry - the manual page entry.
 * RETURNED        filename - location to put the name of the file.
 *	Returns: TRUE if the file was found.
 */

static Boolean
#ifndef HAS_MKSTEMP
UncompressUnformatted(ManpageGlobals * man_globals, char * entry,
		      char * filename)
#else
UncompressUnformatted(ManpageGlobals * man_globals, char * entry,
		      char * filename, FILE **file)
#endif
{
  char path[BUFSIZ], page[BUFSIZ], section[BUFSIZ], input[BUFSIZ];
  int len_cat = strlen(CAT), len_man = strlen(MAN);
#if defined(SMAN) && defined(SFORMAT)
  int len_sman = strlen(SMAN);
#endif

  ParseEntry(entry, path, section, page);

  man_globals->bzip2 = FALSE;
  man_globals->lzma = FALSE;

#if defined(__OpenBSD__) || defined(__NetBSD__)
  /*
   * look for uncompressed file in machine subdir first
   */
  snprintf(filename, BUFSIZ, "%s/%s%s/%s/%s", path, MAN,
	  section + len_cat, MACHINE, page);
  if ( access( filename, R_OK ) == 0 ) {
    man_globals->compress = FALSE;
    man_globals->gzip = FALSE;
    man_globals->deletetempfile = FALSE;
    snprintf(man_globals->save_file, sizeof(man_globals->save_file),
    	     "%s/%s%s/%s/%s", path, CAT, section + len_cat, MACHINE, page);
    return(TRUE);
  }
 /*
  * Then for compressed files in an uncompressed directory.
  */
  snprintf(input, sizeof(input), "%s.%s", filename, COMPRESSION_EXTENSION);
#ifndef HAS_MKSTEMP
  if ( UncompressNamed(man_globals, input, filename) ) {
#else
  if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
    man_globals->compress = TRUE;
    man_globals->deletetempfile = TRUE;
    snprintf(man_globals->save_file, sizeof(man_globals->save_file),
	     "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, 
	     COMPRESSION_EXTENSION);
    return(TRUE);
  }
#ifdef GZIP_EXTENSION
  else {
    snprintf(input, sizeof(input), "%s.%s", filename, GZIP_EXTENSION);
#ifndef HAS_MKSTEMP
    if ( UncompressNamed(man_globals, input, filename) ) {
#else
    if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
      man_globals->compress = TRUE;
      man_globals->gzip = TRUE;
      man_globals->deletetempfile = TRUE;
      snprintf(man_globals->save_file, sizeof(man_globals->save_file),
	       "%s/%s%s/%s.%s", path, CAT, section + len_cat, page,
	       GZIP_EXTENSION);
      return(TRUE);
    }
  }
#endif /* GZIP_EXTENSION */
#endif /* __OpenBSD__ || __NetBSD__ */

#ifdef BZIP2_EXTENSION
 {
    sprintf(input, "%s.%s", filename, BZIP2_EXTENSION);
#ifndef HAS_MKSTEMP
    if ( UncompressNamed(man_globals, input, filename) ) {
#else
    if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
      man_globals->compress = TRUE;
      man_globals->gzip = FALSE;
      man_globals->bzip2 = TRUE;
      sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
	      CAT, section + len_cat, page, BZIP2_EXTENSION);
      return(TRUE);
    }
  }
#endif /* BZIP2_EXTENSION */

#ifdef LZMA_EXTENSION
 {
    sprintf(input, "%s.%s", filename, LZMA_EXTENSION);
#ifndef HAS_MKSTEMP
    if ( UncompressNamed(man_globals, input, filename) ) {
#else
    if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
      man_globals->compress = TRUE;
      man_globals->gzip = FALSE;
      man_globals->lzma = TRUE;
      sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
	      CAT, section + len_cat, page, LZMA_EXTENSION);
      return(TRUE);
    }
  }
#endif /* LZMA_EXTENSION */

/*
 * Look for uncompressed file first.
 */

  snprintf(filename, BUFSIZ, "%s/%s%s/%s", path, MAN, section + len_man, page);
  if ( access( filename, R_OK ) == 0 ) {
    man_globals->compress = FALSE;
    man_globals->gzip = FALSE;
    man_globals->deletetempfile = FALSE;
    snprintf(man_globals->save_file, sizeof(man_globals->save_file), 
	     "%s/%s%s/%s", path, CAT, section + len_cat, page);
    return(TRUE);
  }

#if defined(SMAN) && defined(SFORMAT)
 /*
  * Look for uncompressed sgml file next.
  */

  snprintf(input, BUFSIZ, "%s/%s%s/%s", path, SMAN, section + len_sman, page);
#ifndef HAS_MKSTEMP
  if ( SgmlToRoffNamed(man_globals, input, filename) ) {
#else
  if ( SgmlToRoffNamed(man_globals, input, filename, file) ) {
#endif
    man_globals->compress = FALSE;
    man_globals->gzip = FALSE;
    man_globals->deletetempfile = TRUE;
    snprintf(man_globals->save_file, sizeof(man_globals->save_file),
            "%s/%s%s/%s", path, CAT, section + len_cat, page);
    return(TRUE);
  }
#endif

/*
 * Then for compressed files in an uncompressed directory.
 */

  snprintf(input, sizeof(input), "%s.%s", filename, COMPRESSION_EXTENSION);
#ifndef HAS_MKSTEMP
  if ( UncompressNamed(man_globals, input, filename) ) {
#else
  if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
    man_globals->compress = TRUE;
    man_globals->deletetempfile = TRUE;
    snprintf(man_globals->save_file, sizeof(man_globals->save_file),
	     "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, 
	     COMPRESSION_EXTENSION);
    return(TRUE);
  }
#ifdef GZIP_EXTENSION
  else {
    snprintf(input, sizeof(input), "%s.%s", filename, GZIP_EXTENSION);
#ifndef HAS_MKSTEMP
    if ( UncompressNamed(man_globals, input, filename) ) {
#else
    if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif	
      man_globals->compress = TRUE;
      man_globals->gzip = TRUE;
      man_globals->deletetempfile = TRUE;
      snprintf(man_globals->save_file, sizeof(man_globals->save_file),
	       "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, 
	       GZIP_EXTENSION);
      return(TRUE);
    }
  }
#endif

#ifdef BZIP2_EXTENSION
  {
    sprintf(input, "%s.%s", filename, BZIP2_EXTENSION);
#ifndef HAS_MKSTEMP
    if ( UncompressNamed(man_globals, input, filename) ) {
#else
    if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif	
      man_globals->compress = TRUE;
      man_globals->gzip = TRUE;
      sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
	      CAT, section + len_cat, page, BZIP2_EXTENSION);
      return(TRUE);
    }
  }
#endif

#ifdef LZMA_EXTENSION
  {
    sprintf(input, "%s.%s", filename, LZMA_EXTENSION);
#ifndef HAS_MKSTEMP
    if ( UncompressNamed(man_globals, input, filename) ) {
#else
    if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif	
      man_globals->compress = TRUE;
      man_globals->lzma = TRUE;
      sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path,
	      CAT, section + len_cat, page, LZMA_EXTENSION);
      return(TRUE);
    }
  }
#endif

/*
 * And lastly files in a compressed directory.
 */

  snprintf(input, sizeof(input), "%s/%s%s.%s/%s", path,
	  MAN, section + len_man, COMPRESSION_EXTENSION, page);
#ifndef HAS_MKSTEMP
  if ( UncompressNamed(man_globals, input, filename) ) {
#else
  if ( UncompressNamed(man_globals, input, filename, file) ) {
#endif
    man_globals->compress = TRUE;
    man_globals->deletetempfile = TRUE;
    snprintf(man_globals->save_file, sizeof(man_globals->save_file),
	     "%s/%s%s.%s/%s", path, CAT, section + len_cat, 
    	     COMPRESSION_EXTENSION, page);
    return(TRUE);
  }
  return(FALSE);
}

/*	Function Name: AddCursor
 *	Description: This function adds the cursor to the window.
 *	Arguments: w - the widget to add the cursor to.
 *                 cursor - the cursor to add to this widget.
 *	Returns: none
 */

void
AddCursor(Widget w, Cursor cursor)
{
  XColor colors[2];
  Arg args[10];
  Cardinal num_args = 0;
  Colormap c_map;

  if (!XtIsRealized(w)) {
    PopupWarning(NULL, "Widget is not realized, no cursor added.\n");
    return;
  }

  XtSetArg( args[num_args], XtNcolormap, &c_map); num_args++;
  XtGetValues( w, args, num_args);

  colors[0].pixel = resources.cursors.fg_color;
  colors[1].pixel = resources.cursors.bg_color;

  XQueryColors (XtDisplay(w), c_map, colors, 2);
  XRecolorCursor(XtDisplay(w), cursor, colors, colors+1);
  XDefineCursor(XtDisplay(w),XtWindow(w),cursor);
}

/*	Function Name: ChangeLabel
 *	Description: This function changes the label field of the
 *                   given widget to the string in str.
 *	Arguments: w - the widget.
 *                 str - the string to change the label to.
 *	Returns: none
 */

void
ChangeLabel(Widget w, char * str)
{
  Arg arglist[3];		/* An argument list. */

  if (w == NULL) return;

  XtSetArg(arglist[0], XtNlabel, str);

/* shouldn't really have to do this. */
  XtSetArg(arglist[1], XtNwidth, 0);
  XtSetArg(arglist[2], XtNheight, 0);

  XtSetValues(w, arglist, (Cardinal) 1);
}

/*
 * In an ideal world this would be part of the XToolkit, and I would not
 * have to do it, but such is life sometimes.  Perhaps in X11R3.
 */

/*	Function Name: PositionCenter
 *	Description: This function positions the given widgets center
 *                   in the following location.
 *	Arguments: widget - the widget widget to postion
 *                 x,y - The location for the center of the widget
 *                 above - number of pixels above center to locate this widget
 *                 left - number of pixels left of center to locate this widget
 *                 h_space, v_space - how close to get to the edges of the
 *                                    parent window.
 *	Returns: none
 *      Note:  This should only be used with a popup widget that has override
 *             redirect set.
 */

void
PositionCenter(Widget widget, int x, int y, int above, int left, int v_space, int h_space)
{
  Arg wargs[2];
  int x_temp,y_temp;		/* location of the new window. */
  int parent_height,parent_width; /* Height and width of the parent widget or
				   the root window if it has no parent. */

  x_temp = x - left - Width(widget) / 2 + BorderWidth(widget);
  y_temp = y - above -  Height(widget) / 2 + BorderWidth(widget);

  parent_height = HeightOfScreen(XtScreen(widget));
  parent_width = WidthOfScreen(XtScreen(widget));

/*
 * Check to make sure that all edges are within the viewable part of the
 * root window, and if not then force them to be.
 */

  if (x_temp < h_space)
    x_temp = v_space;
  if (y_temp < v_space)
    (y_temp = 2);

  if ( y_temp + Height(widget) + v_space > parent_height )
      y_temp = parent_height - Height(widget) - v_space;

  if ( x_temp + Width(widget) + h_space > parent_width )
      x_temp = parent_width - Width(widget) - h_space;

  XtSetArg(wargs[0], XtNx, x_temp);
  XtSetArg(wargs[1], XtNy, y_temp);
  XtSetValues(widget, wargs, 2);
}

/*	Function Name: ParseEntry(entry, path, sect, page)
 *	Description: Parses the manual pages entry filenames.
 *	Arguments: str - the full path name.
 *                 path - the path name.      RETURNED
 *                 sect - the section name.   RETURNED
 *                 page - the page name.      RETURNED
 *	Returns: none.
 */

void
ParseEntry(char *entry, char *path, char *sect, char *page)
{
  char *c, temp[BUFSIZ];

  strcpy(temp, entry);

  c = rindex(temp, '/');
  if (c == NULL)
    PrintError("index failure in ParseEntry.");
  *c++ = '\0';
  if (page != NULL)
    strcpy(page, c);

  c = rindex(temp, '/');
  if (c == NULL)
    PrintError("index failure in ParseEntry.");
  *c++ = '\0';
#if defined(SFORMAT) && defined(SMAN)
  /* sgmltoroff sometimes puts an extra ./ in the path to .so entries */
  if (strcmp(c, ".") == 0) {
      c = rindex(temp, '/');
      if (c == NULL)
	  PrintError("index failure in ParseEntry.");
      *c++ = '\0';
  }
#endif      
#if defined(__OpenBSD__) || defined(__NetBSD__)
  /* Skip machine subdirectory if present */
  if (strcmp(c, MACHINE) == 0) {
      c = rindex(temp, '/');
      if (c == NULL)
	  PrintError("index failure in ParseEntry.");
      *c++ = '\0';
  }
#endif
  if (sect != NULL)
    strcpy(sect, c);

  if (path != NULL)
    strcpy(path, temp);
}

/*      Function Name: GetGlobals
 *      Description: Gets the psuedo globals associated with the
 *                   manpage associated with this widget.
 *      Arguments: w - a widget in the manpage.
 *      Returns: the psuedo globals.
 *      Notes: initial_widget is a globals variable.
 *             manglobals_context is a global variable.
 */

ManpageGlobals *
GetGlobals(Widget w)
{
  Widget temp;
  caddr_t data;

  while ( (temp = XtParent(w)) != initial_widget && (temp != NULL))
    w = temp;

  if (temp == NULL)
    XtAppError(XtWidgetToApplicationContext(w),
	       "Xman: Could not locate widget in tree, exiting");

  if (XFindContext(XtDisplay(w), XtWindow(w),
		   manglobals_context, &data) != XCSUCCESS)
    XtAppError(XtWidgetToApplicationContext(w),
	       "Xman: Could not find global data, exiting");

  return( (ManpageGlobals *) data);
}

/*      Function Name: SaveGlobals
 *      Description: Saves the psuedo globals on the widget passed
 *                   to this function, although GetGlobals assumes that
 *                   the data is associated with the popup child of topBox.
 *      Arguments: w - the widget to associate the data with.
 *                 globals - data to associate with this widget.
 *      Returns: none.
 *      Notes: WIDGET MUST BE REALIZED.
 *             manglobals_context is a global variable.
 */

void
SaveGlobals(Widget w, ManpageGlobals * globals)
{
  if (XSaveContext(XtDisplay(w), XtWindow(w), manglobals_context,
		   (caddr_t) globals) != XCSUCCESS)
    XtAppError(XtWidgetToApplicationContext(w),
	       "Xman: Could not save global data, are you out of memory?");
}

/*      Function Name: RemoveGlobals
 *      Description: Removes the psuedo globals from the widget passed
 *                   to this function.
 *      Arguments: w - the widget to remove the data from.
 *      Returns: none.
 *      Notes: WIDGET MUST BE REALIZED.
 *             manglobals_context is a global variable.
 */

void
RemoveGlobals(Widget w)
{
  if (XDeleteContext(XtDisplay(w), XtWindow(w),
		     manglobals_context) != XCSUCCESS)
    XtAppError(XtWidgetToApplicationContext(w),
	       "Xman: Could not remove global data?");
}
Exemplo n.º 21
0
/*
 * IconDraw
 *
 * Render given icon in the window of the given widget.
 */
void
IconDraw(
	Widget		widget,
	IconInfo	*iconPtr)
{
	static GC	graphicsContext = NULL;
	static XFontStruct *fontStruct;
	Display		*display = XtDisplayOfObject(widget);
	Window		window = XtWindow(widget);
	int		screen = DefaultScreen(display);
	XGCValues	gcValues;

	if (graphicsContext == NULL) {
		gcValues.foreground = BlackPixel(display, screen);
                gcValues.background = WhitePixel(display, screen);
                graphicsContext = XCreateGC(display, window,
                                GCForeground | GCBackground, &gcValues);
	}

	/*
	 * Draw icon
	 */

	gcValues.clip_mask = iconPtr->mask;
	gcValues.clip_x_origin = iconPtr->icon.x;
	gcValues.clip_y_origin = iconPtr->icon.y;
	XChangeGC(display, graphicsContext,
		GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcValues);
	XCopyPlane(display, iconPtr->bitmap, window, graphicsContext, 0, 0,
		iconPtr->icon.width, iconPtr->icon.height,
		iconPtr->icon.x, iconPtr->icon.y, 1L);

	/*
	 * Draw icon name centered below icon
	 */

        if (iconPtr->name != NULL) {
                int             nameX, nameY;
                int             direction, ascent, decent;
                XCharStruct     overall;
                Widget          xmScreen;
 
                if (fontStruct == NULL) {
                        xmScreen = XmGetXmScreen(XtScreen(widget));
                        XtVaGetValues(xmScreen, XmNfont, &fontStruct, NULL);
                }
                XTextExtents(fontStruct, iconPtr->name, strlen(iconPtr->name),
                        &direction, &ascent, &decent, &overall);
 
                nameX = (iconPtr->icon.x + (iconPtr->icon.width/2)) -
                        (overall.width/2);
                nameY = iconPtr->icon.y + iconPtr->icon.height +
                        ICON_TEXT_YGAP + ascent;
 
                gcValues.font = fontStruct->fid;
                gcValues.clip_mask = None;
                XChangeGC(display, graphicsContext,
                        GCFont | GCClipMask, &gcValues);
                XDrawString(display, window, graphicsContext, nameX, nameY,
                        iconPtr->name, strlen(iconPtr->name));
        }
}
Exemplo n.º 22
0
_XvicImageSetStringCursor(
   XvicImageWidget iw,
   char *name)
#endif /* _NO_PROTO */
{
   Display *dpy;
   char source_name[xvicPATH_MAX], mask_name[xvicPATH_MAX];
   int source_char, mask_char, fields;
   Font source_font, mask_font;
   XrmValue fromString, toFont;
   Boolean success;
#ifndef NO_XMU
   int i;
   unsigned int shape;
   Pixmap source, mask;
   int xhot, yhot;
   int len;
#endif

   dpy = XtDisplay((Widget)iw);

   /* Check for font name/glyph index form */

   if (strncmp(FONTSPECIFIER, name, strlen(FONTSPECIFIER)) == 0) {

      fields = sscanf(name, "FONT %s %d %s %d", source_name, &source_char,
			mask_name, &mask_char);
      if (fields < 2 || fields > 4) {
         XtAppWarningMsg(XtWidgetToApplicationContext((Widget)iw),
		"BadCursorString", "XvicImage", "XvicImageWidgetError",
		"Invalid format for Cursor string resource, cursor ignored",
		(String *)NULL, (Cardinal *)NULL);
         return;
      }

      fromString.addr = source_name;
      fromString.size = strlen(source_name) + 1;

#if XtSpecificationRelease <= 4
      XtConvert((Widget)iw, XtRString, &fromString, XtRFont, &toFont);
      success = (toFont.addr != NULL);
      if (success)
         source_font = *(Font *)toFont.addr;
#else
      toFont.addr = (XtPointer) &source_font;
      toFont.size = sizeof(Font);
      success = XtConvertAndStore((Widget)iw, XtRString, &fromString,
			XtRFont, &toFont);
#endif
      if (!success) {
         XtAppWarningMsg(XtWidgetToApplicationContext((Widget)iw),
		"BadCursorFont", "XvicImage", "XvicImageWidgetError",
		"Invalid font for Cursor string resource, cursor ignored",
		(String *)NULL, (Cardinal *)NULL);
         return;
      }

      switch (fields) {
         case 2:		/* defaulted mask font & char */
            mask_font = None;		/* thus there is no mask, really */
            mask_char = 0;
            break;

         case 3:		/* defaulted mask font */
            mask_font = source_font;
            mask_char = atoi(mask_name);
            break;

         case 4:		/* specified mask font & char */
            fromString.addr = mask_name;
            fromString.size = strlen(mask_name) + 1;

#if XtSpecificationRelease <= 4
            XtConvert((Widget)iw, XtRString, &fromString, XtRFont, &toFont);
            success = (toFont.addr != NULL);
            if (success)
               mask_font = *(Font *)toFont.addr;
#else
            toFont.addr = (XtPointer) &mask_font;
            toFont.size = sizeof(Font);
            success = XtConvertAndStore((Widget)iw, XtRString, &fromString,
				XtRFont, &toFont);
#endif
            if (!success) {
               XtAppWarningMsg(XtWidgetToApplicationContext((Widget)iw),
		"BadCursorMaskFont", "XvicImage", "XvicImageWidgetError",
		"Invalid mask font for Cursor string resource, cursor ignored",
		(String *)NULL, (Cardinal *)NULL);
               return;
            }
      }

      _XvicImageSetGlyphCursor(iw, source_font, mask_font,
		source_char, mask_char);
/*!!!! Do we need to free fonts here???? !!!!*/

      return;
   }

#ifdef NO_XMU

   if (strcmp(name, DEFAULT_CURSOR) == 0) {
      _XvicImageSetFontCursor(iw, DEFAULT_CURSOR_SHAPE);  /* default value */
      return;
   }
   XtAppWarningMsg(XtWidgetToApplicationContext((Widget)iw),
		"BadCursorString", "XvicImage", "XvicImageWidgetError",
		"Invalid format for Cursor string resource, cursor ignored",
		(String *)NULL, (Cardinal *)NULL);
   return;

#else			/* Xmu is available */

   /* Check for cursor shape name */

   shape = XmuCursorNameToIndex(name);
   if (shape != -1) {
      _XvicImageSetFontCursor(iw, shape);
      return;
   }

   /* Check for bitmap file name */

   source = XmuLocateBitmapFile(XtScreen((Widget)iw), name, 
		mask_name, (sizeof mask_name) - 4, NULL, NULL, &xhot, &yhot);
   if (source == None) {
      XtAppWarningMsg(XtWidgetToApplicationContext((Widget)iw),
		"BadCursorString", "XvicImage", "XvicImageWidgetError",
		"Invalid format for Cursor string resource, cursor ignored",
		(String *)NULL, (Cardinal *)NULL);
      return;
   }
   len = strlen (mask_name);
   for (i = 0; i < 2; i++) {
      strcpy (mask_name + len, i == 0 ? "Mask" : "msk");
      mask = XmuLocateBitmapFile (XtScreen((Widget)iw), mask_name, NULL, 0, 
				NULL, NULL, NULL, NULL);
      if (mask != None)
         break;
   }

   _XvicImageSetPixmapCursor(iw, source, mask, xhot, yhot);

   XFreePixmap(XtDisplay((Widget)iw), source);
   if (mask != None)
      XFreePixmap(XtDisplay((Widget)iw), mask);

   return;

#endif

}
Exemplo n.º 23
0
int
main (int argc, char **argv)
{
	int n1,n2,nz,iz,verbose,looping,nTic1,nTic2,width,height,interp;
	float d1,f1,d2,f2,*z,
		clip,bclip,wclip,white,wfrac,
		perc,bperc,wperc,*temp,
		bhue,whue,sat,bright,
		x1beg,x2beg,x1end,x2end,
		x1min,x1max,x2min,x2max,
		fframe,dframe;
	char *label1="",*label2="",*format="",*windowtitle="",
		*labelFont="",*titleFont="",
		*axesColor="",*gridColor="",*titleColor="",
		*style="normal",*grid1="none",*grid2="none",
		*cmap;
	ClientData cd;
	XrmValue from,to;
	Widget toplevel,axes;
	XtAppContext ac;
	Display *dpy;
	Window win;
	Arg args[98];
	int nargs;
	int scr;
	unsigned int depth;

	/* initialize getpar */
	initargs(argc,argv);
	requestdoc(1);

	/* get parameters describing colormaps */
	cmap = "gray";  getparstring("cmap",&cmap);
	if (STREQ("saturation",cmap)) cmap = "sat";
	bhue = 0;  getparfloat("bhue",&bhue);  bhue /= 360.0;
	whue = 240;  getparfloat("whue",&whue); whue /= 360.0;
	sat = 1.0; getparfloat("sat",&sat);
	if (sat<0.0 || sat>1.0) err("sat must be in range [0,1]!\n");
	bright = 1.0; getparfloat("bright",&bright);
	if (bright<0.0 || bright>1.0) err("bright must be in range [0,1]!\n");

	/* get parameters describing 1st dimension sampling */
	if (!getparint("n1",&n1))
		err("Must specify number of samples in 1st dimension!\n");
	if (!getparfloat("d1",&d1)) d1 = 1.0;
	if (!getparfloat("f1",&f1)) f1 = 0.0;
	x1min = (d1>0.0)?f1:f1+(n1-1)*d1;
	x1max = (d1<0.0)?f1:f1+(n1-1)*d1;
	if (!getparfloat("x1beg",&x1beg)) x1beg = x1min;
	if (!getparfloat("x1end",&x1end)) x1end = x1max;

	/* get parameters describing 2nd dimension sampling */
	if (!getparint("n2",&n2))
		err("Must specify number of samples in 2nd dimension!\n");
	if (!getparfloat("d2",&d2)) d2 = 1.0;
	if (!getparfloat("f2",&f2)) f2 = 0.0;
	x2min = (d2>0.0)?f2:f2+(n2-1)*d2;
	x2max = (d2<0.0)?f2:f2+(n2-1)*d2;
	if (!getparfloat("x2beg",&x2beg)) x2beg = x2min;
	if (!getparfloat("x2end",&x2end)) x2end = x2max;

	/* read first frame of float data */
	nz = n1*n2;
	z = ealloc1float(nz);
	if (fread(z,sizeof(float),nz,stdin)!=nz)
		err("error reading input file");

	/* if necessary, determine clips from percentiles */
	if (getparfloat("clip",&clip)) {
		bclip = clip;
		wclip = -clip;
	}
	if ((!getparfloat("bclip",&bclip) || !getparfloat("wclip",&wclip)) &&
		!getparfloat("clip",&clip)) {
		perc = 100.0;  getparfloat("perc",&perc);
		temp = ealloc1float(nz);
		for (iz=0; iz<nz; iz++)
			temp[iz] = z[iz];
		if (!getparfloat("bclip",&bclip)) {
			bperc = perc;	getparfloat("bperc",&bperc);
			iz = (nz*bperc/100.0);
			if (iz<0) iz = 0;
			if (iz>nz-1) iz = nz-1;
			qkfind(iz,nz,temp);
			bclip = temp[iz];
		}
		if (!getparfloat("wclip",&wclip)) {
			wperc = 100.0-perc;  getparfloat("wperc",&wperc);
			iz = (nz*wperc/100.0);
			if (iz<0) iz = 0;
			if (iz>nz-1) iz = nz-1;
			qkfind(iz,nz,temp);
			wclip = temp[iz];
		}
		free1float(temp);
	}
	if (!getparfloat("white",&white)) white = (bclip+wclip)/2.0;
	if (!getparint("verbose",&verbose)) verbose = 1;
	if (!getparint("sleep",&cd.sleep)) cd.sleep=0 ;
	if (!getparint("loop",&looping)) looping = 0;
	if (verbose) {
		if(STREQ(cmap,"sat") || STREQ(cmap,"customsat")) {
			warn("bclip=%g wclip=%g white=%g",bclip,wclip,white);
		} else {
			warn("bclip=%g wclip=%g",bclip,wclip);
		}
	}
	wfrac = (bclip!=wclip) ? (bclip-white)/(bclip-wclip) : 1.0;

	/* initialize toolkit and set toplevel parameters */
 	toplevel = XtAppInitialize(&ac,"XMovie_XAPP_DEF",NULL,0,&argc,argv,NULL,NULL,0);
	dpy = XtDisplay(toplevel);
	nargs = 0;
	if (getparstring("windowtitle",&windowtitle))
		{XtSetArg(args[nargs],XtNtitle,windowtitle); nargs++;}
	if (getparstring("windowtitle",&windowtitle))
		{XtSetArg(args[nargs],XtNiconName,windowtitle); nargs++;}
	if (getparint("width",&width))
		{XtSetArg(args[nargs],XtNwidth,width); nargs++;}
	if (getparint("height",&height))
		{XtSetArg(args[nargs],XtNheight,height); nargs++;}
	XtSetArg(args[nargs],XtNinput,TRUE);nargs++; 
	XtSetValues(toplevel,args,nargs);

	/* if necessary, make private colormap */
	win = XRootWindowOfScreen(XtScreen(toplevel));
	nargs = 0;

	scr=DefaultScreen(dpy);
	depth=(unsigned int)DefaultDepth(dpy,scr);

	if (depth<=8) {
	  if (STREQ(cmap,"gray")) {
	    Colormap cm=XtcwpCreateGrayColormap(dpy,win);
	    XtSetArg(args[nargs],XtNcolormap,cm); nargs++;
	  } else if (STREQ(cmap,"hue")) {
	    Colormap cm=XtcwpCreateHueColormap(dpy,win,
					       bhue,whue,sat,bright);
	    XtSetArg(args[nargs],XtNcolormap,cm); nargs++;
	  } else if (STREQ(cmap,"sat")) {
	    Colormap cm=XtcwpCreateSatColormap(dpy,win,
					       bhue,whue,wfrac,bright);

	    XtSetArg(args[nargs],XtNcolormap,cm); nargs++;
	  }
	  XtSetValues(toplevel,args,nargs);
	}

	/* create axes and set axes parameters */
	axes = XtCreateManagedWidget("axes",xtcwpAxesWidgetClass, 
		toplevel,NULL,0);
		
	nargs = 0;

	if (getparstring("grid1",&grid1)) {
		from.addr = (char *)grid1;
		XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesGrid,&to);
		if (to.addr) XtSetArg(args[nargs],XtNgrid1,*((int*)to.addr));
		nargs++;
	}
	if (getparstring("grid2",&grid2)) {
		from.addr = (char *)grid2;
		XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesGrid,&to);
		if (to.addr) XtSetArg(args[nargs],XtNgrid2,*((int*)to.addr));
		nargs++;
	}

	if (getparint("nTic1",&nTic1))
		{XtSetArg(args[nargs],XtNnTic1,nTic1); nargs++;}
	if (getparint("nTic2",&nTic2))
		{XtSetArg(args[nargs],XtNnTic2,nTic2); nargs++;}
	if (getparstring("label1",&label1))
		{XtSetArg(args[nargs],XtNlabel1,label1); nargs++;}
	if (getparstring("label2",&label2))
		{XtSetArg(args[nargs],XtNlabel2,label2); nargs++;}
	if (getparstring("title",&format))
		{XtSetArg(args[nargs],XtNtitle,format); nargs++;}
	if (getparstring("style",&style)) {
		from.size = (unsigned int) strlen(style);  from.addr = (char *)style;
		XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesStyle,&to);
		if (to.addr) XtSetArg(args[nargs],XtNstyle,*((int*)to.addr));
		nargs++;
	}
	if (getparstring("axesColor",&axesColor)) {
		from.addr = (char *)axesColor;
		XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to);
		if (to.addr) XtSetArg(args[nargs],XtNaxesColor,
			*((unsigned long*)to.addr));
		nargs++;
	}
	if (getparstring("gridColor",&gridColor)) {
		from.addr = (char *)gridColor;
		XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to);
		if (to.addr) XtSetArg(args[nargs],XtNgridColor,
			*((unsigned long*)to.addr));
		nargs++;
	}
	if (getparstring("titleColor",&titleColor)) {
		from.addr = (char *)titleColor;
		XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to);
		if (to.addr) XtSetArg(args[nargs],XtNtitleColor,
			*((unsigned long*)to.addr));
		nargs++;
	}
	if (getparstring("labelFont",&labelFont)) {
		from.addr = (char *)labelFont;
		XtConvertAndStore(axes,XtRString,&from,XtRFont,&to);
		if (to.addr) XtSetArg(args[nargs],XtNlabelFont,
			*((Font*)to.addr));
		nargs++;
	}
	if (getparstring("titleFont",&titleFont)) {
		from.addr = (char *)titleFont;
		XtConvertAndStore(axes,XtRString,&from,XtRFont,&to);
		if (to.addr) XtSetArg(args[nargs],XtNtitleFont,
			*((Font*)to.addr));
		nargs++;
	}
	XtSetValues(axes,args,nargs);
	x1beg = x1min; getparfloat("x1beg",&x1beg);
	x1end = x1max; getparfloat("x1end",&x1end);
	x2beg = x2min; getparfloat("x2beg",&x2beg);
	x2end = x2max; getparfloat("x2end",&x2end);
	adjustAxesValues(n1,d1,f1,n2,d2,f2,&x1beg,&x1end,&x2beg,&x2end);
	XtcwpSetAxesValues(axes,x1beg,x1end,x2beg,x2end);

	/* frame sampling */
	if (!getparfloat("fframe",&fframe)) fframe = 1.0;
	if (!getparfloat("dframe",&dframe)) dframe = 1.0;

	/* interpolation */
	if (!getparint("interp",&interp)) interp = 1;

	/* initial display mode: cont or step */
	if (!getparint("idm", &displayMode)) displayMode = DM_CONT;

	checkpars();

	/* initialize client data */
	cd.n1 = n1;  cd.d1 = d1;  cd.f1 = f1;
	cd.n2 = n2;  cd.d2 = d2;  cd.f2 = f2;
	cd.floats = z;
	cd.fmin = bclip;
	cd.fmax = wclip;
	cd.bmin = (unsigned char) (XtcwpGetFirstPixel(dpy));
	cd.bmax = (unsigned char) (XtcwpGetLastPixel(dpy));
	if(cd.bmax==0)cd.bmax=255;
	warn("bmin=%d bmax=%d",cd.bmin,cd.bmax);
	cd.x1bega = x1beg;
	cd.x1enda = x1end;
	cd.x2bega = x2beg;
	cd.x2enda = x2end;
	cd.abytes = NULL;
	cd.bbytes = NULL;
	cd.image = NULL;
	cd.exposed = 0;
	cd.noframes = 1;
	cd.axes = axes;
	cd.looping = looping;
	cd.frame = NULL;
	cd.format = format;
	cd.iframe = 0;
	cd.fframe = fframe;
	cd.dframe = dframe;
	cd.interp = interp;
	cd.forward = 1;
	cd.ac = ac;

	/* adjust axes title if formatted */
	if (strchr(cd.format,'%') && !strstr(cd.format,"%%")) {
		sprintf(cd.title,cd.format,cd.fframe+cd.iframe*cd.dframe);
		XtVaSetValues(cd.axes,XtNtitle,cd.title,NULL);
	}

	/* add work procedure */
	cd.wpid = XtAppAddWorkProc(ac,(XtWorkProc) readFrame,&cd);

	/* add callbacks to axes widget */
	XtAddCallback(axes,XtNresizeCallback,(XtCallbackProc) resizeCB,&cd);
	XtAddCallback(axes,XtNexposeCallback,(XtCallbackProc) exposeCB,&cd);
	XtAddCallback(axes,XtNinputCallback,(XtCallbackProc) inputCB,&cd);

	/* add Button2 translation for reversing the movie */
	XtOverrideTranslations(axes,
		XtParseTranslationTable("<Btn2Up>: input()"));

	/* add Button3 translation for pausing the movie */
	XtOverrideTranslations(axes,
		XtParseTranslationTable("<Btn3Up>: input()"));

	/* set up keypress */
	XtAddEventHandler(axes, KeyPress, FALSE,
			  (XtEventHandler) key_pressed, &cd);

	/* realize everything */
	XtRealizeWidget(toplevel);

	/* go */
	XtAppMainLoop(ac);

	return EXIT_SUCCESS;
}
Exemplo n.º 24
0
int
main(int argc, char **argv)
{
    struct { char x; void *y; } z;
    char b[256];
    char *f, *s, *t;
#if MP_GUI_SUPPORT
    XGCValues g;
#endif /* MP_GUI_SUPPORT */
    long n;
    int c, e, h, v;

#if MP_GUI_SUPPORT
    appwidget = XtVaAppInitialize(&appcontext, "MPTrace", options,
                                  XtNumber(options), &argc, argv, NULL, NULL);
    XtVaGetApplicationResources(appwidget, NULL, resources, XtNumber(resources),
                                NULL);
#endif /* MP_GUI_SUPPORT */
    s = t = NULL;
    e = h = v = 0;
    progname = __mp_basename(argv[0]);
    while ((c = __mp_getopt(argc, argv, __mp_shortopts(b, options_table),
             options_table)) != EOF)
        switch (c)
        {
          case OF_GUI:
#if MP_GUI_SUPPORT
            usegui = 1;
#endif /* MP_GUI_SUPPORT */
            break;
          case OF_HATFFILE:
            t = __mp_optarg;
            break;
          case OF_HELP:
            h = 1;
            break;
          case OF_SIMFILE:
            s = __mp_optarg;
            break;
          case OF_SOURCE:
            displaysource = 1;
            break;
          case OF_VERBOSE:
            verbose = 1;
            break;
          case OF_VERSION:
            v = 1;
            break;
          default:
            e = 1;
            break;
        }
    argc -= __mp_optindex;
    argv += __mp_optindex;
    if (v == 1)
    {
        fprintf(stdout, "%s %s\n%s %s\n\n", progname, PROGVERSION,
                __mp_copyright, __mp_author);
        fputs("This is free software, and you are welcome to redistribute it "
              "under certain\n", stdout);
        fputs("conditions; see the GNU Lesser General Public License for "
              "details.\n\n", stdout);
        fputs("For the latest mpatrol release and documentation,\n", stdout);
        fprintf(stdout, "visit %s.\n\n", __mp_homepage);
    }
    if (argc > 1)
        e = 1;
    if ((e == 1) || (h == 1))
    {
        fprintf(stdout, "Usage: %s [options] [file]\n\n", progname);
        if (h == 0)
            fprintf(stdout, "Type `%s --help' for a complete list of "
                    "options.\n", progname);
        else
            __mp_showopts(options_table);
        if (e == 1)
            exit(EXIT_FAILURE);
        exit(EXIT_SUCCESS);
    }
    if (argc == 1)
        f = argv[0];
    else
        f = MP_TRACEFILE;
    __mp_newtree(&alloctree);
    if (strcmp(f, "-") == 0)
        tracefile = stdin;
    else if ((tracefile = fopen(f, "rb")) == NULL)
    {
        fprintf(stderr, "%s: Cannot open file `%s'\n", progname, f);
        exit(EXIT_FAILURE);
    }
    currentevent = 0;
    bufferpos = buffer;
    bufferlen = 0;
    n = (char *) &z.y - &z.x;
    __mp_newslots(&table, sizeof(void *), __mp_poweroftwo(n));
    __mp_initslots(&table, tableslots, sizeof(tableslots));
    maxslots = 1;
    if (s != NULL)
    {
        if (strcmp(s, "stdout") == 0)
            simfile = stdout;
        else if (strcmp(s, "stderr") == 0)
            simfile = stderr;
        else if ((simfile = fopen(s, "w")) == NULL)
        {
            fprintf(stderr, "%s: Cannot open file `%s'\n", progname, s);
            exit(EXIT_FAILURE);
        }
        fprintf(simfile, "/* produced by %s %s from %s */\n\n\n", progname,
                PROGVERSION, f);
        fputs("#include <stdio.h>\n", simfile);
        fputs("#include <stdlib.h>\n\n\n", simfile);
        fputs("typedef struct event\n{\n", simfile);
        fputs("    unsigned long index;\n", simfile);
        fputs("    unsigned long size;\n", simfile);
        fputs("    char resize;\n", simfile);
        fputs("}\nevent;\n\n\n", simfile);
        fputs("static event events[] =\n{\n", simfile);
    }
    if (t != NULL)
    {
        if (strcmp(t, "stdout") == 0)
            hatffile = stdout;
        else if (strcmp(t, "stderr") == 0)
            hatffile = stderr;
        else if ((hatffile = fopen(t, "w")) == NULL)
        {
            fprintf(stderr, "%s: Cannot open file `%s'\n", progname, t);
            exit(EXIT_FAILURE);
        }
        fprintf(hatffile, "## Tracename: %s\n", t);
        fputs("## Author: Unknown\n", hatffile);
        fputs("## Date: Unknown\n", hatffile);
        fputs("## DTDURL: hatf.dtd\n", hatffile);
        fprintf(hatffile, "## Description: Converted to HATF by %s %s.\n\n",
                progname, PROGVERSION);
    }
    readfile();
#if MP_GUI_SUPPORT
    if (usegui)
    {
        appdisplay = XtDisplay(appwidget);
        appscreen = XtScreen(appwidget);
        addrscale = (((addrspace * 1048576) - 1) / (width * height)) + 1;
        /* Set up the main application window and scrollable drawing area.
         * Also set up a pixmap to backup the drawing area.
         */
        mainwidget = XtVaCreateManagedWidget("main",
                                             xmScrolledWindowWidgetClass,
                                             appwidget, XmNwidth, vwidth,
                                             XmNheight, vheight,
                                             XmNscrollingPolicy, XmAUTOMATIC,
                                             XmNscrollBarDisplayPolicy,
                                             XmAS_NEEDED, NULL);
        drawwidget = XtVaCreateManagedWidget("draw", xmDrawingAreaWidgetClass,
                                             mainwidget, XmNwidth, width,
                                             XmNheight, height, NULL);
        pixmap = XCreatePixmap(appdisplay, RootWindowOfScreen(appscreen), width,
                               height, DefaultDepthOfScreen(appscreen));
        /* Set up the graphics contexts that are used for drawing in different
         * colours.
         */
        g.foreground = uncol;
        ungc = XCreateGC(appdisplay, RootWindowOfScreen(appscreen),
                         GCForeground, &g);
        g.foreground = incol;
        ingc = XCreateGC(appdisplay, RootWindowOfScreen(appscreen),
                         GCForeground, &g);
        g.foreground = frcol;
        frgc = XCreateGC(appdisplay, RootWindowOfScreen(appscreen),
                         GCForeground, &g);
        g.foreground = alcol;
        algc = XCreateGC(appdisplay, RootWindowOfScreen(appscreen),
                         GCForeground, &g);
        /* Add a callback procedure to handle the refreshing of the drawing
         * area and also a work procedure to read events from the tracing
         * output file.  Then initialise the drawing area and enter the main X
         * application loop.
         */
        XtAddCallback(drawwidget, XmNexposeCallback,
                      (XtCallbackProc) redrawmemory, NULL);
        XtAppAddWorkProc(appcontext, (XtWorkProc) readevent, NULL);
        XtRealizeWidget(appwidget);
        XFillRectangle(appdisplay, XtWindow(drawwidget), ungc, 0, 0, width - 1,
                       height - 1);
        XFillRectangle(appdisplay, pixmap, ungc, 0, 0, width - 1, height - 1);
        XtAppMainLoop(appcontext);
    }
#endif /* MP_GUI_SUPPORT */
    return EXIT_SUCCESS;
}
Exemplo n.º 25
0
int
main(int argc, char **argv)
{
  Widget toplevel, rc, one;
  XtAppContext app;

  XtSetLanguageProc(NULL, NULL, NULL);

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

  rc = XmCreateRowColumn(toplevel, "RC", NULL, 0);

  one = XltCreateBubbleButton(rc, "BubbleButton1", NULL, 0);
  XtAddCallback(one, XmNactivateCallback, (XtCallbackProc)Callback, NULL);
  {
  XmString string;

  string = XmStringCreateSimple("MouseOver");
  XtVaSetValues(one,
  	XmNalignment, XmALIGNMENT_CENTER,
  	XltNmouseOverString, string,
  	NULL);
  XmStringFree(string);
  }
  XtManageChild(one);
  one = XltCreateBubbleButton(rc, "BubbleButton2", NULL, 0);
  {
    Pixmap pixmap;
    Pixmap pixmap_insens;
    XpmAttributes attrib;
    GC gc;

    {
	XpmColorSymbol colors[1];

	XtVaGetValues(one,
		      XmNbackground, &colors[0].pixel,
		      NULL);
	colors[0].name = NULL;
	colors[0].value = "None";
	attrib.valuemask = XpmCloseness | XpmColorSymbols;
	attrib.closeness = 40000;
	attrib.colorsymbols = colors;
	attrib.numsymbols = 1;
	XpmCreatePixmapFromData(XtDisplay(one),
				XRootWindowOfScreen(XtScreen(one)),
				dates,
				&pixmap,
				NULL,
				&attrib);

	pixmap_insens = XCreatePixmap(XtDisplay(one),
				      pixmap,
				      attrib.width,
				      attrib.height,
				      DefaultDepthOfScreen(XtScreen(one)));
	gc = XDefaultGCOfScreen(XtScreen(one));
	XSetFunction(XtDisplay(one),gc,GXcopy);
	XCopyArea(XtDisplay(one),
		  pixmap,
		  pixmap_insens,
		  gc,
		  0, 0,
		  attrib.width, attrib.height,
		  0, 0);
	XSetFillStyle(XtDisplay(one), gc, FillStippled);
	XSetStipple(XtDisplay(one), gc,
		    XmGetPixmapByDepth(XtScreen(one),
				       "25_foreground",
				       1 /*WhitePixelOfScreen(XtScreen(ToolBar))*/,
				       0 /*BlackPixelOfScreen(XtScreen(ToolBar))*/,
				       1));
	XFillRectangle(XtDisplay(one),
		       pixmap_insens,
		       gc,
		       0, 0,
		       attrib.width + 1, attrib.height + 1);

	XpmFreeAttributes(&attrib);

	XtVaSetValues(one,
		      XmNalignment, XmALIGNMENT_CENTER,
		      XmNlabelType, XmPIXMAP,
		      XmNlabelPixmap, pixmap,
		      XltNmouseOverPixmap, pixmap_insens,
		      NULL);
    }
  }
  XtAddCallback(one, XmNactivateCallback, (XtCallbackProc)Callback, NULL);
  XtManageChild(one);

  XtManageChild(rc);

  XtRealizeWidget(toplevel);
  XtAppMainLoop(app);

  exit(0);
}
Exemplo n.º 26
0
static void
ToolTipPost (XtPointer client_data,
             XtIntervalId * id)
{
    Widget w = (Widget) client_data;

    int rx,
        ry,
        x,
        y;
    unsigned int key;
    Window root,
           child;
    XtWidgetGeometry geo;
    Position destX,
             destY;

    XmToolTipConfigTrait ttp; /* ToolTip pointer */

    ttp = ToolTipGetData (w);

    if (ttp == NULL)
    {
        XtWarning ("ToolTipGetData() returned NULL in ToolTipPost()");
        return;
    }

    ttp->timer = (XtIntervalId) NULL;

    XQueryPointer (XtDisplay (w),
                   XtWindow (w), &root, &child, &rx, &ry, &x, &y, &key);

    if (ttp->duration_timer != (XtIntervalId) NULL)
    {
        XtRemoveTimeOut (ttp->duration_timer);
        ttp->duration_timer = (XtIntervalId) NULL;
    }

    if (XmIsPrimitive(w) || XmIsGadget(w))
    {
        XtVaSetValues (ttp->label,
                       XmNlabelString,
                       XmGetToolTipString(w),
                       NULL);
    }
    else
    {
        XmString string;

        string = XmStringCreateLocalized (XtName (w));
        XtVaSetValues (ttp->label, XmNlabelString, string, NULL);
        XmStringFree (string);
    }
    XtQueryGeometry (ttp->label, NULL, &geo);

    /* rws 25 Feb 2001
       Fix for Bug #1153
       Don't let the tip be off the right/bottom of the screen
     */
    destX = rx + (XmIsGadget (w) ? XtX (w) : 0) - x + XtWidth (w) / 2;
    if (destX + geo.width > WidthOfScreen (XtScreen (w)))
    {
        destX = WidthOfScreen (XtScreen (w)) - geo.width;
    }
    destY = ry + (XmIsGadget (w) ? XtY (w) : 0) - y + XtHeight (w);
    if (destY + geo.height > HeightOfScreen (XtScreen (w)))
    {
        destY = ry + (XmIsGadget (w) ? XtY (w) : 0) - y - geo.height;
    }

    XtVaSetValues (XtParent (ttp->label),
                   XmNx, rx + 1,
                   XmNy, ry + 1, XmNwidth, 1, XmNheight, 1, NULL);
    ttp->slider =
        XtVaCreateWidget ("ToolTipSlider", xmSlideContextWidgetClass,
                          XmGetXmDisplay (XtDisplay (w)), XmNslideWidget,
                          XtParent (ttp->label),
                          XmNslideDestX, destX,
                          XmNslideDestY, destY,
                          XmNslideDestWidth, geo.width,
                          XmNslideDestHeight, geo.height, NULL);

    XtAddCallback (ttp->slider, XmNslideFinishCallback,
                   (XtCallbackProc) ToolTipPostFinish, ttp);

    XtPopup (XtParent (ttp->label), XtGrabNone);
}
Exemplo n.º 27
0
void create_ci_equiplist_shell (Widget parent)
{
	Widget children[10];      /* Children to manage */
	Arg al[64];                    /* Arg List */
	register int ac = 0;           /* Arg Count */
	Pixel fg, bg;                    /* colour values for pixmaps */ 
	XmString xmstrings[16];    /* temporary storage for XmStrings */

	XtSetArg(al[ac], XmNallowShellResize, TRUE); ac++;
	XtSetArg(al[ac], XmNminWidth, 787); ac++;
	XtSetArg(al[ac], XmNminHeight, 496); ac++;
	ci_equiplist_shell = XtCreatePopupShell ( "ci_equiplist_shell", topLevelShellWidgetClass, parent, al, ac );
	ac = 0;
/* begin ci_equipinfo_form pre-creation code */

XtVaSetValues(ci_equiplist_shell, XmNiconPixmap, abp_icon, NULL) ;

/* end ci_equipinfo_form pre-creation code */
	XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
	XtSetArg(al[ac], XmNautoUnmanage, FALSE); ac++;
	ci_equiplist_form = XmCreateForm ( ci_equiplist_shell, "ci_equiplist_form", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
	XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
	ci_equip_account_form = XmCreateForm ( ci_equiplist_form, "ci_equip_account_form", al, ac );
	ac = 0;
	ci_equip_account_id_lbl = XmCreateLabel ( ci_equip_account_form, "ci_equip_account_id_lbl", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 48); ac++;
	XtSetArg(al[ac], XmNcolumns, 48); ac++;
	ci_equip_accountid_txt = XmCreateText ( ci_equip_account_form, "ci_equip_accountid_txt", al, ac );
	ac = 0;
	ci_equip_account_name_lbl = XmCreateLabel ( ci_equip_account_form, "ci_equip_account_name_lbl", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 40); ac++;
	XtSetArg(al[ac], XmNcolumns, 40); ac++;
	ci_equip_name_txt = XmCreateText ( ci_equip_account_form, "ci_equip_name_txt", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
	XtSetArg(al[ac], XmNshadowType, XmSHADOW_IN); ac++;
	ci_equiplist_filter_form = XmCreateForm ( ci_equiplist_form, "ci_equiplist_filter_form", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ac++;
	XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
	XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN); ac++;
	XtSetArg(al[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
	ci_equip_filter_rc = XmCreateRowColumn ( ci_equiplist_filter_form, "ci_equip_filter_rc", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNhighlightOnEnter, FALSE); ac++;
	ci_equip_filter_btn = XmCreatePushButton ( ci_equip_filter_rc, "ci_equip_filter_btn", al, ac );
	ac = 0;
	xmstrings[0] = XmStringCreateLtoR("Reset", (XmStringCharSet)XmFONTLIST_DEFAULT_TAG);
	XtSetArg(al[ac], XmNlabelString, xmstrings[0]); ac++;
	ci_equip_reset_btn = XmCreatePushButton ( ci_equip_filter_rc, "ci_equip_reset_btn", al, ac );
	ac = 0;
	XmStringFree ( xmstrings [ 0 ] );
	XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
	ci_equip_filter_equip_lbl = XmCreateLabel ( ci_equiplist_filter_form, "ci_equip_filter_equip_lbl", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
	ci_equip_filter_status_lbl = XmCreateLabel ( ci_equiplist_filter_form, "ci_equip_filter_status_lbl", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
	XtSetArg(al[ac], XmNmaxLength, 16); ac++;
	XtSetArg(al[ac], XmNcolumns, 16); ac++;
	XtSetArg(al[ac], XmNmarginHeight, 3); ac++;
	XtSetArg(al[ac], XmNmarginWidth, 3); ac++;
	ci_equip_filter_equip_txt = XmCreateText ( ci_equiplist_filter_form, "ci_equip_filter_equip_txt", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNhighlightOnEnter, TRUE); ac++;
	XtSetArg(al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
	XtSetArg(al[ac], XmNmaxLength, 10); ac++;
	XtSetArg(al[ac], XmNcolumns, 10); ac++;
	XtSetArg(al[ac], XmNmarginHeight, 3); ac++;
	XtSetArg(al[ac], XmNmarginWidth, 3); ac++;
	ci_filter_status_txt = XmCreateText ( ci_equiplist_filter_form, "ci_filter_status_txt", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
	XtSetArg(al[ac], XmNmarginHeight, 0); ac++;
	XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
	ci_equip_status_btn = XmCreatePushButton ( ci_equiplist_filter_form, "ci_equip_status_btn", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNforeground, &fg ); ac++;
	XtSetArg(al[ac], XmNbackground, &bg ); ac++;
	XtGetValues(ci_equip_status_btn, al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNlabelPixmap, XmGetPixmap ( XtScreen ( ci_equip_status_btn ), "down_arrow.xbm", fg, bg )); ac++;
	XtSetArg(al[ac], XmNlabelInsensitivePixmap, XmGetPixmap ( XtScreen ( ci_equip_status_btn ), "down_arrow.xbm", fg, bg )); ac++;
	XtSetValues ( ci_equip_status_btn,al, ac );
	ac = 0;
	ci_filter_ckt_lbl = XmCreateLabel ( ci_equiplist_filter_form, "ci_filter_ckt_lbl", al, ac );
	XtSetArg(al[ac], XmNmaxLength, 16); ac++;
	XtSetArg(al[ac], XmNcolumns, 16); ac++;
	ci_filter_ckt_txt = XmCreateText ( ci_equiplist_filter_form, "ci_filter_ckt_txt", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
	XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN); ac++;
	XtSetArg(al[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
	ci_filter_radio = XmCreateRadioBox ( ci_equiplist_filter_form, "ci_filter_radio", al, ac );
	ac = 0;
	ci_filter_owned_tgl = XmCreateToggleButtonGadget ( ci_filter_radio, "ci_filter_owned_tgl", al, ac );
	ci_filter_billed_tgl = XmCreateToggleButtonGadget ( ci_filter_radio, "ci_filter_billed_tgl", al, ac );
	XtSetArg(al[ac], XmNseparatorType, XmNO_LINE); ac++;
	ci_filter_sep1 = XmCreateSeparator ( ci_equiplist_filter_form, "ci_filter_sep1", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
	XtSetArg(al[ac], XmNshadowType, XmSHADOW_IN); ac++;
	XtSetArg(al[ac], XmNautoUnmanage, FALSE); ac++;
	XtSetArg(al[ac], XmNhorizontalSpacing, 5); ac++;
	XtSetArg(al[ac], XmNverticalSpacing, 3); ac++;
	ci_equip_sort_form = XmCreateForm ( ci_equiplist_form, "ci_equip_sort_form", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ac++;
	XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
	XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN); ac++;
	XtSetArg(al[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
	ci_equip_sort_rc_btn = XmCreateRowColumn ( ci_equip_sort_form, "ci_equip_sort_rc_btn", al, ac );
	ac = 0;
	ci_equip_sort_btn = XmCreatePushButton ( ci_equip_sort_rc_btn, "ci_equip_sort_btn", al, ac );
	ci_equip_sort_reset_btn = XmCreatePushButton ( ci_equip_sort_rc_btn, "ci_equip_sort_reset_btn", al, ac );
	XtSetArg(al[ac], XmNheight, 78); ac++;
	XtSetArg(al[ac], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ac++;
	XtSetArg(al[ac], XmNspacing, 0); ac++;
	XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
	XtSetArg(al[ac], XmNmarginHeight, 0); ac++;
	ci_equip_sort_tgls = XmCreateRowColumn ( ci_equip_sort_form, "ci_equip_sort_tgls", al, ac );
	ac = 0;
	ci_equip_sort_status_tgl = XmCreateToggleButton ( ci_equip_sort_tgls, "ci_equip_sort_status_tgl", al, ac );
	XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
	ci_equip_sort_equip_tgl = XmCreateToggleButton ( ci_equip_sort_tgls, "ci_equip_sort_equip_tgl", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
	ci_equip_sort_date_tgl = XmCreateToggleButton ( ci_equip_sort_tgls, "ci_equip_sort_date_tgl", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
	ci_equip_sort_rev_lbl = XmCreateLabel ( ci_equip_sort_form, "ci_equip_sort_rev_lbl", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNnavigationType, XmEXCLUSIVE_TAB_GROUP); ac++;
	XtSetArg(al[ac], XmNspacing, 0); ac++;
	XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
	XtSetArg(al[ac], XmNmarginHeight, 0); ac++;
	ci_equip_sort_rev_tgls = XmCreateRowColumn ( ci_equip_sort_form, "ci_equip_sort_rev_tgls", al, ac );
	ac = 0;
	ci_equip_sort_status_rev_tgl = XmCreateToggleButton ( ci_equip_sort_rev_tgls, "ci_equip_sort_status_rev_tgl", al, ac );
	ci_equip_sort_equip_rev_tgl = XmCreateToggleButton ( ci_equip_sort_rev_tgls, "ci_equip_sort_equip_rev_tgl", al, ac );
	ci_equip_sort_date_rev_tgl = XmCreateToggleButton ( ci_equip_sort_rev_tgls, "ci_equip_sort_date_rev_tgl", al, ac );
	XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
	ci_equip_sort_order_lbl = XmCreateLabel ( ci_equip_sort_form, "ci_equip_sort_order_lbl", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNmaxLength, 300); ac++;
	XtSetArg(al[ac], XmNcolumns, 31); ac++;
	XtSetArg(al[ac], XmNmarginHeight, 1); ac++;
	XtSetArg(al[ac], XmNmarginWidth, 1); ac++;
	XtSetArg(al[ac], XmNeditable, FALSE); ac++;
	XtSetArg(al[ac], XmNcursorPositionVisible, FALSE); ac++;
	XtSetArg(al[ac], XmNautoShowCursorPosition, FALSE); ac++;
	ci_equip_sort_orderby_txt = XmCreateText ( ci_equip_sort_form, "ci_equip_sort_orderby_txt", al, ac );
	ac = 0;
	ci_equip_sort_by_lbl = XmCreateLabel ( ci_equip_sort_form, "ci_equip_sort_by_lbl", al, ac );
	XtSetArg(al[ac], XmNresizePolicy, XmRESIZE_NONE); ac++;
	XtSetArg(al[ac], XmNshadowType, XmSHADOW_IN); ac++;
	XtSetArg(al[ac], XmNverticalSpacing, 0); ac++;
	ci_subscrlist_form = XmCreateForm ( ci_equiplist_form, "ci_subscrlist_form", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
	equip_emf_lbl = XmCreateLabel ( ci_subscrlist_form, "equip_emf_lbl", al, ac );
	ac = 0;
	XtSetArg(al[ac], XmNheight, 151); ac++;
	XtSetArg(al[ac], XmNhighlightOnEnter, TRUE); ac++;
	XtSetArg(al[ac], XmNvisibleItemCount, 9); ac++;
	XtSetArg(al[ac], XmNselectionPolicy, XmSINGLE_SELECT); ac++;
	XtSetArg(al[ac], XmNscrollBarDisplayPolicy, XmSTATIC); ac++;
	XtSetArg(al[ac], XmNlistSizePolicy, XmCONSTANT); ac++;
	ci_equiplist = XmCreateScrolledList ( ci_subscrlist_form, "ci_equiplist", al, ac );
	ac = 0;
	ci_equipslist = XtParent ( ci_equiplist );

	XtSetArg(al[ac], XmNhorizontalScrollBar, &ci_equipHscrollbar ); ac++;
	XtSetArg(al[ac], XmNverticalScrollBar, &ci_equipVscrollbar ); ac++;
	XtGetValues(ci_equipslist, al, ac );
	ac = 0;
	ci_equiplist_btn_form = XmCreateForm ( ci_equiplist_form, "ci_equiplist_btn_form", al, ac );
	XtSetArg(al[ac], XmNspacing, 20); ac++;
	XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
	XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN); ac++;
	XtSetArg(al[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
	ci_equiplist_rowcol = XmCreateRowColumn ( ci_equiplist_btn_form, "ci_equiplist_rowcol", al, ac );
	ac = 0;
	ci_equiplist_prov_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_prov_btn", al, ac );
	ci_equiplist_modify_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_modify_btn", al, ac );
	ci_equiplist_disc_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_disc_btn", al, ac );
	ci_equiplist_contract_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_contract_btn", al, ac );
	ci_equiplist_close_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_close_btn", al, ac );
	ci_equiplist_help_btn = XmCreatePushButton ( ci_equiplist_rowcol, "ci_equiplist_help_btn", al, ac );
	ci_equip_status_txt = XmCreateText ( ci_equiplist_btn_form, "ci_equip_status_txt", al, ac );

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 0); ac++;
	XtSetValues ( ci_equip_account_form,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 10); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_account_form); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 10); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNrightPosition, 45); ac++;
	XtSetValues ( ci_equiplist_filter_form,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 10); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_account_form); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_equiplist_filter_form); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNleftOffset, 10); ac++;
	XtSetArg(al[ac], XmNleftWidget, ci_equiplist_filter_form); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 10); ac++;
	XtSetValues ( ci_equip_sort_form,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 10); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equiplist_filter_form); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_equiplist_btn_form); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 10); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 10); ac++;
	XtSetValues ( ci_subscrlist_form,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 1); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 1); ac++;
	XtSetValues ( ci_equiplist_btn_form,al, ac );
	ac = 0;
	XtAddCallback (ci_equiplist_form,XmNhelpCallback, XDhelp_link, (XtPointer) &_xd_help_pairs[0] );

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_accountid_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_equip_accountid_txt); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNrightOffset, 5); ac++;
	XtSetArg(al[ac], XmNrightWidget, ci_equip_accountid_txt); ac++;
	XtSetValues ( ci_equip_account_id_lbl,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 5); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 100); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_accountid_txt,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_name_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_equip_name_txt); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNrightOffset, 5); ac++;
	XtSetArg(al[ac], XmNrightWidget, ci_equip_name_txt); ac++;
	XtSetValues ( ci_equip_account_name_lbl,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 5); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 5); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 500); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_name_txt,al, ac );
	ac = 0;
	children[ac++] = ci_equip_account_id_lbl;
	children[ac++] = ci_equip_accountid_txt;
	children[ac++] = ci_equip_account_name_lbl;
	children[ac++] = ci_equip_name_txt;
	XtManageChildren(children, ac);
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 5); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 5); ac++;
	XtSetValues ( ci_equip_filter_rc,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_filter_equip_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_equip_filter_equip_txt); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNrightOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightWidget, ci_equip_filter_equip_txt); ac++;
	XtSetValues ( ci_equip_filter_equip_lbl,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_filter_status_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_filter_status_txt); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNrightOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightWidget, ci_filter_status_txt); ac++;
	XtSetValues ( ci_equip_filter_status_lbl,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_filter_status_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNleftWidget, ci_filter_status_txt); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_filter_equip_txt,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_filter_radio); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 136); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_filter_status_txt,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_filter_status_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_filter_status_txt); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNleftOffset, -1); ac++;
	XtSetArg(al[ac], XmNleftWidget, ci_filter_status_txt); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_status_btn,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_filter_ckt_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_filter_ckt_txt); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNrightOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightWidget, ci_filter_ckt_txt); ac++;
	XtSetValues ( ci_filter_ckt_lbl,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_filter_equip_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNleftWidget, ci_equip_filter_equip_txt); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_filter_ckt_txt,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_filter_rc); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 96); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_filter_radio,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 10); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_filter_ckt_txt); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNleftOffset, 10); ac++;
	XtSetArg(al[ac], XmNleftWidget, ci_filter_ckt_txt); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_filter_sep1,al, ac );
	ac = 0;
	XtAddCallback (ci_equip_filter_btn, XmNactivateCallback, filter_equipment,NULL);
	XtAddCallback (ci_equip_reset_btn, XmNactivateCallback, reset_filter_equipment,NULL);
	children[ac++] = ci_equip_filter_btn;
	children[ac++] = ci_equip_reset_btn;
	XtManageChildren(children, ac);
	ac = 0;
	XtAddCallback (ci_equip_filter_equip_txt, XmNactivateCallback, filter_equipment,NULL);
	XtAddCallback (ci_equip_status_btn, XmNactivateCallback, emf_display_status_values,NULL);
	children[ac++] = ci_filter_owned_tgl;
	children[ac++] = ci_filter_billed_tgl;
	XtManageChildren(children, ac);
	ac = 0;
	children[ac++] = ci_equip_filter_rc;
	children[ac++] = ci_equip_filter_equip_lbl;
	children[ac++] = ci_equip_filter_status_lbl;
	children[ac++] = ci_equip_filter_equip_txt;
	children[ac++] = ci_filter_status_txt;
	children[ac++] = ci_equip_status_btn;
	children[ac++] = ci_filter_ckt_lbl;
	children[ac++] = ci_filter_ckt_txt;
	children[ac++] = ci_filter_radio;
	children[ac++] = ci_filter_sep1;
	XtManageChildren(children, ac);
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 5); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 5); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_sort_rc_btn,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_by_lbl); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 5); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNleftWidget, ci_equip_sort_by_lbl); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_sort_tgls,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_by_lbl); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 111); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_sort_rev_lbl,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_rev_lbl); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNleftWidget, ci_equip_sort_rev_lbl); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_sort_rev_tgls,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_rev_lbl); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNleftPosition, 44); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_sort_order_lbl,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_order_lbl); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomWidget, ci_equip_sort_rev_tgls); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNleftWidget, ci_equip_sort_order_lbl); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
	XtSetArg(al[ac], XmNrightPosition, 95); ac++;
	XtSetValues ( ci_equip_sort_orderby_txt,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 5); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equip_sort_rc_btn); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 5); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equip_sort_by_lbl,al, ac );
	ac = 0;
	XtAddCallback (ci_equip_sort_btn, XmNactivateCallback, filter_equipment,NULL);
	XtAddCallback (ci_equip_sort_reset_btn, XmNactivateCallback, reset_sort_equipment,NULL);
	children[ac++] = ci_equip_sort_btn;
	children[ac++] = ci_equip_sort_reset_btn;
	XtManageChildren(children, ac);
	ac = 0;
	XtAddCallback (ci_equip_sort_status_tgl, XmNvalueChangedCallback, update_equip_sort_fields,&equip_status_data);
	XtAddCallback (ci_equip_sort_equip_tgl, XmNvalueChangedCallback, update_equip_sort_fields,&equip_subscr_no_data);
	XtAddCallback (ci_equip_sort_date_tgl, XmNvalueChangedCallback, update_equip_sort_fields,&equip_start_date_data);
	children[ac++] = ci_equip_sort_status_tgl;
	children[ac++] = ci_equip_sort_equip_tgl;
	children[ac++] = ci_equip_sort_date_tgl;
	XtManageChildren(children, ac);
	ac = 0;
	XtAddCallback (ci_equip_sort_status_rev_tgl, XmNvalueChangedCallback, update_equip_asc_desc_list,EQUIPMENT_STATUS);
	XtAddCallback (ci_equip_sort_equip_rev_tgl, XmNvalueChangedCallback, update_equip_asc_desc_list,EQUIPMENT_EQUIP_NUM);
	XtAddCallback (ci_equip_sort_date_rev_tgl, XmNvalueChangedCallback, update_equip_asc_desc_list,EQUIPMENT_START_DATE);
	children[ac++] = ci_equip_sort_status_rev_tgl;
	children[ac++] = ci_equip_sort_equip_rev_tgl;
	children[ac++] = ci_equip_sort_date_rev_tgl;
	XtManageChildren(children, ac);
	ac = 0;
	children[ac++] = ci_equip_sort_rc_btn;
	children[ac++] = ci_equip_sort_tgls;
	children[ac++] = ci_equip_sort_rev_lbl;
	children[ac++] = ci_equip_sort_rev_tgls;
	children[ac++] = ci_equip_sort_order_lbl;
	children[ac++] = ci_equip_sort_orderby_txt;
	children[ac++] = ci_equip_sort_by_lbl;
	XtManageChildren(children, ac);
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( equip_emf_lbl,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, equip_emf_lbl); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 0); ac++;
	XtSetValues ( ci_equipslist,al, ac );
	ac = 0;
	XtAddCallback (ci_equiplist, XmNdefaultActionCallback, modify_emf_cb,NULL);
	XtManageChild(ci_equiplist);
	children[ac++] = equip_emf_lbl;
	XtManageChildren(children, ac);
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 40); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
	XtSetValues ( ci_equiplist_rowcol,al, ac );
	ac = 0;

	XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
	XtSetArg(al[ac], XmNtopOffset, 0); ac++;
	XtSetArg(al[ac], XmNtopWidget, ci_equiplist_rowcol); ac++;
	XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
	XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNleftOffset, 0); ac++;
	XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
	XtSetArg(al[ac], XmNrightOffset, 0); ac++;
	XtSetValues ( ci_equip_status_txt,al, ac );
	ac = 0;
	XtAddCallback (ci_equiplist_prov_btn, XmNactivateCallback, add_emf_cb,NULL);
	XtAddCallback (ci_equiplist_modify_btn, XmNactivateCallback, modify_emf_cb,NULL);
	XtAddCallback (ci_equiplist_disc_btn, XmNactivateCallback, disconnect_emf_cb,NULL);
	XtAddCallback (ci_equiplist_contract_btn, XmNactivateCallback, display_equip_contract_cb,NULL);
	XtAddCallback (ci_equiplist_close_btn, XmNactivateCallback, close_equipment_window,NULL);
	XtAddCallback (ci_equiplist_help_btn,XmNactivateCallback, XDhelp_link, (XtPointer) &_xd_help_pairs[0] );
	children[ac++] = ci_equiplist_prov_btn;
	children[ac++] = ci_equiplist_modify_btn;
	children[ac++] = ci_equiplist_disc_btn;
	children[ac++] = ci_equiplist_contract_btn;
	children[ac++] = ci_equiplist_close_btn;
	children[ac++] = ci_equiplist_help_btn;
	XtManageChildren(children, ac);
	ac = 0;
	children[ac++] = ci_equiplist_rowcol;
	children[ac++] = ci_equip_status_txt;
	XtManageChildren(children, ac);
	ac = 0;
	children[ac++] = ci_equip_account_form;
	children[ac++] = ci_equiplist_filter_form;
	children[ac++] = ci_equip_sort_form;
	children[ac++] = ci_subscrlist_form;
	children[ac++] = ci_equiplist_btn_form;
	XtManageChildren(children, ac);
	ac = 0;
	XtManageChild ( ci_equiplist_form);
}
Exemplo n.º 28
0
int MwListBox(Widget pw, char *text, char *choices[], int nchoices)
{
	Widget form, buttonframe,
     		buttonbox, label, viewport, listframe, list,
		okbutton, cancelbutton;
	int n;
	XtAppContext app_context = XtWidgetToApplicationContext(pw);
	Screen *s = XtScreen(pw);
	unsigned long white = WhitePixelOfScreen(s);

	listshell = XtVaCreatePopupShell("lsel_shell",
		transientShellWidgetClass, pw,
		XtNtitle, _("List"),
		XtNwidth, 300,
		XtNheight, 300,
		(char *)0);
	form = XtVaCreateManagedWidget("lsel_form",
		mwRudegridWidgetClass, listshell,
		XtNxLayout, "5 100% 5",
		XtNyLayout, "5 100% 5 35",
		(char *)0);
	buttonframe = XtVaCreateManagedWidget("lsel_buttonframe",
		mwFrameWidgetClass, form,
		XtNgridy, 3,
		XtNgridWidth, 3,
		XtNshadowWidth, 1,
		(char *)0);
	buttonbox = XtVaCreateManagedWidget("lsel_buttonbox",
		boxWidgetClass, buttonframe,
		XtNborderWidth, 0,
		(char *)0);
	listframe = XtVaCreateManagedWidget("lsel_listframe",
		mwFrameWidgetClass, form,
		XtNgridx, 1,
		XtNgridy, 1,
		XtNshadowType, Groove,
		XtNmarginWidth, 2,
		XtNmarginHeight, 2,
		XtNallowResize, False,
		(char *)0);
	label = XtVaCreateManagedWidget("lsel_label",
		labelWidgetClass, listframe,
		(char *)0);
	MwLabelSet(label, text);
	XtVaSetValues(listframe,
		XtNtitle, label,
		(char *)0);
	viewport = XtVaCreateManagedWidget("lsel_viewport",
		viewportWidgetClass, listframe,
		XtNforceBars, True,
		XtNborderWidth, 0,
		(char *)0);
	list = XtVaCreateManagedWidget("lsel_list",
		listWidgetClass, viewport,
		XtNbackground, white,
		(char *)0);
	XawListChange(list, choices, nchoices, 0, True);
	XtVaSetValues(list, XtNwidth, MwWidthGet(list)+20, (char *)0);
	okbutton = add_button(buttonbox, "lsel_okbutton",
		"OK", listsel_clicked, (XtPointer)1);
	cancelbutton = add_button(buttonbox, "lsel_cancelbutton",
		"Cancel", listsel_clicked, (XtPointer)0);
	status = MW_WAITING;
	MwCenter(listshell);
	XtPopup(listshell, XtGrabNonexclusive);
	XawListChange(list, choices, nchoices, 0, True);
	wm_del(listshell);

	while (status == MW_WAITING) {
		XEvent event_return;
		XtAppNextEvent(app_context, &event_return);
		XtDispatchEvent(&event_return);
	}
	n = XawListShowCurrent(list)->list_index;
	XtDestroyWidget(listshell);
	if (status != MW_ABORT)	/* clicked OK */
		return n;
	else		/* clicked Cancel */
		return -1;
}
Exemplo n.º 29
0
/*ARGSUSED*/
static Boolean
WMiConvert (
     Widget         w,
     Atom           selection,
     Atom           target,
     XtPointer      input,
     unsigned long  inputLen,
     int            inputFmt,
     Atom          *outputType,
     XtPointer     *output,
     unsigned long *outputLen,
     int           *outputFmt)
{
  int      scr;
  Boolean  found = False;

  
  /* set up some defaults. selection code doesn't like garbage! */
  *outputLen = 0;
  *output    = NULL;
  *outputFmt = 8;

  scr = XScreenNumberOfScreen(XtScreen(w));
  if (!wmGD.Screens[scr].managed)
    {
      Warning (((char *)GETMESSAGE(56, 7,
		"Got convert request from unmanaged screen")));
      found = False;
    }
  
  else {
    if (target == wmGD.xa_TARGETS) {
      Atom *targs       = (Atom *)XtMalloc((unsigned) (28 * sizeof(Atom)));
      int   targetCount = 0;
      
      *output = (XtPointer) targs;
      
      /* required targets */
      *targs++ = wmGD.xa_TARGETS;				targetCount++;
      *targs++ = wmGD.xa_MULTIPLE;				targetCount++;
      *targs++ = wmGD.xa_TIMESTAMP;				targetCount++;

#ifdef MWM_WSM
      /* other targets */
      *targs++ = _WSMReqTypeToTarget(DISPLAY, WSM_CONNECT);	targetCount++;
      *targs++ = _WSMReqTypeToTarget(DISPLAY, WSM_EXTENSIONS);	targetCount++;
      *targs++ = _WSMReqTypeToTarget(DISPLAY, WSM_CONFIG_FMT);	targetCount++;
      *targs++ = _WSMReqTypeToTarget(DISPLAY, WSM_GET_STATE);	targetCount++;
      *targs++ = _WSMReqTypeToTarget(DISPLAY, WSM_SET_STATE);	targetCount++;
      *targs++ = _WSMReqTypeToTarget(DISPLAY, WSM_REG_WINDOW);	targetCount++;
#endif
      
      /* menu command interface support */
      *targs++ = wmGD._MOTIF_WM_DEFINE_COMMAND;			targetCount++;
      *targs++ = wmGD._MOTIF_WM_INCLUDE_COMMAND;		targetCount++;
      *targs++ = wmGD._MOTIF_WM_REMOVE_COMMAND;			targetCount++;
      *targs++ = wmGD._MOTIF_WM_ENABLE_COMMAND;			targetCount++;
      *targs++ = wmGD._MOTIF_WM_DISABLE_COMMAND;		targetCount++;
      *targs++ = wmGD._MOTIF_WM_RENAME_COMMAND;			targetCount++;
      *targs++ = wmGD._MOTIF_WM_INVOKE_COMMAND;			targetCount++;
      *targs++ = wmGD._MOTIF_WM_REQUEST_COMMAND;		targetCount++;
      *targs++ = wmGD._MOTIF_WM_WINDOW_FLAGS;			targetCount++;

#ifdef MWM_WSM
      /* virtual screen support */
      *targs++ = wmGD._MOTIF_WM_PAN;				targetCount++;
      *targs++ = wmGD._MOTIF_WM_GOTO;				targetCount++;
#endif

      /* automation support */

      *targs++ = wmGD._MOTIF_WM_AUTOMATION;			 targetCount++;
      
      *outputType   = XA_ATOM;
      *outputLen = (targetCount * sizeof(Atom)) >> 2;
      *outputFmt = 32;
      
      found = True;
    }

#ifdef MWM_WSM    
    /* virtual screen support */
    else if (target == wmGD._MOTIF_WM_PAN)
Exemplo n.º 30
0
/************************************************************************
 *
 *  XmIsMotifWMRunning
 *
 ************************************************************************/
Boolean 
XmIsMotifWMRunning(
	 Widget shell )
{
    Atom	motif_wm_info_atom;
    Atom	actual_type;
    int		actual_format;
    unsigned long num_items, bytes_after;
    PropMotifWmInfo	*prop = 0;
    Window	root = RootWindowOfScreen(XtScreen(shell));

    _XmWidgetToAppContext(shell);
 
    _XmAppLock(app);

    motif_wm_info_atom = XInternAtom(XtDisplay(shell),
				       _XA_MOTIF_WM_INFO,
				       FALSE);
    _XmProcessLock();

    XGetWindowProperty (XtDisplay(shell), 
			 root,
			 motif_wm_info_atom,
			 0, (long)PROP_MOTIF_WM_INFO_ELEMENTS,
			 FALSE, motif_wm_info_atom,
			 &actual_type, &actual_format,
			 &num_items, &bytes_after,
			 (unsigned char **) &prop);
    _XmProcessUnlock();

    if ((actual_type != motif_wm_info_atom) ||
	 (actual_format != 32) ||
	 (num_items < PROP_MOTIF_WM_INFO_ELEMENTS))
      {
	   if (prop != 0) XFree((char *)prop);
           _XmAppUnlock(app);
	   return (FALSE);
      }
    else
      {
	   Window	wm_window = (Window) prop->wmWindow;
	   Window	top, parent, *children;
	   unsigned int	num_children;
	   Boolean	returnVal;
	   Cardinal	i;

	   if (XQueryTree(XtDisplay(shell),
			  root, &top, &parent,
			  &children, &num_children))
	     {
		 i = 0; 
		 while ((i < num_children) && (children[i] != wm_window))
		   i++;
		 returnVal =  (i == num_children) ? FALSE : TRUE;
	     }
	   else
	     returnVal = FALSE;

	   if (prop) XFree((char *)prop);
	   if (children) XFree((char *)children);
           _XmAppUnlock(app);
	   return (returnVal);
      }
}