"

COPYRIGHT (c) 1989 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.

"

DeviceWorkstation subclass:#XWorkstation

       instanceVariableNames:'screen

                              hasShapeExtension hasFaxExtension hasShmExtension

                              hasDPSExtension hasSaveUnder ignoreBackingStore

                              blackpixel whitepixel redMask greenMask blueMask

                              protocolsAtom deleteWindowAtom saveYourselfAtom

                              quitAppAtom

                              listOfXFonts eventRootX eventRootY buttonsPressed

                              displayName eventTrace

                              dispatchingExpose

                              rgbVisual'

       classVariableNames:   ''

       poolDictionaries:''

       category:'Interface-Graphics'

!

XWorkstation comment:'

COPYRIGHT (c) 1989 by Claus Gittinger

              All Rights Reserved

'!

!XWorkstation class methodsFor:'documentation'!

copyright

"

COPYRIGHT (c) 1989 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.

"

!

version

"

"

!

documentation

"

    this class provides the interface to X11

"

! !

%{

/*

 * x does a typedef Time - I need Object Time ...

 */

#define Time XTime

#ifdef memset

# undef memset

#endif

#ifdef IRIX5

  /*

   * accessing private data in Display ... sorry

   */

# define XLIB_ILLEGAL_ACCESS

#endif

#include <stdio.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/Xatom.h>

#define TWOBYTESTRINGS

/*

 * shape support works; enabled by -DSHAPE in makefile

 * see RoundClock and RoundGlobe examples

 */

#ifdef SHAPE

# include <X11/extensions/shape.h>

#endif

/*

 * shared memory extension currently not supported

 * (only query is implemented)

 */

#ifdef SHM

# include <X11/extensions/XShm.h>

#endif

/*

 * this is a non-standard fax-image decompression extension

 * (only found in megascan servers ported by myself)

 */

#ifdef FAX

# include <X11/extensions/XFAXImage.h>

#endif

/*

 * when I have more time to check it out, Ill support display-PS

 */

#ifdef DPS

# ifdef sgi

#  include <X11/extensions/XDPS.h>

#  include <X11/extensions/XDPSlib.h>

#  include <X11/extensions/dpsXclient.h>

# else

#  include <DPS/XDPS.h>

#  include <DPS/XDPSlib.h>

#  include <DPS/dpsXclient.h>

# endif

#endif

static XEvent __ev__;

/*

 * a private error handler

 */

static char lastErrorMsg[80] = "";

static unsigned lastRequestCode = 0;

static unsigned lastMinorCode = 0;

static unsigned lastResource = 0;

/*

 * catch X-errors and forward as errorInterrupt,

 * (which itself raises an exceptionSignal)

 */

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

    fprintf(stderr, "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, "        (%s)\n", lastErrorMsg);

    errorInterrupt();

    return 0;

}

/*

 * added since RootWindow-macro is not suficient

 * when virtual root-windows are involved (i.e. tvtwm)

 */

static Window

getRootWindow(dpy, screen)

    Display *dpy;

{

    Window root;

    Atom vRootAtom = None;

    int i;

    Window rootReturn, parentReturn;

    Window* children;

    unsigned int numChildren;

    root = RootWindow(dpy, screen);

    /*

     * on IRIS, this creates a badwindow error - why ?

     * children contains a funny window (000034)

     */

#ifndef IRIS

    if (XQueryTree(dpy, root, &rootReturn, &parentReturn, &children, &numChildren)) {

        vRootAtom = XInternAtom(dpy, "__SWM_VROOT", True );

        if (vRootAtom != None) {

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

                Atom actual_type;

                int actual_format;

                unsigned long nitems, bytesafter;

                Window* newRoot = (Window*) 0;

                if (children[i]) {

                    if (XGetWindowProperty(dpy, children[i], vRootAtom,

                                           0L, 1L, False, XA_WINDOW,

                                           &actual_type, &actual_format, &nitems, &bytesafter,

                                           (unsigned char**) &newRoot) == Success && newRoot) {

                        root = *newRoot;

                        break;

                    }

                }

            }

            if (children) XFree( children );

        }

    }

#endif

    return root;

}

/*

 * some defines - tired of typing ...

 */

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

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

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

# define _PixmapVal(o)        (Pixmap)((int)(o) & ~TAG_INT)

# define _GCVal(o)            (GC)((int)(o) & ~TAG_INT)

# define _CursorVal(o)        (Cursor)((int)(o) & ~TAG_INT)

# define _FontVal(o)          (XFontStruct *)((int)(o) & ~TAG_INT)

# define _AtomVal(o)          (Atom)((int)(o) & ~TAG_INT)

# define _DPSContextVal(o)    (DPSContext)((int)(o) & ~TAG_INT)

