"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

XWorkstation subclass:#GLXWorkstation

	instanceVariableNames:'activeWindow hasStereoExtension glOK'

	classVariableNames:'ForceGL'

	poolDictionaries:''

	category:'Interface-Graphics'

!

!GLXWorkstation primitiveDefinitions!

%{

/*

 * on SGI, this class is compiled with -DGLX, while

 * for simulation (using vogl), this is compiled with -DVGL

 *   

 * New note: starting to support openGL (tm) (compile with -DOPENGL)

 * or its simulation (compile with -DOPENGL -DMESA)

 */

/*

 * SAD, SAD:

 *    on SGI, the GL library seems to come in different versions,

 *    some include the functions below, others dont.

 *    To avoid getting undefined symbol errors when linking, these

 *    functions are not included by default.

 *

 * enable the #define below (or compile with -DFULL_GLX) to enable

 * the following:

 *

 *    blendcolor getgconfig getmultisample leftbuffer rightbuffer monobuffer

 *    msalpha msmask mspattern mssize multisample stereobuffer

 *    t3s t3i t3f t3d t4s t4i t4f t4d tlutbind zbsize

 *

 * these are not available on all gl's

 */

/* #define FULL_GLX */

/*

 * this is stupid, GLX type-defs String, which is also defined here ...

 * ... and xlib defines True and False

 * It might be a better idea, to completely separate GLX stuff from ST/X

 */

# ifdef String

#  undef String

# endif

# define String GLX_String

# ifdef Object

#  undef Object

# endif

# define Object GLX_Object

# undef True

# undef False

#include <stdio.h>

#ifdef OPENGL   /* SGI or others OPENGL library */

# include "GL/gl.h"

# ifdef MESA    /* GNU MESA openGL simulation */

#  include "GL/xmesa.h"

#  define OPENGLCONTEXT                         XMesaContext

#  define GLXMAKECURRENT(dpy, draw, con)        XMesaMakeCurrent(con)

# else

   /* not yet known what else to include */

#  define OPENGLCONTEXT GLXContext

#  define GLXMAKECURRENT(dpy, draw, con)        glxMakeCurrent(dpy, draw, con)

# endif

#else

# ifdef GLX     /* SGI's GL library */

#  include <gl/glws.h>

#  include <gl/sphere.h>

# else          /* VOGL GL simulation */

#  undef memset

#  include <vogl.h>

#  undef move

#  include <X11/Xlib.h>

# endif

#endif

/*

 * XSGIStereo extension - if available

 */

#ifdef XSGIStereo

# include <X11/extensions/SGIStereo.h>

#endif

#ifndef NULL

# define NULL (char *)0         /* sigh */

#endif

typedef enum {

    GLXcolorIndexSingleBuffer,

    GLXcolorIndexDoubleBuffer,

    GLXrgbSingleBuffer,

    GLXrgbDoubleBuffer

} GLXWindowType;

# define ENTERGLX     __BEGIN_PROTECT_REGISTERS__

# define LEAVEGLX     __END_PROTECT_REGISTERS__

/*

 * stupid again - from now on, we need ST/X's String again

 */

#undef String

#ifdef __DEF_String

# define String __DEF_String

#endif

#undef Object

#ifdef __DEF_Object

# define Object __DEF_Object

#endif

/*

 * mhmh - openGL has its separate gl-context,

 * which is distinct (?) from the windowID.

 * We dont want to add another instvar to View - do we ?

 */

#if defined(OPENGL)

# ifndef MAX_OPENGL_VIEWS

#  define MAX_OPENGL_VIEWS      50

# endif

struct windowIDToGLContextMapping {

	Window          win;

	OPENGLCONTEXT   con;

};

static struct windowIDToGLContextMapping windowIDToGLContextMapping[MAX_OPENGL_VIEWS];

static OPENGLCONTEXT

__glxWindowIdToGLContext(xId) 

	Window xId;

{

	int i;

	for (i=0; i<MAX_OPENGL_VIEWS; i++) {

	    if (windowIDToGLContextMapping[i].win == xId) {

		return windowIDToGLContextMapping[i].con;

	    }

	}

	return (OPENGLCONTEXT) 0;

}

/*

 * set the GLXWindow for followup drawing

 */

#define SETWIN(aGLXWindowId)                            \

    {                                                   \

	OPENGLCONTEXT context;                          \

							\

	if (_INST(activeWindow) != aGLXWindowId) {      \

	    if (! ISCONNECTED ) {                       \

		RETURN (false);                         \

	    }                                           \

	    if (! __isExternalAddress(aGLXWindowId)) {  \

		RETURN (false);                         \

	    }                                           \

	    context = (OPENGLCONTEXT) __glxWindowIdToGLContext(_WindowVal(aGLXWindowId));       \

	    if (! context) {                            \

		RETURN (false);                         \

	    }                                           \

	    GLXMAKECURRENT(myDpy, _WindowVal(aGLXWindowId), context ); \

	    _INST(activeWindow) = aGLXWindowId;         \

	    __STORE(self, aGLXWindowId);                \

	} else {                                        \

	    if (aGLXWindowId == nil) {                  \

		RETURN (false);                         \

	    }                                           \

	}                                               \

    }

#else /* old GL */

/*

 * set the GLXWindow for followup drawing

 */

#define SETWIN(aGLXWindowId)                            \

    {                                                   \

	if (_INST(activeWindow) != aGLXWindowId) {      \

	    if (! ISCONNECTED ) {                       \

		RETURN (false);                         \

	    }                                           \

	    if (! __isExternalAddress(aGLXWindowId)) {  \

		RETURN (false);                         \

	    }                                           \

	    if (GLXwinset(myDpy, _WindowVal(aGLXWindowId)) < 0) { \

		RETURN (false);                         \

	    }                                           \

	    _INST(activeWindow) = aGLXWindowId;         \

	    __STORE(self, aGLXWindowId);                \

	} else {                                        \

	    if (aGLXWindowId == nil) {                  \

		RETURN (false);                         \

	    }                                           \

	}                                               \

    }

#endif /* old GL */

/*

 * some defines - tired of typing ...

 * most of these macros/functions extract values from smalltalk objects or

 * put/pack them into corresponding c variables.

 *

 */

#ifdef OPENGL

# define Boolean        int

# define TRUE           1

# define FALSE          0

# define Coord          float

# define Icoord         int

# define Scoord         int

# define Colorindex     int

# define Linestyle      int

# define Offset         int

# define Angle          int

# define Screencoord    int

#endif

#define myDpy              (Display *)(__MKCP(_INST(displayId)))

#define ISCONNECTED        (_INST(displayId) != nil)

#define _WindowVal(o)      (Window)(__MKCP(o))

#define __MKBOOLEAN(b)     ((b==FALSE) ? false : true)

#define _booleanVal(b)     ((b==false) ? (Boolean)FALSE : (Boolean)TRUE)

#define _coordVal(c)       ((__isFloat(c)) ? (Coord)(_floatVal(c))  : (Coord)(__intVal(c)))

#define _icoordVal(c)      ((Icoord)(__intVal(c)))

#define _scoordVal(c)      ((Scoord)(__intVal(c)))

#define _screencoordVal(c) ((Screencoord)(__intVal(c)))

#define _colorindexVal(c)  ((Colorindex)(__intVal(c)))

#define _linestyleVal(l)   ((Linestyle)(__intVal(l)))

#define _shortVal(l)       ((short)(__intVal(l)))

#define _longVal(l)        ((long)(__intVal(l)))

#define _deviceVal(l)      ((Device)(__intVal(l)))

#define _tagVal(l)         ((Tag)(__intVal(l)))

#define _objectVal(l)      ((GLX_Object)(__intVal(l)))

#define _offsetVal(l)      ((Offset)(__intVal(l)))

#define _rgbVal(l)         ((RGBvalue)(__intVal(l)))

#define _angleVal(c)       ((Angle)(__intVal(c)))

/*

 * check for and fetch a boolean from ST-arg into C-dst

 * ST-object must be true or false. Return from method if invalid.

 */

#define _BOOLEAN_(arg, dst)             \

    if (arg==true)                      \

	dst = (Boolean)TRUE;            \

    else if (arg==false)                \

	dst = (Boolean)FALSE;           \

    else { RETURN(false); }

/*

 * check for and fetch a coord from ST-arg into C-dst

 * ST-object must be Float, SmallInteger or Fraction.

 * Return from method if invalid.

 */

#define _COORD_(arg, dst)               \

    if (__isFloat(arg))                 \

	dst = (Coord)(_floatVal(arg));  \

    else if (__isSmallInteger(arg))     \

	dst = (Coord)(__intVal(arg));    \

    else if (__isFraction(arg)          \

	  && __isSmallInteger(_FractionInstPtr(arg)->f_numerator)       \

	  && __isSmallInteger(_FractionInstPtr(arg)->f_denominator)) {  \

	float n, d;                                                     \

									\

	n = (float)(__intVal(_FractionInstPtr(arg)->f_numerator));       \

	d = (float)(__intVal(_FractionInstPtr(arg)->f_denominator));     \

	dst = (Coord)(n / d);                                           \

    } else { RETURN(false); }

/*

 * check for and fetch an icoord from ST-arg into C-dst

 * ST-object must be SmallInteger. Return from method if invalid. 

 */

#define _ICOORD_(arg, dst)              \

    if (__isSmallInteger(arg))          \

      dst = (Icoord)(__intVal(arg));     \

    else { RETURN(false); }

/*

 * check for and fetch an scoord from ST-arg into C-dst

 * ST-object must be SmallInteger. Return from method if invalid. 

 */

#define _SCOORD_(arg, dst)              \

    if (__isSmallInteger(arg))          \

      dst = (Scoord)(__intVal(arg));     \

    else { RETURN(false); }

#define _SCREENCOORD_(arg, dst)          \

    if (__isSmallInteger(arg))           \

      dst = (Screencoord)(__intVal(arg)); \

    else { RETURN(false); }

#define _COLORINDEX_(arg, dst)           \

    if (__isSmallInteger(arg))           \

      dst = (Colorindex)(__intVal(arg));  \

    else { RETURN(false); }

#define _ANGLE_(arg, dst)               \

    if (__isSmallInteger(arg))          \

	dst = (Angle)(__intVal(arg));    \

    else { RETURN(false); }

#define _FLOAT_(arg, dst)               \

    if (__isFloat(arg))                 \

	dst = (float)(_floatVal(arg));  \

    else if (__isSmallInteger(arg))     \

	dst = (float)(__intVal(arg));    \

    else if (__isFraction(arg)          \

	  && __isSmallInteger(_FractionInstPtr(arg)->f_numerator)       \

	  && __isSmallInteger(_FractionInstPtr(arg)->f_denominator)) {  \

	float n, d;                                                     \

									\

	n = (float)(__intVal(_FractionInstPtr(arg)->f_numerator));       \

	d = (float)(__intVal(_FractionInstPtr(arg)->f_denominator));     \

	dst = (float)(n / d);                                           \

    } else { RETURN(false); }

#define _INT_(arg, dst)                 \

    if (__isSmallInteger(arg))          \

	dst = (int)(__intVal(arg));      \

    else { RETURN(false); }

#define _indexedArea(object)            \

    (((char *) (_InstPtr(object)))      \

	+ OHDR_SIZE                     \

	+ (__intVal(_ClassInstPtr(__qClass(object))->c_ninstvars)) * sizeof(OBJ))

%}

