"

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

 */

/*

 * define this (or compile with -DFULL_GLX) to enable:

 *    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 defines String, which is also defined here ...

 * ... and xlib defines True and False

 */

# undef String

# define String GLX_String

# undef True

# undef False

#include <stdio.h>

#ifdef GLX

# include <gl/glws.h>

# include <gl/sphere.h>

#else

# undef memset

# include <vogl.h>

# undef move

# include <X11/Xlib.h>

#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;

/*

extern Window GLXCreateWindow();

*/

# 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

/*

 * some defines - tired of typing ...

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

 * put/pack them into corresponding c variables.

 *

 */

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

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

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

/*

 * 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);                             \

	}                                               \

    }

#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)      ((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 wth false 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 wth false 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 wth false 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 wth false 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!

%{

/*

 * 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 (@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 '%s'\n", lastErrorMsg);

    }

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

    return 0;

}

/* 

 * begin moved from GLXsupport.c

 */

/*

 * GLXsupport.c:

 *

 *   This file 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,

 *                      a typical value for this is

 *                      RootWindow(dpy, DefaultScreen(dpy))

 *      x,y             The location of the window to be created,

 *                      y coordinate is measured from the top down.

 *      w,h             size of the new window

 *      borderWidth     the X border size for this window, should probably

 *                      be zero.

 *      type            the GLXWindowType (see glxhelper.h) desribing the

 *                      typer of GL drawing to be done in this window

 */

static Window 

GLXCreateWindow(dpy, parent, x, y, w, h, borderWidth, type)

    Display* dpy;

    Window parent;

    GLXWindowType type;

{

#ifdef VGL

    Visual visual;

#else

    GLXconfig params[50];

    GLXconfig* next;

    GLXconfig* retconfig;

    Colormap cmap = DefaultColormap(dpy, DefaultScreen(dpy));

    XVisualInfo *vis;

#endif

    XVisualInfo template;

    XColor white;

    XSetWindowAttributes cwa;

    XWindowAttributes   pwa;

    int scr, i, nret;

    Window win;

#ifdef HAS_SIGACTION

    struct sigaction oldSig, newSig;

#else

    void *oldSig;

#endif

    __catchExit(1);

    if (setjmp(errorReturn)) {

	printf("hard error in GL - return\n");

#ifdef HAS_SIGACTION

	sigaction(SIGSEGV, &oldSig, 0);

#else

	signal(SIGSEGV, oldSig);

#endif

        __catchExit(0);

	return 0;

    }

    __CONT__

#ifdef VGL

    /*

     * I know what VGL supports; its somewhat unclean to hard code it here

     */

    switch (type) {

      case GLXcolorIndexSingleBuffer:

      case GLXcolorIndexDoubleBuffer:

	break;

      case GLXrgbSingleBuffer:

      case GLXrgbDoubleBuffer:

	printf("Sorry, VGL can't support %s type of windows\n", typeToName[type]);

        __catchExit(0);

	return 0;

    }

    scr = DefaultScreen(dpy);

    visual.visualid = CopyFromParent;

    cwa.border_pixel = 0;  /* Even if we don't use it, it must be something */

    if (w <= 0) {

	printf("VGL: bad width: %d\n", w);

	w = 1;

    }

    if (h <= 0) {

	printf("VGL: bad height: %d\n", h);

	h = 1;

    }

    win = XCreateWindow(dpy, parent, x, y, w, h,

			     borderWidth, DisplayPlanes(dpy, scr), 

			     InputOutput, &visual,

			     CWBorderPixel, &cwa);

    /*

     * on some, seg-violations occur in the GL, if too many

     * views are created ... just to make certain, we catch those

     * in GL too.

     */

# ifdef HAS_SIGACTION

    sigaction(SIGSEGV, (struct sigaction *)0, &oldSig);

    newSig = oldSig;

    newSig.sa_handler = glAbort;

    sigaction(SIGSEGV, &newSig, (struct sigaction *)0);

# else

    oldSig = signal(SIGSEGV, glAbort);

# endif

    i = GLXlink(dpy, win);

# ifdef HAS_SIGACTION

    sigaction(SIGSEGV, &oldSig, (struct sigaction *)0);

# else

    signal(SIGSEGV, oldSig);

# endif

    if (i < 0) {

	printf("GLXlink returned %d\n", i);

        __catchExit(0);

	return 0;

    }

#else /* not VGL */

    /*

     * This builds an array in "params" that describes for GLXgetconfig(3G)

     * the type of GL drawing that will be done.

     */

    next = params;

    switch (type) {

      case GLXcolorIndexSingleBuffer:

	set_entry(next++, GLX_NORMAL, GLX_RGB, FALSE);

	set_entry(next++, GLX_NORMAL, GLX_DOUBLE, FALSE);

	break;

      case GLXcolorIndexDoubleBuffer:

	set_entry(next++, GLX_NORMAL, GLX_RGB, FALSE);

	set_entry(next++, GLX_NORMAL, GLX_DOUBLE, TRUE);

	break;

      case GLXrgbSingleBuffer:

	set_entry(next++, GLX_NORMAL, GLX_RGB, TRUE);

	set_entry(next++, GLX_NORMAL, GLX_DOUBLE, FALSE);

	break;

      case GLXrgbDoubleBuffer:

	set_entry(next++, GLX_NORMAL, GLX_RGB, TRUE);