#ifndef _XtIntrinsic_h
#define _XtIntrinsic_h

/*****************************************************************
 *
 * Includes that we depend on
 *
 ****************************************************************/

#ifndef VMS
#include	<X++/Xlib.h>
#include	<X++/Xutil.h>
#include	<X++/Xresource.h>
#include	<sys/types.h>
#include	<string.h>
#else
#include	<decw$include/Xlib.h>
#include	<decw$include/Xutil.h>
#include	<decw$include/Xresource.h>
#include	<types.h>
#include	<string.h>
#endif

/*****************************************************************
 *
 * defines
 *
 ****************************************************************/

#ifndef MIN

/* MIN and MAX get defined vis <sys/types.h> on Unix, this is for VMS */

#define	MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))

#endif

#ifndef NULL
#define NULL 0
#endif

#ifdef unix
#define externalref extern
#define externaldef(psect)
#else
#define externalref globalref
#define externaldef(psect) globaldef {"psect"} noshare
#endif

#ifndef BOOLEANTYPE
#ifndef FALSE
#define FALSE 0
#define TRUE  1
#endif FALSE
#endif BOOLEANTYPE

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

/*****************************************************************
 *
 * Forward type definitions
 *
 ****************************************************************/

class Arg;
class CompositeRec;
class ObjectRec;
class RectObjRec;
class WidgetClassRec;
class WidgetRec;
class WindowObjClassRec;
class WindowObjRec;
class XrmResource;
class XtActionsRec;
class XtAppStruct;
class XtBoundAccActionRec;
class XtCallbackRec;
class XtEventRec;
class XtPopdownIDRec;
class XtResource;
class XtWidgetGeometry;
class vms_time;

enum XtGeometryResult {
    XtGeometryYes,        /* Request accepted. */
    XtGeometryNo,         /* Request denied. */
    XtGeometryAlmost,     /* Request denied, but willing to take replyBox. */
    XtGeometryDone,       /* Request accepted and done. */
};

enum XtCallbackStatus {
        XtCallbackNoList,
        XtCallbackHasNone,
        XtCallbackHasSome
};

enum XtGrabKind {XtGrabNone, XtGrabNonexclusive, XtGrabExclusive};

typedef Arg*		ArgList;
typedef char		Boolean;
typedef unsigned int	Cardinal;
typedef CompositeRec*	CompositeWidget;
typedef unsigned short	ShortCard;
typedef ShortCard	Dimension;  /* Size in pixels		        */
typedef ObjectRec*	Object;
typedef unsigned long*	Opaque;
typedef unsigned long	Pixel;	    /* Index into colormap	        */
typedef short		Position;   /* Offset from 0 coordinate	        */
typedef RectObjRec*	RectObj;
typedef char*		String;
typedef WidgetRec*	Widget;
typedef WidgetClassRec*	WidgetClass;
typedef Widget*		WidgetList;
typedef WindowObjRec*	WindowObj;
typedef WindowObjClassRec*	WindowObjClass;
typedef XrmResource*	XrmResourceList;
typedef Boolean		(*XtAcceptFocusProc)(Widget, Time* /* X time */);
typedef XtActionsRec*	XtActionList;
typedef void		(*XtAlmostProc)(Widget, Widget, XtWidgetGeometry*, XtWidgetGeometry*);
typedef XtAppStruct*	XtAppContext;
typedef long		XtArgVal;
typedef Boolean		(*XtArgsFunc)(Widget, ArgList, Cardinal*);
typedef void		(*XtArgsProc)(Widget, ArgList, Cardinal*);
typedef XtBoundAccActionRec*	XtBoundAccActions;
typedef XtCallbackRec*	XtCallbackList;
typedef void		(*XtCallbackProc)(Widget, caddr_t, caddr_t);
typedef void		(*XtCreatePopupChildProc)();
typedef void		(*XtErrorHandler)(String);
typedef void		(*XtErrorMsgHandler)(String, String, String, String, String*, Cardinal*);
typedef XtEventRec*	XtEventTable;
typedef void		(*XtExposeProc)(Widget, XEvent*, Region);
typedef unsigned long	XtGCMask;   /* Mask of values that are used by widget*/
typedef XtGeometryResult	(*XtGeometryHandler)(Widget, XtWidgetGeometry*, XtWidgetGeometry*);
typedef unsigned int	XtGeometryMask;
typedef void		(*XtInitProc)(Widget, Widget);
typedef unsigned long	XtInputId;
typedef unsigned long	XtIntervalId;
typedef XtPopdownIDRec*	XtPopdownID;
typedef void		(*XtProc)();
typedef unsigned long	XtValueMask;
typedef void		(*XtRealizeProc) (Widget, XtValueMask, XSetWindowAttributes*);
typedef XtResource*	XtResourceList;
typedef Boolean		(*XtSetValuesFunc)(Widget, Widget, Widget);
typedef void		(*XtStringProc)(Widget, String);
typedef unsigned long	XtVersionType;
typedef void		(*XtWidgetClassProc)(WidgetClass);
typedef void		(*XtWidgetProc)(Widget);
typedef Boolean		(*XtWorkProc)(Opaque);
typedef unsigned long	XtWorkProcId;

