"

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'

       classVariableNames:   ''

       poolDictionaries:''

       category:'Interface-Graphics'

!

GLXWorkstation comment:'

COPYRIGHT (c) 1993 by Claus Gittinger

              All Rights Reserved

'!

%{

/*

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

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

 */

/*

 * define this 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 ...

 */

# define String GLX_String

#ifdef GLX

# include <gl/glws.h>

# include <gl/sphere.h>

#else

# include <vogl.h>

# include <X11/Xlib.h>

#endif

#ifndef NULL

#endif

typedef enum {

    GLXcolorIndexSingleBuffer,

    GLXcolorIndexDoubleBuffer,

    GLXrgbSingleBuffer,

    GLXrgbDoubleBuffer

} GLXWindowType;

extern Window GLXCreateWindow();

#undef String

/*

 * some defines - tired of typing ...

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

 * put/pack them into corresponding c variables.

 *

 */

#if defined(hpux) && defined(POSITIVE_ADDRESSES)

# define MKDPY(o)       (Display *)((int)(o) & ~TAG_INT)

# define MKWIN(o)        (Window)((int)(o) & ~TAG_INT)

#else

# define MKDPY(o)       (Display *)(_intVal(o))

# define MKWIN(o)       (Window)(_intVal(o))

#endif

#define myDpy MKDPY(_INST(displayId))

#define SETWIN(aGLXWindowId)                             \

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

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

            RETURN (false);                              \

        }                                                \

        _INST(activeWindow) = aGLXWindowId;              \

    }

/*

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

 * ST-object must be true or false

 */

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

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

#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

 */

#define _coordVal(c)                            \

    ((__isFloat(c)) ? (Coord)(_floatVal(c))      \

                   : (Coord)(_intVal(c)))

#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 

 */

#define _icoordVal(c) ((Icoord)(_intVal(c)))

#define _ICOORD_(arg, dst)              \

    if (_isSmallInteger(arg))           \

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

    else { RETURN(false); }

/*

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

 * ST-object must be SmallInteger 

 */

#define _scoordVal(c) ((Scoord)(_intVal(c)))

#define _SCOORD_(arg, dst)              \

    if (_isSmallInteger(arg))           \

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

    else { RETURN(false); }

#define _screencoordVal(c) ((Screencoord)(_intVal(c)))

#define _SCREENCOORD_(arg, dst)          \

    if (_isSmallInteger(arg))            \

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

    else { RETURN(false); }

#define _colorindexVal(c) ((Colorindex)(_intVal(c)))

#define _COLORINDEX_(arg, dst)           \

    if (_isSmallInteger(arg))            \

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

    else { RETURN(false); }

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

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

/*

 * helper for rotation - call rot() for floats or fractions; rotate for integers

 */

static OBJ

doRotate(angle, axis)

    OBJ angle;

    char axis;

{

    Angle a_angle;

    float f_angle;

    if (__isFloat(angle)) {

        f_angle = (float)(_floatVal(angle));

        rot(f_angle, axis);

        return (true);

    }

    if (__isFraction(angle)

     && _isSmallInteger(_FractionInstPtr(angle)->f_numerator)

     && _isSmallInteger(_FractionInstPtr(angle)->f_denominator)) {

        float n, d;

        n = (float)(_intVal(_FractionInstPtr(angle)->f_numerator));

        d = (float)(_intVal(_FractionInstPtr(angle)->f_denominator));

        f_angle = n / d;

        rot(f_angle, axis);

        return (true);

    }

    if (_isSmallInteger(angle)) {

        a_angle = (Angle)(_intVal(angle));

        rotate(a_angle, axis);

        return (true);

    }

    return false;

}

/*

 * fetch integers from an st-array (elements must be smallIntegers)

 */

static long *

getLongsFromInto(obj, vec, count)

   OBJ obj;

   long *vec;

{

    OBJ cls, o;

    int nByte, i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return (long *)NULL;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    if (nByte < (count * sizeof(OBJ))) return (long *)NULL;

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

        o = *(OBJ *)pElem;

        if (! _isSmallInteger(o)) return (long *)NULL;

        vec[i] = (long)_intVal(o);

        pElem += sizeof(OBJ);

    }

    return vec;

}

/*

 * fetch shorts from an st-array (elements must be smallIntegers)

 */

static short *

getShortsFromInto(obj, vec, count)

   OBJ obj;

   short *vec;

{

    OBJ cls, o;

    int nByte, i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return (short *)NULL;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    if (nByte < (count * sizeof(OBJ))) return (short *)NULL;

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

        o = *(OBJ *)pElem;

        if (! _isSmallInteger(o)) return (short *)NULL;

        vec[i] = (short)_intVal(o);

        pElem += sizeof(OBJ);

    }

    return vec;

}

/*

 * fetch floats from an st-object into a c-float array 

 * which may be a floatArray, doubleArray or array-of-something,

 * where something may be a float, fraction or smallInteger,

 */

static float *

getFloatsFromInto(obj, vec, count)

   OBJ obj;

   float *vec;

