"

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.

"

"{ Package: 'stx:libview' }"

DeviceWorkstation subclass:#XWorkstation

	instanceVariableNames:'hasShapeExtension hasShmExtension hasDPSExtension

		hasMbufExtension hasXVideoExtension hasSaveUnder hasPEXExtension

		hasImageExtension hasInputExtension ignoreBackingStore blackpixel

		whitepixel atoms protocolsAtom deleteWindowAtom saveYourselfAtom

		quitAppAtom primaryAtom clipboardAtom stringAtom wmStateAtom

		motifWMHintsAtom listOfXFonts buttonsPressed eventRootX

		eventRootY displayName eventTrace dispatchingExpose rgbVisual

		virtualRootId rootId altModifierMask metaModifierMask

		lastEventTime lastButtonPressTime deviceIOTimeoutErrorSignal

		activateOnClick rawKeySymTranslation selectionOwner selectionTime

		selectionFetchers selectionHandlers preWaitAction xlibTimeout

		xlibTimeoutForWindowCreation hasConnectionBroken uniqueDeviceID

		stxDeviceAtom uuidAtom'

	classVariableNames:'RawKeySymTranslation ConservativeSync MaxStringLength

		DefaultXLibTimeout DefaultXLibTimeoutForWindowCreation'

	poolDictionaries:''

	category:'Interface-Graphics'

!

Object subclass:#SelectionFetcher

	instanceVariableNames:'sema message display drawableID selectionID propertyID targetID

		buffer done incremental'

	classVariableNames:''

	poolDictionaries:''

	privateIn:XWorkstation

!

!XWorkstation primitiveDefinitions!