/****************************************************************
 *
 * System Dependent Definitions
 *
 *
 * XtArgVal ought to be a union of caddr_t, char *, long, int *, and proc *
 * but casting to union types is not really supported.
 *
 *
 *      sizeof (XtArgVal) >=	sizeof(caddr_t)
 *				sizeof(char *)
 *				sizeof(long)
 *				sizeof(int *)
 *				sizeof(proc *)
 *
 *
 ****************************************************************/

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

class Arg {
    String	name;
    XtArgVal	value;

public:
    void Set(String n, XtArgVal d) {name = n; value = d; }
    String Name() { return name; };
    XtArgVal Value() { return value; };
};

inline void XtSetArg(Arg arg, String n, XtArgVal d) { arg.Set(n,d); }

class ArgsRec {
    ArgList args;
    Cardinal maxArgs;
    Cardinal numArgs;

public:

    ArgsRec(Cardinal c = 10) { args = new Arg[maxArgs = c]; numArgs = 0; }
    ~ArgsRec() { delete args; maxArgs = numArgs = 0; }

    void Clear() { numArgs = 0; }
    void Add(String name, XtArgVal value) {
	if (numArgs == maxArgs) {
	    ArgList newargs = new Arg[maxArgs *= 2];
	    for (int i=0 ; i<numArgs ; i++)
		newargs[i] = args[i];
	    delete args;
	    args = newargs;
	}
	args[numArgs++].Set(name, value);
    }

    Arg operator [](int i) { return args[i]; }
/* Mike Chow wanted this routine, unfortunately CFRONT won't let you
return from inlines, so I've commented it out.
    void ChangeArg(String n, XtArgVal d)
	{
	    for (int i=0; i<numArgs; i++) 
		if (strcmp(args[i].Name(), n) == 0) {
		    args[i].Set(args[i].Name(), d);
		    return;
		}
	}
*/
    ArgList GetArgs() { return args; }
    Cardinal GetCount() { return numArgs; }
};
typedef ArgsRec *Args;

#ifdef VMS
class vms_time {
     unsigned long low;
     unsigned long high;
};
#endif

#define XT_VERSION 7
#define XT_REVISION 1
#define XtVersion (XT_VERSION * 1000 + XT_REVISION)
#define XtVersionDontCheck 0

#ifndef R3_INTRINSICS

#define XtMapWidget(w) XMapWindow(XtDisplay(w), XtWindow(w))
#define XtUnmapWidget(w) XUnmapWindow(XtDisplay(w), XtWindow(w))

#endif R3_INTRINSICS

inline void  XtCheckSubclass(
    Widget w, WidgetClass widget_class_ptr, String message) {
#ifdef DEBUG
	if (!XtIsSubclass((w), (widget_class_ptr))) {
	    String params[3];
	    Cardinal num_params = 3;
	    params[0] = (w)->core.widget_class->core_class.class_name;
	    params[1] = (widget_class_ptr)->core_class.class_name;
	    params[2] = (message);
	    XtErrorMsg("subclassMismatch", "xtCheckSubclass",
		    "XtToolkitError",
		    "Widget class %s found when subclass of %s expected: %s",
		    params, &num_params);
	}
#else
	/* do nothing */
#endif
    };

#define XtIsComposite(widget)       XtIsSubclass(widget, (WidgetClass) compositeWidgetClass)
#define XtIsCompositeObject(widget) XtIsSubclass(widget, (WidgetClass) compositeObjectClass)
#define XtIsWindowObject(widget)    XtIsSubclass(widget, (WidgetClass) windowObjClass)
#define XtIsRectObject(widget)      XtIsSubclass(widget, (WidgetClass) rectObjClass)
#define XtIsConstraint(widget)      XtIsSubclass(widget, (WidgetClass) constraintWidgetClass)
#define XtIsShell(widget)	    XtIsSubclass(widget, (WidgetClass) shellWidgetClass)

/*************************************************************
 *
 * Information routines
 *
 ************************************************************/

class XtCallbackRec {
    XtCallbackProc  callback;
    caddr_t         closure;
};

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

/* Additions to Xlib geometry requests: ask what would happen, don't do it */
#define XtCWQueryOnly   (1 << 7)

/* Additions to Xlib stack modes: don't change stack order */
#define XtSMDontChange  5

