"

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

			      primaryAtom secondaryAtom cutBuffer0Atom

			      stringAtom lengthAtom

			      listOfXFonts buttonsPressed

			      eventRootX eventRootY

			      displayName eventTrace

			      dispatchingExpose

       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. It redefines all required methods

    from DeviceWorkstation. Notice, that in Smalltalk/X you are not technically

    limited to one display - in theory, you can create Views on many displays

    simultanously. However, the default setup is for one display only.

    To support multiple displays, you will have to start another event dispatcher

    process for the other display(s) and create the other views with a slightly

    different protocol. However, 'normal' applications do not have to care for

    all of this ...

"

! !

!XWorkstation primitiveDefinitions!

%{

/*

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

 */

#define Time XTime

#ifdef memset

# undef memset

#endif

#include <stdio.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/Xatom.h>

/*

 * this define adds support for two-byte-strings.

 * leaving it undefined does not really save you much

 * (the define will vanish)

 */

#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, I will 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

#if defined(IRIX5) || (XlibSpecificationRelease == 6)

  /*

   * accessing private data in Display ... sorry

   */

# define DISPLAYACCESS(d) ((_XPrivDisplay)d)

#else

# define DISPLAYACCESS(d) d

#endif

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

# undef MKOBJ

# define MKOBJ(p) (OBJ)((int)p | TAG_INT)

# define MKCP(o)  (char *)((int)(o) & ~TAG_INT)

#else

# define MKCP(o)  (char *)(_intVal(o))

#endif

/*

 * some defines - tired of typing ...

 */

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

#define _WindowVal(o)        (Window)(MKCP(o))

#define _PixmapVal(o)        (Pixmap)(MKCP(o))

#define _GCVal(o)            (GC)(MKCP(o))

#define _CursorVal(o)        (Cursor)(MKCP(o))

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

#define _AtomVal(o)          (Atom)(MKCP(o))

#define _DPSContextVal(o)    (DPSContext)(MKCP(o))

#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 primitiveVariables!

%{

/*

 * a private error handler

 */

static char lastErrorMsg[80] = "";

static unsigned lastRequestCode = 0;

static unsigned lastMinorCode = 0;

static unsigned lastResource = 0;

static int __debug__ = 0;

#define DPRINTF(x)      if (__debug__) { printf x; }

%}

! !

!XWorkstation primitiveFunctions!

%{

/*

 * catch X-errors and forward as errorInterrupt,

 * (which itself 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.

 */

__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, "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);

    errorInterrupt();

    return 0;

}

#ifdef VIRTUAL_ROOT

/*

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

     */

# if !defined(IRIS) || defined(IRIX5)

    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;

}

#endif

%}

! !

!XWorkstation class methodsFor:'error handling'!

debug:aBoolean

%{  /* NOCONTEXT */

    __debug__ = (aBoolean == true) ? 1 : 0;

%}

!

requestCodeOfLastError

%{  /* NOCONTEXT */

    RETURN ( _MKSMALLINT(lastRequestCode) );

%}

!

minorCodeOfLastError

%{  /* NOCONTEXT */

    RETURN ( _MKSMALLINT(lastMinorCode) );

%}

!

resourceIdOfLastError

%{  /* NOCONTEXT */

    RETURN ( _MKSMALLINT(lastResource) );

%}

!

errorStringOfLastError

%{

    RETURN ( _MKSTRING(lastErrorMsg, __context) );

%}

!

    "return the last X-error string - 

     when buffering is on, this may be

     an error for a long-ago operation"

    |string requestCode s match line|

    string := self errorStringOfLastError.

    requestCode := self requestCodeOfLastError.

    "

     X specific: search the requestCode in '/usr/lib/X11/XErrorDB',

     and append the name of the corresponding X-request

    "

    s := '/usr/lib/X11/XErrorDB' asFilename readStream.

    s notNil ifTrue:[

	match := 'XRequest.' , requestCode printString.

	line := s peekForLineStartingWith:match.

	line notNil ifTrue:[

	    string := string , ' in ' , (line copyFrom:(line indexOf:$:)+1)

	].

	s close.

    ].

    ^ string

! !

!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 command line argument) or the name of the server 

     as hostname:number"

    |dpyName index|

    dpyName := aDisplayName.

    dpyName isNil ifTrue:[

	"look for a '-display xxx' argument"

	]

    ].

%{

    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, *nm;

    int dummy;

    if (_INST(displayId) != nil) {

	RETURN ( self );

    }

    BEGIN_INTERRUPTSBLOCKED

    if (__isString(dpyName))

	nm = (char *)_stringVal(dpyName);

    else

	nm = NULL;

    dpy = XOpenDisplay(nm);

    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

	_INST(hasShapeExtension) = false;

#ifdef SHM

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

	    _INST(hasShmExtension) = true;

	else

	_INST(hasShmExtension) = false;

#ifdef FAX

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

	    _INST(hasFaxExtension) = true;

	else

	_INST(hasFaxExtension) = false;

#ifdef DPS

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

	    _INST(hasDPSExtension) = true;

	else

	_INST(hasDPSExtension) = false;

	/*

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