{

    OBJ cls;

    int nByte;

    OBJ o;

    int i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return (float *)0;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    switch (_intVal(_ClassInstPtr(cls)->c_flags) & ARRAYMASK) {

      case FLOATARRAY:

        /*

         * best speed for float array

         * - the data is already as we want it

         */

        if (nByte < (count * sizeof(float))) return (float *)0;

        return (float *)pElem;

      case DOUBLEARRAY:

        /*

         * for double array, have to copy-and-cast

         */

        if (nByte < (count * sizeof(double))) return (float *)0;

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

            vec[i] = *((double *)pElem);

            pElem += sizeof(double);

        }

        return vec;

      case POINTERARRAY:

        /*

         * for other array, have to fetch, check and store

         * the elements can be floats, smallintegers or fractions

         */

        if (nByte < (count * sizeof(OBJ))) return (float *)0;

        /* get elements one-by-one */

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

            o = *(OBJ *)pElem;

            if (__isFloat(o)) {

                vec[i] = _floatVal(o);

            } else if (_isSmallInteger(o)) {

                vec[i] = (float)(_intVal(o));

            } else if (__isFraction(o)

                    && _isSmallInteger(_FractionInstPtr(o)->f_numerator)

                    && _isSmallInteger(_FractionInstPtr(o)->f_denominator)) {

                float n, d;

                n = (float)(_intVal(_FractionInstPtr(o)->f_numerator));

                d = (float)(_intVal(_FractionInstPtr(o)->f_denominator));

                vec[i] = n / d;

            } else

                return 0;

            pElem += sizeof(OBJ);

        }

        return vec;

    }

    return (float *)0;

}

/*

 * fetch doubles from an st-object into a c-double array 

 * which may be a floatArray, doubleArray or array-of-something,

 * where something may be a float, fraction or smallInteger,

 */

static double *

getDoublesFromInto(obj, vec, count)

   OBJ obj;

   double *vec;

{

    OBJ cls, o;

    int nByte, i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return (double *)0;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    switch (_intVal(_ClassInstPtr(cls)->c_flags) & ARRAYMASK) {

      case DOUBLEARRAY:

        /* best speed for double array - the data is already as we want it */

        if (nByte < (count * sizeof(double))) return (double *)0;

        return (double *)pElem;

      case FLOATARRAY:

        if (nByte < (count * sizeof(float))) return (double *)0;

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

            vec[i] = *((float *)pElem);

            pElem += sizeof(float);

        }

        return vec;

      case POINTERARRAY:

        if (nByte < (count * sizeof(OBJ))) return (double *)0;

        /* get elements one-by-one */

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

            o = *(OBJ *)pElem;

            if (__isFloat(o)) 

                vec[i] = _floatVal(o);

            else if (_isSmallInteger(o)) 

                vec[i] = (double)(_intVal(o));

            else if (__isFraction(o)

                     && _isSmallInteger(_FractionInstPtr(o)->f_numerator)

                     && _isSmallInteger(_FractionInstPtr(o)->f_denominator)) {

                double n, d;

                n = (double)(_intVal(_FractionInstPtr(o)->f_numerator));

                d = (double)(_intVal(_FractionInstPtr(o)->f_denominator));

                vec[i] = n / d;

            } else 

                return 0;

            pElem += sizeof(OBJ);

        }

        return vec;

    }

    return (double *)0;

}

/*

 * move from a c-float array into an st-object,

 * the st-object MUST be either a float- or double array

 */

static

putFloatsFromInto(vec, obj, count)

   OBJ obj;

   float *vec;

{

    OBJ cls;

    int nByte;

    OBJ o;

    int i, ninstVars, nInstBytes;

    char *pElem;

    if (! _isNonNilObject(obj)) return 0;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);

    nInstBytes = OHDR_SIZE + ninstVars * sizeof(OBJ);

    nByte = _qSize(obj) - nInstBytes;

    pElem = (char *)(_InstPtr(obj)) + nInstBytes;

    switch (_intVal(_ClassInstPtr(cls)->c_flags) & ARRAYMASK) {

      case FLOATARRAY:

        if (nByte < (count * sizeof(float))) return 0;

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

            *(float *)pElem = vec[i];

            pElem += sizeof(float);

        }

        return 1;

      case DOUBLEARRAY:

        if (nByte < (count * sizeof(float))) return 0;

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

            *(double *)pElem = vec[i];

            pElem += sizeof(double);

        }

        return 1;

    }

    /* not implemented for others */

    return 0;

}

static Matrix*

getFloatsFromMatrixInto(obj, mp)

    OBJ obj;

    Matrix *mp;

{

    OBJ cls;

    extern OBJ FloatArray, DoubleArray, Array;

    int nByte;

    OBJ o;

    int ninstVars, nInstBytes;

    char *pElem;

    int x = 0;

    int i,j;

    if (! _isNonNilObject(obj)) return (Matrix *)0;

    cls = _qClass(obj);

    ninstVars = _intVal(_ClassInstPtr(cls)->c_ninstvars);