⟦b4969626d⟧

TextFile

/*
 *	sccsid:	@(#)Intrinsic.h	1.16	6/8/87
 */

/*
 * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its 
 * documentation for any purpose and without fee is hereby granted, 
 * provided that the above copyright notice appear in all copies and that
 * both that copyright notice and this permission notice appear in 
 * supporting documentation, and that the name of Digital Equipment
 * Corporation not be used in advertising or publicity pertaining to
 * distribution of the software without specific, written prior permission.  
 * 
 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

#ifndef _Intrinsic_h
#define _Intrinsic_h

/****************************************************************
 ****************************************************************
 ***                                                          ***
 ***                                                          ***
 ***                   X Toolkit Intrinsics                   ***
 ***                                                          ***
 ***                                                          ***
 ****************************************************************
 ****************************************************************/


/****************************************************************
 *
 * System Dependent Definitions
 *
 *
 * The typedef for XtArgVal should be chosen such that
 *      sizeof (XtArgVal) == max (sizeof(caddr_t), sizeof(long))
 *
 * ArgLists rely heavily on the above typedef.
 *
 ****************************************************************/

typedef char *XtArgVal;



/****************************************************************
 *
 * Miscellaneous definitions
 *
 ****************************************************************/

#ifndef	makedev
#include	<sys/types.h>
#endif

#ifndef NULL
#define NULL 0
#endif

#define Boolean int
#ifndef FALSE
#define FALSE 0
#define TRUE  1
#endif

#define XtNumber(arr)			(sizeof(arr) / sizeof(arr[0]))


/****************************************************************
 *
 * Error codes
 *
 ****************************************************************/

typedef	int XtStatus;

#define XtSUCCESS 0	/* No error. */

extern int (*XtErrorFunction)();
extern int XtreferenceCount;

/* Associative lookup table error codes */

#define XtNOMEM   1    /* Out of memory */
#define XtNOENT   2    /* No entry in table */
#define XtFOPEN   3    /* fopen failed. */

/* Other errors. */

#define XtNOTWINDOW 3	/* Given window id is invalid. */


/****************************************************************
 *
 * Toolkit initialization
 *
 ****************************************************************/

extern void    XtInitialize();
extern Display *XtCurDisplay;
extern int     XtCurScreen;

/****************************************************************
 *
 * Memory Allocation
 *
 ****************************************************************/

#ifndef _Alloc_c_

extern char *XtMalloc(); /* size */
    /* unsigned size; */

extern char *XtCalloc(); /* num, size */
    /* unsigned num, size; */

extern char *XtRealloc(); /* ptr, num */
    /* char     *ptr; */
    /* unsigned num; */

extern void free();

#define XtFree(ptr)	    if ((ptr) != NULL) free(ptr);


#endif




/****************************************************************
 *
 * Quark Management
 *
 ****************************************************************/

typedef int     XtQuark, *XtQuarkList;
#define NULLQUARK ((XtQuark) 0)

typedef char *XtAtom;
#define NULLATOM ((XtAtom) 0)

/* find quark for atom, create new quark if none already exists */
extern XtQuark XtAtomToQuark(); /* name */
    /* XtAtom name; */

/* find atom for quark */
extern XtAtom XtQuarkToAtom(); /* quark */
    /* XtQuark name; */

extern XtQuark XtUniqueQuark();

#define XtAtomsEqual(a1, a2) (a1 && a2 && (strcmp(a1, a2) == 0))



/****************************************************************
 *
 * Quark Lists
 *
 ****************************************************************/

extern void XtStringToQuarkList(); /* name, quarks */
    /* char	    *name;  */
    /* XtQuarkList  quarks; */

extern XtQuarkList XtNewQuarkList();

#define XtFreeQuarkList(list)   XtFree((char *) list)

extern int XtQuarkListLength(); /* list */
    /* XtQuarkList list   */

extern XtQuarkList XtCopyQuarkList(); /* list */
    /* XtQuarkList	list; */


/****************************************************************
 *
 * Arg lists
 *
 ****************************************************************/

typedef struct {
    XtAtom	name;
    XtArgVal	value;
} Arg, *ArgList;