%{

#define SUPPORT_MOTIF_WM_HINTS

#ifdef LINUX

# define SHM

#endif

#define COUNT_RESOURCES

#ifdef COUNT_RESOURCES

static int __cnt_color = 0;

static int __cnt_bitmap = 0;

static int __cnt_view = 0;

static int __cnt_gc = 0;

static int __cnt_cursor = 0;

static int __cnt_font = 0;

#endif

/*

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

 */

#undef Time

#define Time XTime

/*

 * x does a #define True / False

 * we are lucky - the ST/X True/False are not needed

 */

#undef True

#undef False

#ifdef memset

# undef memset

#endif

#include <stdio.h>

#ifndef FREEBSD

# include <malloc.h>

#endif

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/Xatom.h>

#define XK_MISCELLANY

#include <X11/keysymdef.h>

#include <X11/cursorfont.h>

#ifdef LINUX

# include <sys/socket.h>

#endif

/*

 * this define suppresses XAllocColor/XFreeColor on

 * TrueColor systems - I am not certain, if this is

 * always legal to do (it works with XFree servers).

 */

#define QUICK_TRUE_COLORS

/*

 * shape support works; enabled by -DSHAPE in makefile

 * see RoundClock and RoundGlobe examples

 */

#ifdef SHAPE

# include <X11/extensions/shape.h>

#endif

/*

 * shared memory extension access is currently not supported

 * (only query is implemented)

 */

#ifdef SHM

# include <X11/extensions/XShm.h>

#endif

/*

 * multiBuffer extension access is currently not supported

 * (only query is implemented)

 */

#ifdef MBUF

# include <X11/extensions/multibuf.h>

#endif

/*

 * XVideo extension access is currently not supported

 * (only query is implemented)

 */

#ifdef XVIDEO

# include <X11/extensions/Xv.h>

#endif

/*

 * PEX extension - if available

 */

#ifdef PEX5

# include <PEX5/PEX.h>

#endif

/*

 * XImage extension - if available

 */

#ifdef XIE

# include <X11/extensions/XIE.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(someMachine)

/*

 * if nformats cannot be found in the Display structure ...

 */

# define NO_PRIVATE_DISPLAY_ACCESS

#endif

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

  /*

   * accessing private data in Display ... sorry

   */

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

#else

# define DISPLAYACCESS(d) d

#endif

/*

 * some defines - tired of typing ...

 */

#define __DisplayVal(o)      (Display *)(__externalAddressVal(o))

#define __DrawableVal(o)     (Drawable)(__externalAddressVal(o))

#define __WindowVal(o)       (Window)(__externalAddressVal(o))

#define __PixmapVal(o)       (Pixmap)(__externalAddressVal(o))

#define __GCVal(o)           (GC)(__externalAddressVal(o))

#define __CursorVal(o)       (Cursor)(__externalAddressVal(o))

#define __FontVal(o)         (XFontStruct *)(__externalAddressVal(o))

#define __DPSContextVal(o)   (DPSContext)(__externalAddressVal(o))

#define __MKATOMOBJ(a)       __MKSMALLINT(a)   /* add STORE macro if ever changed */

#define __AtomVal(o)         __intVal(o)

#define __isAtomID(o)        __isSmallInteger(o)

#define myDpy                __DisplayVal(__INST(displayId))

#define ISCONNECTED          ((__INST(displayId) != nil) && (__INST(hasConnectionBroken) != nil))

#ifdef __VMS__

# include "vms_Xnames.h"

#endif

void __XTimeoutErrorHandler();

int __XErrorHandler__();

int __XIOErrorHandler__();

/*

 * these two macros should be placed around X-lib calls,

 * which may block due to a broken connection.

 * They setup/remove a VM-timeout which raises an exception

 * after xlibTimeout seconds.

 * This exception will shutDown the connection.

 * Q: is this a good idea for the local display ?

 */

#define __ENTER_XLIB(whichTimeout)   \

    { \

        __blockingPrimitiveTimoutHandler__ = (VOIDFUNC)__XTimeoutErrorHandler; \

        __blockingPrimitiveTimeoutArg__ = self; \

        __blockingPrimitiveTimeout__ = __intVal(__INST(whichTimeout)) * 1000; \

    } {

#define LEAVE_XLIB()   \

    { \

        __blockingPrimitiveTimoutHandler__ = (VOIDFUNC)0; \

        __blockingPrimitiveTimeoutArg__ = nil; \

        __blockingPrimitiveTimeout__ = 0; \

    } }

#define ENTER_XLIB()   __ENTER_XLIB(xlibTimeout)

#define ENTER_XLIB2()  __ENTER_XLIB(xlibTimeoutForWindowCreation)

#ifdef SUPPORT_MOTIF_WM_HINTS

# ifdef SOME_MACHINE

#  include <anIncludeFileWhichDefinesTheStuffBelow>

# endif

# ifndef MWM_HINTS_FUNCTIONS

#  define MWM_HINTS_FUNCTIONS       (1L << 0)

#  define MWM_HINTS_DECORATIONS     (1L << 1)

#  define MWM_HINTS_INPUT_MODE      (1L << 2)

#  define MWM_HINTS_STATUS          (1L << 3)

#  define MWM_FUNC_ALL              (1L << 0)

#  define MWM_FUNC_RESIZE           (1L << 1)

#  define MWM_FUNC_MOVE             (1L << 2)

#  define MWM_FUNC_MINIMIZE         (1L << 3)

#  define MWM_FUNC_MAXIMIZE         (1L << 4)

#  define MWM_FUNC_CLOSE            (1L << 5)

#  define MWM_INPUT_MODELESS                      0

#  define MWM_INPUT_PRIMARY_APPLICATION_MODAL     1

#  define MWM_INPUT_SYSTEM_MODAL                  2

#  define MWM_INPUT_FULL_APPLICATION_MODAL        3

#  define MWM_DECOR_NONE            0

#  define MWM_DECOR_ALL             (1L << 0)

#  define MWM_DECOR_BORDER          (1L << 1)

#  define MWM_DECOR_RESIZEH         (1L << 2)

#  define MWM_DECOR_TITLE           (1L << 3)

#  define MWM_DECOR_MENU            (1L << 4)

#  define MWM_DECOR_MINIMIZE        (1L << 5)

#  define MWM_DECOR_MAXIMIZE        (1L << 6)

# endif

#endif /* SUPPORT_MOTIF_WM_HINTS */

/*

 * openlook hints are not supported yet

 * - noone needs them anymore ;-(

 */

#ifdef SUPPORT_OPENLOOCK_WM_HINTS

# ifdef SOME_MACHINE

#  include <anIncludeFileWhichDefinesTheStuffBelow>

# endif

# ifndef OL_DECOR_CLOSE

#  define OL_DECOR_CLOSE            (1L << 0)

#  define OL_DECOR_RESIZEH          (1L << 1)

#  define OL_DECOR_HEADER           (1L << 2)

#  define OL_DECOR_ICON_NAME        (1L << 3)

#  define OL_DECOR_ALL              (OL_DECOR_CLOSE | OL_DECOR_RESIZEH | OL_DECOR_HEADER | OL_DECOR_ICON_NAME)

#  define OL_ANY_HINTS              (1L << 7)

# endif

#endif /* SUPPORT_OPENLOOCK_WM_HINTS */

%}

! !

!XWorkstation primitiveVariables!

