"{ Encoding: utf8 }"

"

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' }"

"{ NameSpace: Smalltalk }"

DeviceGraphicsContext subclass:#X11GraphicsContext

	instanceVariableNames:'depth xftDrawId'

	classVariableNames:''

	poolDictionaries:''

	category:'Interface-Graphics'

!

!X11GraphicsContext primitiveDefinitions!

%{

#define SUPPORT_MOTIF_WM_HINTS

#ifdef LINUX

# ifndef __arm__

#  define SHM

# endif

#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

#include <stdio.h>

#if defined(__osx__)

# include <malloc/malloc.h>

extern void *malloc();

#else

# ifndef FREEBSD

#  include <malloc.h>

# endif

#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

extern OBJ __GLOBAL_GET_BY_NAME(char *);

# define __HANDLE_VAL(type, externalAddress) \

	((type)__externalAddressVal(externalAddress))

# define __HANDLE_NEW(ptr, __cls)                    \

	({                                           \

	    OBJ handle = __MKEXTERNALADDRESS(ptr);   \

	    OBJ clsObj = __GLOBAL_GET_BY_NAME(__cls);\

	    __InstPtr(handle)->o_class = clsObj;     \

	    __STORE(handle, clsObj);                 \

	    handle;                                  \

	})

/*

 * 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

/*

 * multiscreen extension - if available

 */

#ifdef XINERAMA

# include <X11/extensions/Xinerama.h>

#endif

/*

 * XCURSOR extension - if available

 */

#ifdef XCURSOR

# include <X11/Xcursor/Xcursor.h>

#endif

/*

 * xft library (based on RENDER extension) - if available

 */

#ifdef XFT

# include <X11/Xft/Xft.h>

# include <X11/extensions/Xrender.h>

# include <X11/extensions/render.h>

# define XFT_FONT(x)            __HANDLE_VAL(XftFont*, x)

# define XFT_FONT_HANDLE_NEW(x) __HANDLE_NEW(x, "XftFontDescription::XftFontHandle")

# define XFT_DRAW(x)            __HANDLE_VAL(XftDraw*, x)

# define XFT_DRAW_HANDLE_NEW(x) __HANDLE_NEW(x, "XftFontDescription::XftDrawHandle")

#endif // XFT

/*

 * 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

# define DISPLAY(x)    __HANDLE_VAL(Display*, x)

# define SCREEN(x)     ((int)(__intVal(x)))

# define DRAWABLE(x)   __HANDLE_VAL(Drawable, x)

# define GC(x)         __HANDLE_VAL(GC, x)

# define VISUAL(x)     __HANDLE_VAL(Visual*, x)

# define COLORMAP(x)   __HANDLE_VAL(Colormap, x)

/*

 * 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__ = whichTimeout; \

    } {

#define LEAVE_XLIB()   \

    { \

	__blockingPrimitiveTimoutHandler__ = (voidFUNC)0; \

	__blockingPrimitiveTimeoutArg__ = nil; \

	__blockingPrimitiveTimeout__ = 0; \

    } }

#define ENTER_XLIB()   __ENTER_XLIB(__intVal(__INST(xlibTimeout)) * 1000)

#define ENTER_XLIB2()  __ENTER_XLIB(__intVal(__INST(xlibTimeoutForWindowCreation)) * 1000)

#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 */

%}

! !

!X11GraphicsContext methodsFor:'accessing'!

depth

    ^ depth

!

xftDrawId

    ^ xftDrawId

! !

!X11GraphicsContext methodsFor:'destroying'!

destroy

    xftDrawId notNil ifTrue:[

	self destroyXftDrawId.

    ].

    super destroy.

!

destroyXftDrawId

    |id|

    id := xftDrawId.

    xftDrawId := nil.

%{

#ifdef XFT

    if (__isExternalAddress(id)) {

	XftDraw *address = (XftDraw *)__externalAddressVal(id);

	if (address) {

	    XftDrawDestroy(address);

	    __externalAddressVal(id) = 0;

	}

    }

#endif

%}.

! !

!X11GraphicsContext methodsFor:'displaying'!

displayDeviceString:aString from:index1 to:index2 x:x y:y opaque:opaque

    "draw a sub-string - if opaque is false, draw foreground only; otherwise, draw both

     foreground and background characters.

     If the coordinates are not integers, an error is triggered."

    <context: #return>

    |displayId|

    font isXftFont ifTrue:[

	self displayDeviceXftString:aString from:index1 to:index2 x:x y:y opaque:opaque.

	^ self.

    ].

    device flushIfAppropriate.

    displayId := device displayIdOrErrorIfBroken.