#define XtSetArg(arg, n, d) \
    ( (arg).name = (n), (arg).value = (XtArgVal)(d) )

extern ArgList XtMergeArgLists(); /* args1, argCount1, args2, argCount2 */
    /* ArgList args1;       */
    /* int     argCount1;   */
    /* ArgList args2;       */
    /* int     argCount2;   */


/****************************************************************
 *
 * Context Management
 *
 ****************************************************************/

typedef XtQuark XtContext;

#define XtUniqueContext()       ((XtContext) XtUniqueQuark())
#define XtAtomToContext(atom)   ((XtContext) XtAtomToQuark(atom))

extern XtStatus XtSaveContext(); /* window, context, data */
    /* Window       window;		*/
    /* XtContext    context;		*/
    /* caddr_t      data;		*/

extern XtStatus XtFindContext(); /* window, context, data */
    /* Window       window;		*/
    /* XtContext    context;		*/
    /* caddr_t      *data;    /* RETURN */

extern XtStatus XtDeleteContext(); /* window, context */
    /* Window       window;		*/
    /* XtContext    context;		*/




/****************************************************************
 *
 * Cursor Management
 *
 ****************************************************************/

extern Cursor XtGetCursor(); /* num */
    /* int num; */


/****************************************************************
 *
 * Event Management
 *
 ****************************************************************/

#define ResizeWindow 0x0081 /* Faked XEvent code for windows changing s!
ize */
#define DestroyWindow 0x0083 /* Faked XEvent code for destroying a wind!
ow */


typedef enum {
    XteventHandled,	/* Event dispatched and handled */
    XteventNotHandled,	/* Event dispatched but not handled by event proc */
    XteventNoHandler,	/* No event handler proc found */
    XteventError	/* Error in event handling */
} XtEventReturnCode;

#define XtINPUT_READ	(1)
#define XtINPUT_WRITE	(2)
#define XtINPUT_EXCEPT	(4)

typedef XtEventReturnCode (*XtEventHandler)(); /* event, data */
    /* XEvent  *event;  */
    /* caddr_t data;    */

extern void XtSetEventHandler(); /* w, proc, eventMask, data */
    /* Window		w;	    */
    /* XtEventHandler   proc;       */
    /* unsigned long    eventMask;  */
    /* caddr_t		data;       */

extern void XtSetNotify(); /* proc, mask, data */
    /* XtEventHandler	proc;       */
    /* unsigned long	mask;       */
    /* caddr_t		data;       */

extern void XtDeleteNotify(); /* proc */
    /* XtEventHandler	proc;       */

extern void XtDeleteEventHandler(); /* w, proc */
    /* Window         w;       */
    /* XtEventHandler proc;    */

extern void XtClearEventHandlers(); /* window */
    /* Window window; */

extern XtEventReturnCode XtDispatchEvent(); /* event */
    /* XEvent	*event; */

extern void XtDisableAutoGrab(); /* w */
    /* Window w; */

extern void XtEnableAutoGrab(); /* w */
    /* Window w; */

extern void XtGrabMouse(); /* w, cursor, mask */
    /* Window w; */
    /* Cursor cursor; */
    /* unsigned long mask; */

extern void XtUngrabMouse();


/****************************************************************
 *
 * Geometry Management
 *
 ****************************************************************/

#define geometryMOVE		0x1	/* Move window to wb.x, wb.y */
#define geometryRESIZE		0x2	/* Resize to wb.width, wb.height */
#define geometryTOP		0x4	/* Move window to top of stack */
#define geometryBOTTOM		0x8	/* Move window to bottom of stack */
#define geometryGETWINDOWBOX	0x10	/* Return window pos., dimensions */

typedef struct {
    int x, y, width, height, borderWidth;
} WindowBox, *WindowBoxPtr;

typedef enum  {
    XtgeometryYes,        /* Request accepted. */
    XtgeometryNo,         /* Request denied. */
    XtgeometryAlmost,     /* Request denied, but willing to take replyBox. */
    XtgeometryNoManager   /* Request denied: couldn't find geometry manager */
} XtGeometryReturnCode;