#else

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

# define _WindowVal(o)        (Window)(_intVal(o))

# define _PixmapVal(o)        (Pixmap)(_intVal(o))

# define _GCVal(o)            (GC)(_intVal(o))

# define _CursorVal(o)        (Cursor)(_intVal(o))

# define _FontVal(o)          (XFontStruct *)(_intVal(o))

# define _AtomVal(o)          (Atom)(_intVal(o))

# define _DPSContextVal(o)    (DPSContext)(_intVal(o))

#endif

#define myDpy _DisplayVal(_INST(displayId))

#ifndef THISCONTEXT_IN_REGISTER

# define BLOCKINTERRUPTS()      /* */

# define UNBLOCKINTERRUPTS()    /* */

# define BEGIN_INTERRUPTSBLOCKED /* */

# define END_INTERRUPTSBLOCKED /* */

#else

extern int __interruptsBlocked;

# define BEGIN_INTERRUPTSBLOCKED        \

    {                                   \

        int needUnblock = 0;            \

        extern OBJ __thisContext__;     \

                                        \

        __thisContext__ = __thisContext;\

        if (!__interruptsBlocked) {     \

            BLOCKINTERRUPTS();          \

            needUnblock = 1;            \

        }

# define END_INTERRUPTSBLOCKED          \

        if (needUnblock) {              \

            UNBLOCKINTERRUPTS();        \

        }                               \

        __thisContext__ = 0;            \

    }

#endif

%}

!XWorkstation class methodsFor:'initialization'!

initialize

    self initializeConstants.

! !

!XWorkstation class methodsFor:'error handling'!

requestCodeOfLastError

%{  /* NOCONTEXT */

    RETURN ( _MKSMALLINT(lastRequestCode) );

%}

!

minorCodeOfLastError

%{  /* NOCONTEXT */

    RETURN ( _MKSMALLINT(lastMinorCode) );

%}

!

resourceIdOfLastError

%{  /* NOCONTEXT */

    RETURN ( _MKSMALLINT(lastResource) );

%}

!

lastError

    "return the last X-error string - 

     when buffering is on, this may be

     an error for a long-ago operation"

%{

    RETURN ( _MKSTRING(lastErrorMsg, __context) );

%}

! !

!XWorkstation methodsFor:'initialize / release'!

initializeFor:aDisplayName

    "initialize the receiver for a connection to an X-Server;

     the argument, aDisplayName may be nil (for the default server from

     DISPLAY-variable) or the name of the server as hostname:number"