class XtWidgetGeometry {
    XtGeometryMask request_mode;
    Position x, y;
    Dimension width, height, border_width;
    Widget sibling;
    int stack_mode;    /* Above, Below, TopIf, BottomIf, Opposite, DontChange */
};

/* Class record constants */

class XtPopdownIDRec {
    Widget  shell_widget;
    Widget  enable_widget;
};

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

class XrmResource {
    XrmQuark	xrm_name;	  /* Resource name quark 		*/
    XrmQuark	xrm_class;	  /* Resource class quark 		*/
    XrmQuark	xrm_type;	  /* Resource representation type quark */
    Cardinal	xrm_size;	  /* Size in bytes of representation	*/
    long int	xrm_offset;	  /* -offset-1				*/
    XrmQuark	xrm_default_type; /* Default representation type quark 	*/
    caddr_t	xrm_default_addr; /* Default resource address		*/
};

class XtResource {
  public:
    String     resource_name;   /* Resource name                            */
    String     resource_class;  /* Resource class                           */
    String     resource_type;   /* Representation type desired              */
    Cardinal    resource_size;  /* Size in bytes of representation          */
    Cardinal    resource_offset;/* Offset from base to put resource value   */
    String     default_type;    /* representation type of specified default */
    caddr_t     default_addr;   /* Address of default resource              */
};

/*
 * If we're going to go sticking proc *'s into default_addr, we should use a
 * different type for the field. Possibly XtArgVal?
 */

#define XtOffset(type,field)    ((unsigned int)&(((type)NULL)->field))

#define XtNew(type) ((type *) XtMalloc((unsigned) sizeof(type)))
#define XtNewString(str) (strcpy(XtMalloc((unsigned) strlen(str) + 1), str))

/*****************************************************************
 *
 * External function definitions
 *
 *****************************************************************/