typedef XtGeometryReturnCode (*XtGeometryHandler)();
    /* w, request, requestBox, replyBox */
    /* Window		    w;			    */
    /* XtGeometryRequest    request;		    */
    /* WindowBox	    *requestBox;	    */
    /* WindowBox	    *replyBox;    /* RETURN */

extern XtStatus XtSetGeometryHandler();  /* w, proc */
    /* Window		 w;     */
    /* XtGeometryHandler proc;  */

extern XtStatus XtGetGeometryHandler(); /* w, proc */
    /* Window		 w;		    */
    /* XtGeometryHandler *proc;   /* RETURN */

extern XtStatus XtClearGeometryHandler();  /* w */
    /* Window w; */

extern XtGeometryReturnCode XtMakeGeometryRequest();
    /* window, request, requestBox, replyBox */
    /* Window		 window;		*/
    /* XtGeometryRequest request;		*/
    /* WindowBox	 *requestBox;		*/
    /* WindowBox	 *replyBox;   /* RETURN */

typedef struct {
    Window      w;
    WindowBox   wb;
} WindowLug, *WindowLugPtr;


/****************************************************************
 *
 * Resources
 *
 ****************************************************************/

typedef struct _Resource {
    XtAtom		name;		/* Resource name		    */
    XtAtom		class;		/* Resource class		    */
    XtAtom		type;		/* Representation type desired      */
    unsigned int	size;		/* Size in bytes of representation  */
    caddr_t		addr;		/* Where to put resource value      */
    caddr_t		defaultaddr;    /* Default resource value (or addr) */
} Resource, *ResourceList;

/* ||| Should be opaque types */
/* ||| Free of lists should probably be done by SetNameAndClass */

typedef XtQuark     XtName;
typedef XtQuarkList XtNameList;
#define XtNameToAtom(name)		(XtQuarkToAtom((XtQuark) (name)))
#define XtNameListLength(names) 	(XtQuarkListLength((XtQuarkList)names))
#define XtFreeNameList(name)		XtFreeQuarkList((XtQuark) (name))

typedef XtQuark     XtClass;
typedef XtQuarkList XtClassList;
#define XtFreeClassList(class)		XtFreeQuarkList((XtQuark) (class))

extern void XtGetResources();
    /* resources, resourceCount, args, argCount,
       parent, widgetName, widgetClass, names, classes */
    /* ResourceList resources;		*/
    /* int	    resourceCount;      */
    /* ArgList	    args;		*/
    /* int	    argCount;		*/
    /* Window	    parent;		*/
    /* XtAtom	    widgetName;		*/
    /* XtAtom	    widgetClass;	*/
    /* XtNameList   *names;   /* RETURN */
    /* XtClassList  *classes; /* RETURN */

extern void XtSetNameAndClass(); /* w, names, classes */
    /* Window       w;			*/
    /* XtNameList   names;		*/
    /* XtClassList  classes;		*/

extern void XtGetValues(); /* resources, resourceCount, args, argCount */
    /* ResourceList	resources;      */
    /* int		resourceCount;  */
    /* ArgList		args;		*/
    /* int		argCount;       */

extern void XtSetValues(); /* resources, resourceCount, args, argCount */
    /* ResourceList	resources;      */
    /* int		resourceCount;  */
    /* ArgList		args;		*/
    /* int		argCount;       */

extern int XtDefaultFGPixel, XtDefaultBGPixel;
extern Pixmap XtDefaultFGPixmap, XtDefaultBGPixmap;


/****************************************************************
 *
 * Resource Types and Conversions
 *
 ****************************************************************/

typedef struct {
    unsigned int	size;
    caddr_t		addr;
} XrmValue, *XrmValuePtr;

typedef	void (*XtTypeConverter)(); /* from, to */
    /* XrmValue    from; */
    /* XrmValue    *to; */

extern void XtRegisterTypeConverter(); /*fromType, toType, converter*/
    /* XtAtom		fromType, toType; */
    /* XtTypeConverter  converter; */

extern void XtConvert(); /* fromType, from, toType, to*/
    /* XtAtom       fromType		*/
    /* XrmValue     from;		*/
    /* XtAtom       toType;		*/
    /* XrmValue     *to;      /* RETURN */