! !

!GLXWorkstation primitiveVariables!

%{

/*

 * remembered info from private error handler

 */

static char lastErrorMsg[80] = "";

static unsigned lastRequestCode = 0;

static unsigned lastMinorCode = 0;

static unsigned lastResource = 0;

%}

! !

!GLXWorkstation primitiveFunctions!

%{

#ifdef DYNAMICALLY_LOADABLE

/*

 * catch X-errors and forward as errorInterrupt:#DisplayError,

 * (which itself invokes my handler and optionally raises an exceptionSignal)

 * the implementation below is somewhat wrong: it will

 * report all errors for Display, even though there could be

 * more than one display connection. (being fixed, new errorInterrupt mechanism

 * allows passing an additional argument, which is the displayID ...)

 *

 * this dublicates the functionality as found in XWorkstation;

 * the reason is to allow dynamic loading systems to load this module

 * before XWorkstation (which was not possible otherwise, due to unresolved

 * external references while loading this one)

 */

static

__XErrorHandler__(dpy, event)

    Display *dpy;

    XErrorEvent *event;

{

    XGetErrorText(dpy, event->error_code, lastErrorMsg, 80);

    if (lastErrorMsg[0] == '\0') {

	sprintf(lastErrorMsg, "code: %d", event->error_code);

    }

    lastRequestCode = event->request_code;

    lastMinorCode = event->minor_code;

    lastResource = event->resourceid;

    if ((event->error_code == BadWindow) && (lastRequestCode == 4) && (lastMinorCode == 0)) {

	/* 

	 * this is a BadWindow error for X_DestroyWindow.

	 * ignore it here, since it results from the GC freeing windows

	 * in non bottom-up window order.

	 */

	return 0;

    }

    if (@global(ErrorPrinting) == true) {

	fprintf(stderr, "XWORKSTAT: x-error cought maj=%d (0x%x) min=%d (0x%x) resource=%x\n",

			event->request_code, event->request_code,

			event->minor_code, event->minor_code, event->resourceid);

	fprintf(stderr, "XWORKSTAT: x-error message is [%d] '%s'\n", event->error_code, lastErrorMsg);

    }

    __errorInterruptWithIDAndParameter__(@symbol(DisplayError), __MKOBJ(dpy));

    return 0;

}

#else

extern __XErrorHandler__();

#endif

/* 

 * begin moved from GLXsupport.c

 */

/*

 * This provides a helper function "GLXCreateWindow", which does

 * all the necessary magic to create an X window suitable for GL drawing 

 * to take place within. See the definition of GLXCreateWindow for a 

 * description of how to call it.

 *

 * claus: I really had no time to look into all this,

 * this file has been just copied from a 4Dgifts demo ..

 * (will need more than a day to show more ...)

 */

#if defined(GLX) || defined(VGL)

#include        <X11/Xlib.h>

#include        <X11/Xutil.h>

#ifndef VGL

# include        <gl/glws.h>  

#endif

#include        <signal.h>

#include        <setjmp.h>

#include        "stcIntern.h"

/*

 * glxhelper.h:

 *

 *   List of drawing modes supported by GLXCreateWindow (in glxhelper.c).

 * More than this are possible with mixed model, but this is just an 

 * example.  You can either expand this list (and the corresponding code in 

 * GLXCreateWindow) or call the mixed model calls yourself, using 

 * GLXCreateWindow as an example.

 */

static char *

typeToName[] = {

    "color index single buffer",

    "color index double buffer",

    "rgb single buffer",

    "rgb double buffer",

};

#ifndef VGL

/*

 * Dorky little helper function used to build up a GLXconfig array.

 */

static void 

set_entry (GLXconfig* ptr, int b, int m, int a)

{

    ptr->buffer = b;

    ptr->mode = m;

    ptr->arg = a;

}

#endif /* VGL */

static JMP_BUF errorReturn;

static void

glAbort() {

    longjmp(errorReturn, 1);

}

/*

 * GLXCreateWindow(dpy, parent, x, y, w, h, boderWidth, type)

 *

 * Return value is the X window id of the newly created window.

 *

 * Arguments are:

 *      dpy             The X "Display*" returned by XOpenDisplay

 *      parent          The parent of the newly created window,