extern void XrmCompileResourceList(XtResourceList, Cardinal);
extern void XtAddCallback(Widget, String, XtCallbackProc, caddr_t);
extern void XtAddCallbacks(Widget, String, XtCallbackList);
extern XtWorkProcId XtAddWorkProc();
extern XtWorkProcId XtAppAddWorkProc(XtAppContext, XtWorkProc, Opaque);
extern Widget XtAppCreateShell(String, String, WidgetClass, Display*, ArgList, Cardinal);
extern void XtCallCallbacks(Widget, String, caddr_t);
extern void XtCallbackExclusive(Widget, caddr_t, caddr_t);
extern void XtCallbackNone(Widget, caddr_t, caddr_t);
extern void XtCallbackNonexclusive(Widget, caddr_t, caddr_t);
extern void XtCallbackPopdown(Widget, caddr_t, caddr_t);
extern char* XtCalloc(Cardinal, Cardinal);
extern void XtCloseDisplay(Display *);
extern void XtConfigureWidget(Widget, Position, Position, Dimension, Dimension, Dimension, Dimension);
extern void XtCopyAncestorSensitive();
extern void XtCopyDefaultColormap();
extern void XtCopyDefaultDepth();
extern void XtCopyFromParent();
extern void XtCopyScreen();
extern XtAppContext XtCreateApplicationContext();
extern Widget XtCreateApplicationShell();
extern Widget XtCreateManagedWidget(String, WidgetClass, Widget, ArgList, Cardinal);
extern Widget XtCreatePopupShell(String, WidgetClass, Widget, ArgList, Cardinal);
extern Widget XtCreateWidget(String, WidgetClass, Widget, ArgList, Cardinal);
extern void XtCreateWindow(Widget, unsigned int, Visual *, Mask , XSetWindowAttributes *);
extern XrmDatabase XtDatabase(Display*);
extern void XtDestroyApplicationContext(XtAppContext);
extern void XtDestroyGC(Widget, GC);
extern void XtDestroyWidget(Widget);
extern void XtDisplayInitialize(XtAppContext, Display*, String, String, XrmOptionDescRec *, Cardinal, Cardinal*, char**);
extern void XtError(String);
extern void XtErrorMsg(String, String, String, String, String*, Cardinal*);
extern void XtFree(char *);
extern XrmDatabase XtGetErrorDatabase();
extern void XtGetErrorDatabaseText(char*, char*, char*, char*, char*, int);
extern GC XtGetGC(Widget, XtGCMask, XGCValues*);
extern void XtGetSubresources(Widget, caddr_t, String, String, XtResourceList, Cardinal, ArgList, Cardinal);
extern void XtGetSubvalues(caddr_t, XtResourceList, Cardinal, ArgList, Cardinal);
extern void XtGetValues(Widget, ArgList, Cardinal);
extern XtCallbackStatus XtHasCallbacks(Widget, String);
extern Widget XtInitialize(String, String, XrmOptionDescRec*, Cardinal, Cardinal*, char**);
extern Boolean XtIsSubclass(Widget, WindowObjClass);
extern XtGeometryResult XtMakeGeometryRequest(Widget, XtWidgetGeometry*, XtWidgetGeometry*);
extern XtGeometryResult XtMakeResizeRequest(Widget, Dimension, Dimension, Dimension*, Dimension*);
extern char* XtMalloc(Cardinal);
extern void XtManageChild (Widget);
extern void XtManageChildren (WidgetList, Cardinal);
extern ArgList XtMergeArgLists(ArgList, Cardinal, ArgList, Cardinal);
extern void XtMoveWidget(Widget, Position, Position);
extern Widget XtNameToWidget(Widget, String);
extern Display* XtOpenDisplay(XtAppContext, String, String, String, XrmOptionDescRec *, Cardinal, Cardinal *, char *[]);
extern void XtOverrideCallback(); /* widget, callcallback */
extern void XtPopdown(Widget);
extern void XtPopup(Widget, XtGrabKind);
extern XtGeometryResult XtQueryGeometry(Widget, XtWidgetGeometry*, XtWidgetGeometry*);
extern void XtReadBinaryDatabase();
extern void XtRealizeWidget(Widget);
extern char* XtRealloc(char*, Cardinal);
extern void XtRemoveAllCallbacks(Widget, String);
extern void XtRemoveCallback(Widget, String, XtCallbackProc, caddr_t);
extern void XtRemoveCallbacks(Widget, String, XtCallbackList);
extern void XtRemoveWorkProc(XtWorkProcId);
extern void XtResizeWidget(Widget, Dimension, Dimension, Dimension, Dimension);
extern void XtSetErrorHandler(XtErrorHandler);
extern void XtSetErrorMsgHandler(XtErrorMsgHandler);
extern void XtSetMappedWhenManaged(Widget, Boolean);
extern void XtSetSensitive(Widget, Boolean);
extern void XtSetSubvalues(caddr_t, XtResourceList, Cardinal, ArgList, Cardinal);
extern void XtSetValues(Widget, ArgList, Cardinal);
extern void XtSetWarningHandler(XtErrorHandler);
extern void XtSetWarningMsgHandler(XtErrorMsgHandler);
extern void XtToolkitInitialize();
extern void XtTranslateCoords(Widget,Position,Position,Position*,Position*);
extern void XtUnmanageChild (Widget);
extern void XtUnmanageChildren (WidgetList, Cardinal);
extern void XtUnrealizeWidget(Widget);
extern void XtWarning(String);
extern void XtWarningMsg(String, String, String, String, String*, Cardinal*);
extern XtAppContext XtWidgetToApplicationContext(Widget);
extern Widget XtWindowToWidget(Display*, Window);
extern void XtWriteBinaryDatabase();
extern void _XtInherit();

/*****************************************************************
 *
 * random convenient includes
 *
 ****************************************************************/

#ifdef VMS
#include <decw$include/Translate.h>
#include <decw$include/Event.h>
#include <decw$include/Object.h>
#include <decw$include/RectObj.h>
#include <decw$include/WindowObj.h>
#include <decw$include/Core.h>
#include <decw$include/Composite.h>
#include <decw$include/CompObj.h>
#include <decw$include/Constraint.h>
#include <decw$include/Convert.h>
/*#include <decw$include/Callback.h>
#include <decw$include/Event.h>
#include <decw$include/Geometry.h>
#include <decw$include/Popup.h>
#include <decw$include/Create.h>
#include <decw$include/Initialize.h>
#include <decw$include/Resource.h>
#include <decw$include/Error.h>
#include <decw$include/Alloc.h>
#include <decw$include/Work.h>
#include <decw$include/GC.h>*/
#else
#include "X++/Translate.h"
#include "X++/Event.h"
#include "xt++/Object.h"
#include "xt++/RectObj.h"
#include "xt++/WindowObj.h"
#include "xt++/Core.h"
#include "xt++/Composite.h"
#include "xt++/CompObj.h"
#include "xt++/Constraint.h"
#include "xt++/Convert.h"
/*#include "Callback.h"
#include  "Geometry.h"
#include  "Popup.h"
#include  "Create.h"
#include  "Initialize.h"
#include  "Resource.h"
#include  "Error.h"
#include  "Alloc.h"
#include  "Work.h"
#include  "GC.h"*/
#endif

extern GC XtGetGC(Widget, XtGCMask, XGCValues*);
extern void XtAddCallback(Widget, String, XtCallbackProc, caddr_t);

#endif _XtIntrinsic_h
/* DON'T ADD STUFF AFTER THIS #endif */