%{

    int scr;

    Display *dpy;

    Visual *visual;

    XVisualInfo viproto;

    XVisualInfo *vip;                   /* retured info */

    int maxRGBDepth;

    int rgbRedMask, rgbGreenMask, rgbBlueMask;

    int rgbVisualID;

    int nvi, i;

    int shapeEventBase, shapeErrorBase;

    int shmEventBase, shmErrorBase;

    int faxEventBase, faxErrorBase;

    char *type;

    int dummy;

    if (_INST(displayId) != nil) {

        RETURN ( self );

    }

    BEGIN_INTERRUPTSBLOCKED

    if (aDisplayName != nil)

        dpy = XOpenDisplay((char *)_stringVal(aDisplayName));

    else

        dpy = XOpenDisplay(NULL);

    if (dpy) {

#ifdef SUPERDEBUG

        XSynchronize(dpy, 1);

#endif

        _INST(screen) = _MKSMALLINT(scr = DefaultScreen(dpy));

        _INST(displayId) = MKOBJ((int)dpy);

        _INST(depth) = _MKSMALLINT(DisplayPlanes(dpy, scr));

        _INST(ncells) = _MKSMALLINT(DisplayCells(dpy, scr));

        _INST(width) = _MKSMALLINT(DisplayWidth(dpy, scr));

        _INST(height) = _MKSMALLINT(DisplayHeight(dpy, scr));

        _INST(widthMM) = _MKSMALLINT(DisplayWidthMM(dpy, scr));

        _INST(heightMM) = _MKSMALLINT(DisplayHeightMM(dpy, scr));

        _INST(blackpixel) = _MKSMALLINT(BlackPixel(dpy, scr));

        _INST(whitepixel) = _MKSMALLINT(WhitePixel(dpy, scr));

#ifdef SHAPE

        if (XShapeQueryExtension(dpy, &shapeEventBase, &shapeErrorBase))

            _INST(hasShapeExtension) = true;

        else

#else

        _INST(hasShapeExtension) = false;

#endif

#ifdef SHM

        if (XShmQueryExtension(dpy, &shmEventBase, &shmErrorBase))

            _INST(hasShmExtension) = true;

        else

#else

        _INST(hasShmExtension) = false;

#endif

#ifdef FAX

        if (XFAXImageQueryExtension(dpy, &faxEventBase, &faxErrorBase))

            _INST(hasFaxExtension) = true;

        else

#else

        _INST(hasFaxExtension) = false;

#endif

#ifdef DPS

        if (XQueryExtension(dpy, "DPSExtension", &dummy, &dummy, &dummy))

            _INST(hasDPSExtension) = true;

        else

#else

        _INST(hasDPSExtension) = false;

#endif

        /*

         * this is a kludge around a bug in the X11/NeWS server,

         * which does not correctly handle saveUnder

         */

        if (strncmp(XServerVendor(dpy), "X11/NeWS", 8) == 0) {

            _INST(hasSaveUnder) = false;

        } else

            _INST(hasSaveUnder) = true;

        /*

         * look for RGB visual

         */

        nvi = 0;

        viproto.screen = scr;

        vip = XGetVisualInfo (dpy, VisualScreenMask, &viproto, &nvi);

        maxRGBDepth = 0;

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

            switch (vip[i].class) {

                case TrueColor:

                    if (vip[i].depth > maxRGBDepth) {

                        maxRGBDepth = vip[i].depth;

                        rgbRedMask = vip[i].red_mask;

                        rgbGreenMask = vip[i].green_mask;

                        rgbBlueMask = vip[i].blue_mask;

                        rgbVisualID = vip[i].visualid;

                    }

                    break;

            }

        }

        if (vip) XFree ((char *) vip);

        if (maxRGBDepth) {

            _INST(rgbVisual) = _MKSMALLINT(rgbVisualID);

        }

        visual = DefaultVisualOfScreen(DefaultScreenOfDisplay(dpy));

        switch (visual->class) {

            case StaticGray:

                _INST(visualType) = @symbol(StaticGray);

                _INST(hasColors) = false;

                _INST(hasGreyscales) = true;

                _INST(monitorType) = @symbol(monochrome);

                break;

            case GrayScale:

                _INST(visualType) = @symbol(GrayScale);

                _INST(hasColors) = false;

                _INST(hasGreyscales) = true;

                _INST(monitorType) = @symbol(monochrome);

                break;

            case StaticColor:

                _INST(visualType) = @symbol(StaticColor);

                _INST(hasColors) = true;

                _INST(hasGreyscales) = true;

                _INST(monitorType) = @symbol(unknown);

                break;

            case PseudoColor:

                _INST(visualType) = @symbol(PseudoColor);

                _INST(hasColors) = true;

                _INST(hasGreyscales) = true;

                _INST(monitorType) = @symbol(unknown);

                break;

            case TrueColor:

                _INST(visualType) = @symbol(TrueColor);

                _INST(hasColors) = true;

                _INST(hasGreyscales) = true;

                _INST(monitorType) = @symbol(unknown);

                break;

            case DirectColor:

                _INST(visualType) = @symbol(DirectColor);

                _INST(hasColors) = true;

                _INST(hasGreyscales) = true;

                _INST(monitorType) = @symbol(unknown);

                break;

        }

        if (DisplayCells(dpy, scr) == 2) {

            _INST(hasColors) = false;

            _INST(hasGreyscales) = false;

            _INST(monitorType) = @symbol(monochrome);

        }

        _INST(bitsPerRGB) = _MKSMALLINT(visual->bits_per_rgb);

        _INST(redMask)   = _MKSMALLINT(visual->red_mask);

        _INST(greenMask) = _MKSMALLINT(visual->green_mask);

        _INST(blueMask)  = _MKSMALLINT(visual->blue_mask);

        XSetErrorHandler(__XErrorHandler__);

    }

    END_INTERRUPTSBLOCKED

%}

.

    displayId isNil ifTrue:[

        'cannot connect to Display.' errorPrintNewline.

        ^ nil

    ].

    dispatching := false.

    dispatchingExpose := false.

    isSlow := false.

    shiftDown := false.

    controlDown := false.

    metaDown := false.

    altDown := false.

    motionEventCompression := true.

    buttonsPressed := 0.

    displayName := aDisplayName.

    protocolsAtom := nil.

    deleteWindowAtom := nil.

    saveYourselfAtom := nil.

    quitAppAtom := nil.

    self initializeKeyboardMap.

    ObjectMemory errorInterruptHandler:self class.

!

close

    "close down the connection to the X-server"

%{  /* NOCONTEXT */

    if (_INST(displayId) != nil) {

        BEGIN_INTERRUPTSBLOCKED

        XCloseDisplay(myDpy);

        _INST(displayId) = nil;

        END_INTERRUPTSBLOCKED

    }

%}