/****************************************************************
 *
 * Resource Database Management
 *
 ****************************************************************/

typedef struct		_ResourceDataBase *ResourceDataBase;
typedef int		unspecified;

extern void XtSetCurrentDataBase(); /* db */
    /* ResourceDataBase db; */

extern void XtGetCurrentDataBase(); /* db */
    /* ResourceDataBase *db;    /* RETURN */

extern void XtFreeDataBase (); /* db */
    /* ResourceDataBase db; */

extern void XtGetDataBase(); /* magicCookie, db*/
    /* unspecified      magicCookie; /*  *FILE, actually */
    /* ResourceDataBase *db;	     /*  RETURN		 */

extern void XtPutDataBase(); /* magicCookie, db */
    /* unspecified magicCookie;     /*  *FILE, actually */
    /* ResourceDataBase db;				*/

extern void XtEnumDataBase(); /* tag, proc, db */
    /* caddr_t tag;	    */
    /* DBEnumProc proc;	    */
    /* ResourceDataBase db; */

extern void XtMergeDataBases(); /* new, into */
    /* ResourceDataBase new;		    */
    /* ResourceDataBase *into;    /* RETURN */




/****************************************************************
 *
 * Command line option mapping to resource entries
 *
 ****************************************************************/

typedef enum {
    XtoptionNoArg,      /* Value is specified in OptionDescRec.value	    */
    XtoptionIsArg,      /* Value is the option string itself		    */
    XtoptionStickyArg,  /* Value is characters immediately following option   */
    XtoptionSepArg,     /* Value is next argument in argv			    */
    XtoptionSkipArg,    /* Ignore this option and the next argument in argv   */
    XtoptionSkipLine    /* Ignore this option and the rest of argv	    */
} XtOptionKind;

typedef struct {
    char	*option;	/* Option abbreviation in argv		    */
    char	*resourceName;  /* Resource name (sans application name)    */
    XtOptionKind  argKind;	/* Which style of option it is		    */
    caddr_t     value;		/* Value to provide if optionSTICKYARG	    */
} OptionDescRec, *OptionDescList;

extern void XtParseCommand(); /* table, prependName, argc, argv */
    /* OptionDescList   table;						    */
    /* int		tableCount;					    */
    /* XtAtom		prependName; (NULLATOM means don't prepend)	    */
    /* int		*argc;						    */
    /* char		**argv;						    */



/****************************************************************
 *
 * Translation Management
 *
 ****************************************************************/

typedef caddr_t XtEventsPtr;

typedef struct {
    char    *string;
    caddr_t value;
} XtActionsRec, *XtActionsPtr;

/* Different classes of action tokens */

typedef enum {XttokenChar, XttokenString, XttokenAction} XtTokenType;

/* List of tokens. */

typedef XtQuark XtAction;
#define XtAtomToAction(atom)    ((XtAction) XtAtomToQuark(atom))

typedef struct _XtActionTokenRec {
    XtTokenType type;
    union {
	char     c;
	char     *str;
	XtAction action;
    } value;
    struct _XtActionTokenRec *next;
} XtActionTokenRec, *XtActionTokenPtr;

extern caddr_t XtSetActionBindings();
			/* eventTable, actionTable, defaultValue */
    /*  XtEventsPtr  eventTable;    */
    /*  XtActionsPtr actionTable;   */
    /*  caddr_t      defaultValue;  */

extern XtEventsPtr XtParseEventBindings(); /* stringTable */
    /* char **stringTable */

extern void XtMergeEventBindings(); /* eventTable, string Table */
    /* XtEventsPtr eventTable */
    /* char **stringTable */

extern caddr_t XtInterpretAction(); /* state, action */
    /* TranslationPtr start;    */
    /* XtAction       action;   */

XtActionTokenPtr XtTranslateEvent(); /* event, state */
    /* XEvent         *event;   */
    /* TranslationPtr state;    */

#endif _Intrinsic_h
/* DON'T ADD STUFF AFTER THIS #endif */
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦b4969626d⟧ TextFile

Derivation

TextFile