%{

    GC gc;

    Window win;

    char *cp;

    int  i1, i2, l, n;

#   define NLOCALBUFFER 200

    XChar2b xlatebuffer[NLOCALBUFFER];

    int nInstBytes;

    if (__isExternalAddress(displayId)

     && __isExternalAddress(__INST(gcId))

     && __isExternalAddress(__INST(drawableId))

     && __isNonNilObject(aString)

     && __bothSmallInteger(index1, index2)

     && __bothSmallInteger(x, y)) {

	int lMax = __intVal(@global(XWorkstation:MaxStringLength));

	Display *dpy = __DisplayVal(displayId);

	gc = __GCVal(__INST(gcId));

	win = __WindowVal(__INST(drawableId));

	i1 = __intVal(index1) - 1;

	if (i1 >= 0) {

	    OBJ cls;

	    i2 = __intVal(index2) - 1;

	    if (i2 < i1) {

		RETURN (self);

	    }

	    cp = (char *) __stringVal(aString);

	    l = i2 - i1 + 1;

	    if (__isStringLike(aString)) {

		n = __stringSize(aString);

		if (i2 < n) {

		    cp += i1;

		    if (l > lMax) l = lMax;

		    __ENTER_XLIB(1000 * __intVal(@global(XWorkstation:DefaultXLibTimeout)));

		    if (opaque == true)

			XDrawImageString(dpy, win, gc, __intVal(x), __intVal(y), cp, l);

		    else

			XDrawString(dpy, win, gc, __intVal(x), __intVal(y), cp, l);

		    LEAVE_XLIB();

		    RETURN ( self );

		}

	    }

	    cls = __qClass(aString);

	    nInstBytes = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));

	    cp += nInstBytes;

	    if (__isBytes(aString)) {

		n = __byteArraySize(aString) - nInstBytes - 1;

		if (i2 < n) {

		    cp += i1;

		    if (l > lMax) l = lMax;

		    __ENTER_XLIB(1000 * __intVal(@global(XWorkstation:DefaultXLibTimeout)));

		    if (opaque == true)

			XDrawImageString(dpy, win, gc, __intVal(x), __intVal(y), cp, l);

		    else

			XDrawString(dpy, win, gc, __intVal(x), __intVal(y), cp, l);

		    LEAVE_XLIB();

		    RETURN ( self );

		}

	    }

	    /* TWOBYTESTRINGS */

	    if (__isWords(aString)) {

		n = (__byteArraySize(aString) - nInstBytes) / 2;

		if (i2 < n) {

		    union {

			char b[2];

			unsigned short s;

		    } u;

		    int i;

		    XChar2b *cp2 = (XChar2b *)0;

		    int mustFree = 0;

		    cp += (i1 * 2);

		    if (l > lMax) l = lMax;

#if defined(MSBFIRST) || defined(__MSBFIRST)

		    /*

		     * chars already in correct order

		     */

#else

# if ! (defined(LSBFIRST) || defined(__LSBFIRST))

		    /*

		     * ST/X TwoByteStrings store the asciiValue in native byteOrder;

		     * X expects them MSB first

		     * convert as required

		     */

		    u.s = 0x1234;

		    if (u.b[0] != 0x12)

# endif  // ! (defined(LSBFIRST) || defined(__LSBFIRST))

		    {

			if (l <= NLOCALBUFFER) {

			    cp2 = xlatebuffer;

			} else {

			    cp2 = (XChar2b *)(malloc(l * 2));

			    mustFree = 1;

			}

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

			    cp2[i].byte1 = (((XChar2b *)cp)[i]).byte2;

			    cp2[i].byte2 = (((XChar2b *)cp)[i]).byte1;

			}

			cp = (char *) cp2;

		    }

#endif  // ! (defined(MSBFIRST) || defined(__MSBFIRST))

		    __ENTER_XLIB(1000 * __intVal(@global(XWorkstation:DefaultXLibTimeout)));

		    if (opaque == true)

			XDrawImageString16(dpy, win, gc, __intVal(x), __intVal(y), (XChar2b *)cp, l);

		    else

			XDrawString16(dpy, win, gc, __intVal(x), __intVal(y), (XChar2b *)cp, l);

		    LEAVE_XLIB();

		    if (mustFree) {

			free(cp2);

		    }

		    RETURN ( self );

		}

	    }

	    /* FOURBYTESTRINGS */

	    if (__isLongs(aString)) {

		n = (__byteArraySize(aString) - nInstBytes) / 4;

		if (i2 < n) {

		    union {

			char b[2];

			unsigned short s;

		    } u;

		    int i;

		    XChar2b *cp2 = (XChar2b *)0;

		    int32 *ip;

		    int mustFree = 0;

		    cp += (i1 * 4);

		    if (l > lMax) l = lMax;

		    /*

		     * all codePoints <= 16rFFFF are draw; above 16bit range are drawn as 16rFFFF.

		     */

		    if (l <= NLOCALBUFFER) {

			cp2 = xlatebuffer;

		    } else {

			cp2 = (XChar2b *)(malloc(l * 2));

			mustFree = 1;

		    }

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

			int32 codePoint = ((int32 *)cp)[i];

			if (codePoint > 0xFFFF) {

			    codePoint = 0xFFFF;

			}

			cp2[i].byte1 = (codePoint >> 8) & 0xFF;

			cp2[i].byte2 = codePoint & 0xFF;

		    }