%{

/*

 * remembered info from private error handler

 */

static char lastErrorMsg[128] = "";

static unsigned INT lastRequestCode = 0;

static unsigned INT lastMinorCode = 0;

static unsigned INT lastResource = 0;

static int __debug__ = 0;

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

%}

! !

!XWorkstation primitiveFunctions!

%{

/*

 * some systems need a dummy reference to force the linker

 * to include that stuff. Should be #ifdef'd ...

 */

#ifndef ELF

# ifdef __GNUC__

VOLATILE

# endif

static

dummyToForceLoading() {

        XCreateSimpleWindow(0, 0, 0, 0, 0, 0, 0, 0, 0);

        XCloseDisplay(0);

        XCreateImage(0, 0, 0 ,0 ,0 ,0 ,0 ,0 ,0 ,0);

        XSetWindowColormap(0, 0, 0);

        XQueryColors(0,0,0,0);

# ifdef SHM

        XShmAttach(0, 0);

        XShmCreateImage(0, 0, 0, 0, 0, 0, 0 ,0);

        XShmDetach(0, 0);

        XShmPutImage(0, 0, 0, 0 , 0,0,0,0,0,0,0);

        shmctl(0,0,0);

        fgetc(0);

# endif

}

#endif

#undef __myInstPtr

#define __myInstPtr(obj) ((struct __XWorkstation_struct *)(obj))

/*

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

 */

int

__XErrorHandler__(dpy, event)

    Display *dpy;

    XErrorEvent *event;

{

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

    lastErrorMsg[127] = '\0';

    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(DeviceWorkstation:ErrorPrinting) == true) {

        console_fprintf(stderr, "XWorkstation [error]: x-error caught 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);

        console_fprintf(stderr, "XWorkstation [error]: x-error message is [%d] '%s'\n",

                        event->error_code, lastErrorMsg);

    }

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

    return 0;

}

/*

 * much like the above, but for IO Errors;

 * forwarded as errorInterrupt:#DisplayIOError,

 * In single display apps, handling those here does not

 * really make sense (except, for a controlled cleanup).

 * However, in multiDisplay apps, a single broken

 * connection should not affect the other users.

 */

int

__XIOErrorHandler__(dpy)

    Display *dpy;

{

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

        console_fprintf(stderr, "XWorkstation [error]: I/O error\n");

    }

    __immediateErrorInterruptWithIDAndParameter__(@symbol(DisplayIOError),

                                                  __MKEXTERNALADDRESS(dpy));

#if 0

    /*

     * don't do this.

     * This error is called asynchronously, and the wrong process may be terminated

     */

    /*

     * if we return from the error interrupt ...

     */

    __internalError("unhandled display I/O error");

    __terminateProcess(0);      /* soft terminate */

    __terminateProcess(1);      /* hard terminate */

    /* never reached */

#endif

    return 0;

}

/*

 * timeout error in case of Xlib request timeout.

 * forwarded as errorInterrupt:#DisplayIOTimeoutError,

 * This is generated synthetically by the VM if the

 * timeoutHandler has been set.

 */

void

__XTimeoutErrorHandler(displayDeviceInst)

    OBJ displayDeviceInst;

{

    if ((displayDeviceInst == @global(MainDisplay))

        || (displayDeviceInst == @global(DeviceWorkstation:DefaultScreen))) {

        console_fprintf(stderr, "XWorkstation [error]: keep display connection for master display after X11 timeout (no shutdown)\n");

        return;

    }

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

        console_fprintf(stderr, "XWorkstation [error]: X11 request timeout dpy=%x\n", displayDeviceInst);

    }

    __OINST(displayDeviceInst, hasConnectionBroken) = true;

    __PROTECT__(displayDeviceInst);

    __immediateErrorInterruptWithIDAndParameter__(@symbol(DisplayIOTimeoutError), displayDeviceInst);

    __UNPROTECT__(displayDeviceInst);

    /*

     * if we return from the error interrupt ...

     */

    if (__OINST(displayDeviceInst, displayId) != nil) {

        __internalError("unhandled X11 display timeout error");

        /*

         * the current process failed to do an X11 request.

         * Terminate it!

         */

        __terminateProcess(0);      /* soft terminate */

        __terminateProcess(1);      /* hard terminate */

    }

}

#ifdef VIRTUAL_ROOT

/*

 * added since RootWindow-macro is not sufficient

 * 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 = (Window *)0;

    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 (root) {

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

        if (vRootAtom != None) {

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

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

                    Atom actual_type;

                    int actual_format;