hg/stx-libview: comparison XWorkstation.st

equal deleted inserted replaced

-:3389ebfe886f
+:5d0b9d669832
 "
 DeviceWorkstation subclass:#XWorkstation
 instanceVariableNames:'screen
 			      hasShapeExtension hasFaxExtension hasShmExtension
-			      hasDPSExtension hasSaveUnder ignoreBackingStore
+			      hasDPSExtension hasMbufExtension hasXVideoExtension
+			      hasSaveUnder ignoreBackingStore
 			      blackpixel whitepixel redMask greenMask blueMask
 			      protocolsAtom deleteWindowAtom saveYourselfAtom
 			      quitAppAtom
 			      primaryAtom secondaryAtom cutBuffer0Atom
 			      stringAtom lengthAtom
 			      listOfXFonts buttonsPressed
 			      eventRootX eventRootY
 			      displayName eventTrace
 			      dispatchingExpose
-			      rgbVisual virtualRootId
+			      rgbVisual virtualRootId rootId
 			      eventBuffer'
 classVariableNames:   ''
 poolDictionaries:''
 category:'Interface-Graphics'
 !
 XWorkstation comment:'
 COPYRIGHT (c) 1989 by Claus Gittinger
 	      All Rights Reserved
-$Header: /cvs/stx/stx/libview/XWorkstation.st,v 1.45 1995-05-18 15:40:16 claus Exp $
+$Header: /cvs/stx/stx/libview/XWorkstation.st,v 1.46 1995-06-04 16:38:31 claus Exp $
 '!
 !XWorkstation class methodsFor:'documentation'!
 copyright
 "
 !
 version
 "
-$Header: /cvs/stx/stx/libview/XWorkstation.st,v 1.45 1995-05-18 15:40:16 claus Exp $
+$Header: /cvs/stx/stx/libview/XWorkstation.st,v 1.46 1995-06-04 16:38:31 claus Exp $
 "
 !
 documentation
 "
 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 ...
+See more documentation in my superclass, DeviceWorkstation.
 "
 ! !
 !XWorkstation primitiveDefinitions!
 #include <stdio.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
+#define XK_MISCELLANY
+#include <X11/keysymdef.h>
 /*
 * this define adds support for two-byte-strings.
 * leaving it undefined does not really save you much
 * (the define will vanish)
 #ifdef SHAPE
 # include <X11/extensions/shape.h>
 #endif
 /*
-* shared memory extension currently not supported
+* 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
 /*
 * this is a non-standard fax-image decompression extension
 * (only found in megascan servers ported by myself)
 #define _FontVal(o)          (XFontStruct *)(MKCP(o))
 #define _AtomVal(o)          (Atom)(MKCP(o))
 #define _DPSContextVal(o)    (DPSContext)(MKCP(o))
 #define myDpy _DisplayVal(_INST(displayId))
+#define ISCONNECTED (_INST(displayId) != nil)
 #ifndef THISCONTEXT_IN_REGISTER
 # define BLOCKINTERRUPTS()      /* */
 # define UNBLOCKINTERRUPTS()    /* */
 # define BEGIN_INTERRUPTSBLOCKED /* */
 	int needUnblock = 0;            \
 	extern OBJ __thisContext__;     \
 					\
 	__thisContext__ = __thisContext;\
 	if (!__interruptsBlocked) {     \
-	    BLOCKINTERRUPTS();          \
+	    __BLOCKINTERRUPTS();        \
 	    needUnblock = 1;            \
 	}
 # define END_INTERRUPTSBLOCKED          \
 	if (needUnblock) {              \
-	    UNBLOCKINTERRUPTS();        \
+	    __UNBLOCKINTERRUPTS();      \
 	}                               \
 	__thisContext__ = 0;            \
 }
 #endif
 #ifdef SHAPE
 	if (XShapeQueryExtension(dpy, &shapeEventBase, &shapeErrorBase))
 	    _INST(hasShapeExtension) = true;
 	else
 #endif
-	_INST(hasShapeExtension) = false;
+	  _INST(hasShapeExtension) = false;
 #ifdef SHM
 	if (XShmQueryExtension(dpy, &shmEventBase, &shmErrorBase))
 	    _INST(hasShmExtension) = true;
 	else
 #endif
-	_INST(hasShmExtension) = false;
+	  _INST(hasShmExtension) = false;
 #ifdef FAX
 	if (XFAXImageQueryExtension(dpy, &faxEventBase, &faxErrorBase))
 	    _INST(hasFaxExtension) = true;
 	else
 #endif
-	_INST(hasFaxExtension) = false;
+	  _INST(hasFaxExtension) = false;
 #ifdef DPS
 	if (XQueryExtension(dpy, "DPSExtension", &dummy, &dummy, &dummy))
 	    _INST(hasDPSExtension) = true;
 	else
 #endif
-	_INST(hasDPSExtension) = false;
+	  _INST(hasDPSExtension) = false;
+#ifdef XVIDEO
+	if (XQueryExtension(dpy, "XVideo", &dummy, &dummy, &dummy))
+	    _INST(hasXVideoExtension) = true;
+	else
+#endif
+	  _INST(hasXVideoExtension) = false;
+#ifdef MBUF
+	if (XQueryExtension(dpy, "Multi-Buffering", &dummy, &dummy, &dummy))
+	    _INST(hasMbufExtension) = true;
+	else
+#endif
+	  _INST(hasMbufExtension) = false;
 	/*
 	 * look for RGB visual
 	 */
 	nvi = 0;
 ].
 dispatching := false.
 dispatchingExpose := false.
 isSlow := false.
 shiftDown := false.
-controlDown := false.
+ctrlDown := false.
 metaDown := false.
 altDown := false.
 motionEventCompression := true.
 buttonsPressed := 0.
 displayName := dpyName.
 |sz|
 %{
 sz = _MKSMALLINT(sizeof(XEvent) + 100);
 %}.
-eventBuffer := ByteArray new:sz.
+eventBuffer isNil ifTrue:[
+	eventBuffer := ByteArray new:sz.
+].
 !
 initializeSpecialFlags
 "perform additional special server implementation flags"
 close
 "close down the connection to the X-server"
 %{  /* NOCONTEXT */
-if (_INST(displayId) != nil) {
+if (ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	XCloseDisplay(myDpy);
 	_INST(displayId) = nil;
 	END_INTERRUPTSBLOCKED
 }
 %}
 !
 reinitialize
-virtualRootId := nil.
+virtualRootId := rootId := nil.
 super reinitialize.
 dispatchingExpose := nil
 ! !
 !XWorkstation methodsFor:'misc'!
 setInputFocusTo:aWindowId revertTo:revertSymbol
 %{  /* NOCONTEXT */
 int arg;
-if (__isSmallInteger(aWindowId)) {
+if (__isSmallInteger(aWindowId) && ISCONNECTED) {
 	if (revertSymbol == @symbol(parent))
 	    arg = RevertToParent;
 	else if (revertSymbol == @symbol(root))
 	    arg = RevertToPointerRoot;
 	else
 unBuffered
 "make all drawing be sent immediately to the display"
 %{  /* NOCONTEXT */
-BEGIN_INTERRUPTSBLOCKED
+if (ISCONNECTED) {
-XSynchronize(myDpy, 1);
+	BEGIN_INTERRUPTSBLOCKED
-END_INTERRUPTSBLOCKED
+	XSynchronize(myDpy, 1);
+	END_INTERRUPTSBLOCKED
+}
 %}
 "Display unbuffered"
 !
 buffered
 "buffer drawing - do not send it immediately to the display"
 %{  /* NOCONTEXT */
-BEGIN_INTERRUPTSBLOCKED
+if (ISCONNECTED) {
-XSynchronize(myDpy, 0);
+	BEGIN_INTERRUPTSBLOCKED
-END_INTERRUPTSBLOCKED
+	XSynchronize(myDpy, 0);
+	END_INTERRUPTSBLOCKED
+}
 %}
 "Display buffered"
 !
 synchronizeOutput
 "send all buffered drawing to the display"
 %{  /* NOCONTEXT */
-BEGIN_INTERRUPTSBLOCKED
+if (ISCONNECTED) {
-XSync(myDpy, 0);
+	BEGIN_INTERRUPTSBLOCKED
-END_INTERRUPTSBLOCKED
+	XSync(myDpy, 0);
+	END_INTERRUPTSBLOCKED
+}
 %}
 !
 flushDpsContext:aDPSContext
 beep:volumeInPercent
 "output an audible beep"
 %{
 int volume;
-if (__isSmallInteger(volumeInPercent)) {
+if (__isSmallInteger(volumeInPercent) && ISCONNECTED) {
 	/* stupid: X wants -100 .. 100 and calls this percent */
 	volume = _intVal(volumeInPercent) * 2 - 100;
 	if (volume < -100) volume = -100;
 	else if (volume > 100) volume = 100;
 	BEGIN_INTERRUPTSBLOCKED
 displayFileDescriptor
 "return the displays fileNumber - for select"
 %{  /* NOCONTEXT */
-RETURN ( MKOBJ(ConnectionNumber(myDpy)) );
+if (ISCONNECTED) {
+	RETURN ( MKOBJ(ConnectionNumber(myDpy)) );
+}
+RETURN (nil);
 %}
 !
 displayName
 "return the X-connections display name.
 serverVendor
 "return the X-server vendor string - this should normally not be of
 any interrest, but can be for special cases
 (to avoid bugs in certain implementations)"
 %{
-RETURN ( _MKSTRING(XServerVendor(myDpy), __context) );
+if (ISCONNECTED) {
+	RETURN ( _MKSTRING(XServerVendor(myDpy), __context) );
+}
+RETURN (nil);
 %}
 "
 Display serverVendor
 "
 "return the X-servers vendor release - should normally not be of
 any interrest, but can be for special cases.
 (to avoid bugs in certain implementations)"
 %{  /* NOCONTEXT */
-RETURN ( _MKSMALLINT(XVendorRelease(myDpy)) );
+if (ISCONNECTED) {
+	RETURN ( _MKSMALLINT(XVendorRelease(myDpy)) );
+}
+RETURN (nil);
 %}
 "
 Display vendorRelease
 "
 protocolVersion
 "return the X-servers protocol version - should normally not be of
 any interrest"
 %{  /* NOCONTEXT */
-RETURN ( _MKSMALLINT(XProtocolVersion(myDpy)) );
+if (ISCONNECTED) {
+	RETURN ( _MKSMALLINT(XProtocolVersion(myDpy)) );
+}
+RETURN (nil);
 %}
 "
 Display protocolVersion
 "
 Display hasShape
 "
 !
 hasShm
-"return true, if this workstation supports shared pixmaps"
+"return true, if this workstation supports the shared pixmap extension"
 ^ hasShmExtension
 !
 hasFax
 hasDPS
 "return true, if this workstation supports display postscript"
 ^ hasDPSExtension
+!
+hasMultibuffer
+"return true, if this workstation supports the multibuffer extension"
+^ hasMbufExtension
+!
+hasXVideo
+"return true, if this workstation supports the XVideo extension"
+^ hasXVideoExtension
+!
+hasExtension:extensionString
+"query for an X extension. The argument, extensionString
+should be the name of the extension (i.e. 'SHAPE', 'XInputExtension' etc).
+Return true, if that extension is available."
+%{
+int dummy;
+if (__isString(extensionString) && ISCONNECTED) {
+	if (XQueryExtension(myDpy, __stringVal(extensionString), &dummy, &dummy, &dummy)) {
+	    RETURN ( true );
+	}
+}
+%}.
+^ false
 !
 supportedImageFormats
 "return an array with supported image formats; each array entry
 is another array, consisting of depth and bitsPerPixel values."
-|nFormats formatArray|
+|nFormats "{ Class: SmallInteger }"
+formatArray|
 %{
 Display *dpy = myDpy;
+if (! ISCONNECTED) {
+	RETURN (nil);
+}
 nFormats = _MKSMALLINT(DISPLAYACCESS(dpy)->nformats);
 %}.
 formatArray := Array new:nFormats.
-1 to:nFormats do:[:i |
+1 to:nFormats do:[:index |
-	|bitsPerPixelInfo depthInfo|
+	|bitsPerPixelInfo depthInfo i|
+	i := index.
 %{
 	ScreenFormat *format;
 	Display *dpy = myDpy;
 	format = DISPLAYACCESS(dpy)->pixmap_format;
 	format += (_intVal(i)-1);
 	bitsPerPixelInfo = _MKSMALLINT(format->bits_per_pixel);
 	depthInfo = _MKSMALLINT(format->depth);
 %}.
-	formatArray at:i put:(Array with:depthInfo with:bitsPerPixelInfo).
+	formatArray at:index put:(Array with:depthInfo with:bitsPerPixelInfo).
 ].
 ^ formatArray
 "
 Display supportedImageFormats
 "return a mask to enable some events by default."
 %{  /* NOCONTEXT */
 RETURN (_MKSMALLINT( ExposureMask | StructureNotifyMask |
 			 KeyPressMask | KeyReleaseMask |
+			 EnterWindowMask | LeaveWindowMask |
 			 ButtonPressMask | ButtonMotionMask | ButtonReleaseMask ));
 %}
 !
 viewIdFromPoint:aPoint in:windowId
 Display *dpy = myDpy;
 int screen = _intVal(_INST(screen));
 Pixmap newBitmap;
-if (__bothSmallInteger(w, h)) {
+if (__bothSmallInteger(w, h) && ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	newBitmap = XCreatePixmap(dpy, RootWindow(dpy, screen),
 				       _intVal(w), _intVal(h), 1);
 	END_INTERRUPTSBLOCKED
 	RETURN ( (newBitmap != (Pixmap)0) ? MKOBJ(newBitmap) : nil );
 Display *dpy = myDpy;
 int screen = _intVal(_INST(screen));
 Pixmap newBitmap;
-if (__bothSmallInteger(w, h)) {
+if (__bothSmallInteger(w, h) && ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	newBitmap = XCreatePixmap(dpy, RootWindow(dpy, screen),
 				       _intVal(w), _intVal(h), _intVal(d));
 	END_INTERRUPTSBLOCKED
 	RETURN ( (newBitmap != (Pixmap)0) ? MKOBJ(newBitmap) : nil );
 char *filename;
 unsigned b_width, b_height;
 int b_x_hot, b_y_hot;
 int status;
-if (__isString(aString) || __isSymbol(aString)) {
+if (ISCONNECTED) {
-	filename = (char *)_stringVal(aString);
+	if (__isString(aString) || __isSymbol(aString)) {
+	    filename = (char *)_stringVal(aString);
-	BEGIN_INTERRUPTSBLOCKED
-	status = XReadBitmapFile(dpy, RootWindow(dpy, screen),
+	    BEGIN_INTERRUPTSBLOCKED
-				 filename, &b_width, &b_height, &newBitmap,
+	    status = XReadBitmapFile(dpy, RootWindow(dpy, screen),
-				 &b_x_hot, &b_y_hot);
+				     filename, &b_width, &b_height, &newBitmap,
-	END_INTERRUPTSBLOCKED
+				     &b_x_hot, &b_y_hot);
+	    END_INTERRUPTSBLOCKED
-	if (status == BitmapSuccess) {
-	    w = _MKSMALLINT(b_width);
+	    if (status == BitmapSuccess) {
-	    h = _MKSMALLINT(b_height);
+		w = _MKSMALLINT(b_width);
-	    id = MKOBJ(newBitmap);
+		h = _MKSMALLINT(b_height);
+		id = MKOBJ(newBitmap);
+	    }
 	}
 }
 %}
 .
 id notNil ifTrue:[
 destroyPixmap:aDrawableId
 %{  /* NOCONTEXT */
-if (__isSmallInteger(aDrawableId)) {
+if (__isSmallInteger(aDrawableId) && ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	XFreePixmap(myDpy, _PixmapVal(aDrawableId));
 	END_INTERRUPTSBLOCKED
 	RETURN ( self );
 }
-%}
+%}.
-.
 self primitiveFailed
 !
 destroyFaxImage:aFaxImageId
 	XFAXImageFreeImage(myDpy, (FAXImage)_WindowVal(aFaxImageId));
 	END_INTERRUPTSBLOCKED
 	RETURN ( self );
 }
 #endif
-%}
+%}.
-.
+self primitiveFailed
-self primitiveFailed
+!
-!
+realRootWindowId
-realRootWindowFor:aView
+"return the id of the real root window.
-%{  /* NOCONTEXT */
+This may not be the window you see as background,
+since some window managers install a virtual root window on top
+of it. Except for very special cases, use #rootWindowId, which takes
+care of any virtual root."
+%{  /* NOCONTEXT */
 int screen = _intVal(_INST(screen));
 Window root;
-root = RootWindow(myDpy, screen);
+if (_INST(rootId) != nil) {
-if (! root) {
+	RETURN (_INST(rootId));
-	RETURN ( nil );
+}
-}
-RETURN( MKOBJ(root) );
+if (ISCONNECTED) {
-%}
+	root = RootWindow(myDpy, screen);
-!
+	if (! root) {
+	    RETURN ( nil );
-rootWindowFor:aView
+	}
-|id|
+	_INST(rootId) = MKOBJ(root);
-%{
+	RETURN (_INST(rootId));
+}
+%}.
+self primitiveFailed
+!
+rootWindowId
+"return the id of the root window.
+This is the window you see as background,
+however, it may or may not be the real physical root window,
+since some window managers install a virtual root window on top
+of the real one. If this is the case, that views id is returned here."
+%{  /* NOCONTEXT */
 int screen = _intVal(_INST(screen));
-Window root;
+Window rootWin, vRootWin;
-OBJ vRoot;
+if (_INST(virtualRootId) != nil) {
-vRoot = _INST(virtualRootId);
+	RETURN (_INST(virtualRootId));
-if (__isSmallInteger(vRoot)) {
+}
-	root = _WindowVal(vRoot);
-} else {
+if (ISCONNECTED) {
+	vRootWin = rootWin = RootWindow(myDpy, screen);
+#ifndef IRIS
 	BEGIN_INTERRUPTSBLOCKED
-	root = RootWindow(myDpy, screen);
-#ifndef IRIS
 	/*
 	 * on IRIS, this creates a badwindow error - why ?
 	 * children contains a funny window (000034)
 	 */
 	    int i;
 	    Window rootReturn, parentReturn;
 	    Window* children;
 	    unsigned int numChildren;
-	    if (XQueryTree(myDpy, root,
+	    if (XQueryTree(myDpy, rootWin,
 			   &rootReturn, &parentReturn,
 			   &children, &numChildren)) {
 		vRootAtom = XInternAtom(myDpy, "__SWM_VROOT", True );
 		if (vRootAtom != None) {
 		    for (i=0; i < numChildren; i++) {
 						     0L, 1L, False, XA_WINDOW,
 						     &actual_type, &actual_format,
 						     &nitems, &bytesafter,
 						     (unsigned char**) &newRoot
 						   ) == Success && newRoot) {
-				root = *newRoot;
+				vRootWin = *newRoot;
 				break;
 			    }
 			}
 		    }
 		    if (children) XFree( children );
 		}
 	    }
 	}
+	END_INTERRUPTSBLOCKED
 #endif
-	END_INTERRUPTSBLOCKED
+}
-}
-if (! root) {
+/* cannot happen */
-	RETURN ( nil );
+if (! vRootWin) {
-}
+	vRootWin = rootWin;
-id = _INST(virtualRootId) = MKOBJ(root);
+	if (! rootWin) {
-%}
+	    RETURN ( nil );
-.
+	}
+}
+_INST(rootId) = MKOBJ(rootWin);
+_INST(virtualRootId) = MKOBJ(vRootWin);
+RETURN ( _INST(virtualRootId) );
+%}
+!
+realRootWindowFor:aView
+"the name of this method is historic;
+- it will vanish"
+|id|
+id := self realRootWindowId.
+self addKnownView:aView withId:id.
+^ id
+!
+rootWindowFor:aView
+|id|
+id := self rootWindowId.
 self addKnownView:aView withId:id.
 ^ id
 !
 createWindowFor:aView left:xpos top:ypos width:wwidth height:wheight
 		 iconView:wiconView
 |xpos ypos wwidth wheight minWidth minHeight maxWidth maxHeight
 bColorId wsuperViewId wcursorId wiconId windowId
 weventMask wiconViewId bitGravity viewGravity vBgColor
-vBgForm deepForm preferedVisual preferedDepth|
+vBgForm deepForm preferredVisual preferredDepth|
+displayId isNil ifTrue:[
+	self primitiveFailed.
+	^ nil
+].
 origin notNil ifTrue:[
 	xpos := origin x.
 	ypos := origin y.
 ] ifFalse:[
 ].
 weventMask := aView eventMask.
 "/    bitGravity := aView bitGravity.
 "/    viewGravity := aView viewGravity.
-preferedVisual := aView preferedVisual.
+preferredVisual := aView preferredVisual.
-preferedDepth := aView preferedDepth.
+preferredDepth := aView preferredDepth.
 %{  /* STACK:16000 */
 Display *dpy = myDpy;
 int screen = _intVal(_INST(screen));
 Visual visual;
 #ifdef OLD
 /* these may not be disabled */
 xswa.event_mask |= ExposureMask | StructureNotifyMask |
 		       KeyPressMask | KeyReleaseMask |
+		       EnterWindowMask | LeaveWindowMask |
 		       ButtonPressMask | ButtonMotionMask | ButtonReleaseMask;
 #endif
 if (ioClass == InputOnly) {
 	bw = 0;
 	}
 	xswa.border_pixel = bd;
 }
 visual.visualid = CopyFromParent;
-if (__isSmallInteger(preferedDepth)) {
+if (__isSmallInteger(preferredDepth)) {
-	depth = _intVal(preferedDepth);
+	depth = _intVal(preferredDepth);
 }
 BEGIN_INTERRUPTSBLOCKED
-if (preferedVisual != nil) {
+if (preferredVisual != nil) {
 	XVisualInfo vi;
 	int cls;
-	if (preferedVisual == @symbol(StaticGray))
+	if (preferredVisual == @symbol(StaticGray))
 	    cls = StaticGray;
-	else if (preferedVisual == @symbol(GrayScale))
+	else if (preferredVisual == @symbol(GrayScale))
 	    cls = StaticGray;
-	else if (preferedVisual == @symbol(StaticColor))
+	else if (preferredVisual == @symbol(StaticColor))
 	    cls = StaticColor;
-	else if (preferedVisual == @symbol(PseudoColor))
+	else if (preferredVisual == @symbol(PseudoColor))
 	    cls = PseudoColor;
-	else if (preferedVisual == @symbol(TrueColor))
+	else if (preferredVisual == @symbol(TrueColor))
 	    cls = TrueColor;
-	else if (preferedVisual == @symbol(DirectColor))
+	else if (preferredVisual == @symbol(DirectColor))
 	    cls = DirectColor;
 	else
 	    cls = PseudoColor;
 	if (XMatchVisualInfo(dpy, screen, depth, cls, &vi)) {
 ^ windowId
 !
 destroyView:aView withId:aWindowId
 %{
-if (__isSmallInteger(aWindowId)) {
+if (__isSmallInteger(aWindowId) && ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	XDestroyWindow(myDpy, _WindowVal(aWindowId));
 	END_INTERRUPTSBLOCKED
 }
 %}
 !
 destroyGC:aGCId
 %{  /* NOCONTEXT */
-if (__isSmallInteger(aGCId)) {
+if (__isSmallInteger(aGCId) && ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	XFreeGC(myDpy, _GCVal(aGCId));
 	END_INTERRUPTSBLOCKED
 	RETURN ( self );
 }
 %{  /* NOCONTEXT */
 int screen = _intVal(_INST(screen));
 GC gc;
-if (__isSmallInteger(aDrawableId)) {
+if (__isSmallInteger(aDrawableId) && ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	gc = XCreateGC(myDpy, (Drawable)_WindowVal(aDrawableId),
 			      0L, (XGCValues *)0);
 	END_INTERRUPTSBLOCKED
 	RETURN ( gc ? MKOBJ(gc) : nil );
 #ifdef XXDPS
 int screen = _intVal(_INST(screen));
 DPSContext dps;
 int height;
-if (__bothSmallInteger(aDrawableId, aGCId)) {
+if (__bothSmallInteger(aDrawableId, aGCId) && ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	dps = XDPSCreateContext(myDpy, (Drawable)_WindowVal(aDrawableId),
 				       _GCVal(aGCId),
 				       0, height, 0, colormap, NULL, 0,
 				       XDPSDefaultTextBackstop,
 getResource:name class:cls
 %{
 char *rslt;
 if ((__isString(name) || __isSymbol(name))
-&& (__isString(cls) || __isSymbol(cls))) {
+&& (__isString(cls) || __isSymbol(cls))
+&& ISCONNECTED) {
 	BEGIN_INTERRUPTSBLOCKED
 	rslt = XGetDefault(myDpy, (char *)_stringVal(cls),
 				  (char *)_stringVal(name));
 	END_INTERRUPTSBLOCKED
 	RETURN (rslt ? _MKSTRING(rslt,  __context) : nil );
 Atom prop, type;
 Window window;
 unsigned int value;
 if (__bothSmallInteger(propertyID, typeID)
+&& ISCONNECTED
 && (__isString(anObject)
 	 || __isSmallInteger(anObject)
 	 || __isSymbol(anObject)
 	 || __isByteArray(anObject))) {
 %{  /* NOCONTEXT */
 Display *dpy = myDpy;
 Atom selection;
 Window window;
-if (__isSmallInteger(selectionID)) {
+if (__isSmallInteger(selectionID) && ISCONNECTED) {
 	window = XGetSelectionOwner(dpy, _AtomVal(selectionID));
 	if (window == None) {
 	    RETURN (nil);
 	}
 	RETURN (MKOBJ(window));
 "set the owner of a selection; return false if failed"
 %{  /* NOCONTEXT */
 Display *dpy = myDpy;
-if (__bothSmallInteger(aWindowId, selectionID)) {
+if (__bothSmallInteger(aWindowId, selectionID) && ISCONNECTED) {
 	XSetSelectionOwner(dpy, _AtomVal(selectionID), _WindowVal(aWindowId), CurrentTime);
 	if (XGetSelectionOwner(dpy, _AtomVal(selectionID)) != _WindowVal(aWindowId)) {
 	    RETURN (false);
 	}
 	RETURN (true);
 Display *dpy = myDpy;
 Atom sel_prop;
 char *cp;
 if (_isSmallInteger(aWindowId)
+&& ISCONNECTED
 && __bothSmallInteger(typeID, selectionID)) {
 	if (XGetSelectionOwner(dpy, _AtomVal(selectionID)) == None) {
 	    /*
 	     * no owner of primary selection
 	     */
 "return an Atoms ID; if create is true, create it if not already present"
 %{  /* NOCONTEXT */
 Atom prop;
-if (__isString(aStringOrSymbol)
+if (ISCONNECTED) {
-|| __isSymbol(aStringOrSymbol)) {
+	if (__isString(aStringOrSymbol)
-	prop = XInternAtom(myDpy, _stringVal(aStringOrSymbol),
+	 || __isSymbol(aStringOrSymbol)) {
-				  (create == true) ? False : True);
+	    prop = XInternAtom(myDpy, _stringVal(aStringOrSymbol),
-	if (prop == None) {
+				      (create == true) ? False : True);
-	    RETURN (nil);
+	    if (prop == None) {
-	}
+		RETURN (nil);
-	RETURN ( MKOBJ(prop) );
+	    }
+	    RETURN ( MKOBJ(prop) );
+	}
 }
 %}.
 self primitiveFailed.
 ^ nil
 %{  /* NOCONTEXT */
 Display *dpy = myDpy;
 if (__bothSmallInteger(propertyID, requestorID)
+&& ISCONNECTED
 && __bothSmallInteger(targetID, selectionID)) {
 	XEvent ev;
 	int requestor = (int)(_AtomVal(requestorID));
 	int property = (int)(_AtomVal(propertyID));
 	int target = (int)(_AtomVal(targetID));
 %{  /* NOCONTEXT */
 XFontStruct *newFont;
-if (__isString(aFontName) || __isSymbol(aFontName)) {
+if (ISCONNECTED) {
-	BEGIN_INTERRUPTSBLOCKED
+	if (__isString(aFontName) || __isSymbol(aFontName)) {
-	newFont = XLoadQueryFont(myDpy, (char *)_stringVal(aFontName));
+	    BEGIN_INTERRUPTSBLOCKED
-	END_INTERRUPTSBLOCKED
+	    newFont = XLoadQueryFont(myDpy, (char *)_stringVal(aFontName));
-	RETURN ( newFont ? MKOBJ(newFont) : nil );
+	    END_INTERRUPTSBLOCKED
+	    RETURN ( newFont ? MKOBJ(newFont) : nil );
+	}
 }
 %}
 .
 self primitiveFailed.
 ^ nil
 %{  /* NOCONTEXT */
 XFontStruct *f;
-if (__isSmallInteger(aFontId)) {
+if (ISCONNECTED) {
-	f = _FontVal(aFontId);
+	if (__isSmallInteger(aFontId)) {
-	BEGIN_INTERRUPTSBLOCKED
+	    f = _FontVal(aFontId);
-	XFreeFont(myDpy, f);
+	    BEGIN_INTERRUPTSBLOCKED
-	END_INTERRUPTSBLOCKED
+	    XFreeFont(myDpy, f);
-	RETURN ( self );
+	    END_INTERRUPTSBLOCKED
+	    RETURN ( self );
+	}
 }
 %}
 .
 self primitiveFailed
 !
 %{  /* NOCONTEXT */
 XFontStruct *f;
 char *cp;
 int len, n;
-#ifdef TWOBYTESTRINGS
-extern OBJ TwoByteString;
-#endif
 if (__isSmallInteger(aFontId)) {
 	f = _FontVal(aFontId);
 	if (__isString(aString) || __isSymbol(aString)) {
 	    n = _stringSize(aString);
 	    len = XTextWidth(f, cp, n);
 	    END_INTERRUPTSBLOCKED
 	    RETURN ( _MKSMALLINT(len) );
 	}
 #ifdef TWOBYTESTRINGS
-	if (__Class(aString) == TwoByteString) {
+	if (__Class(aString) == @global(TwoByteString)) {
 	    n = _byteArraySize(aString) / 2;
 	    cp = (char *) _stringVal(aString);
 	    BEGIN_INTERRUPTSBLOCKED
 	    len = XTextWidth16(f, (XChar2b *)cp, n);
 	    END_INTERRUPTSBLOCKED
 %{  /* NOCONTEXT */
 XFontStruct *f;
 char *cp;
 int len, n, i1, i2;
-#ifdef TWOBYTESTRINGS
-extern OBJ TwoByteString;
-#endif
 if (__bothSmallInteger(index1, index2)
 && __isSmallInteger(aFontId)) {
 	f = _FontVal(aFontId);
 	i1 = _intVal(index1) - 1;
 		END_INTERRUPTSBLOCKED
 		RETURN ( _MKSMALLINT(len) );
 	    }
 	}
 #ifdef TWOBYTESTRINGS
-	if (__Class(aString) == TwoByteString) {
+	if (__Class(aString) == @global(TwoByteString)) {
 	    cp = (char *) _stringVal(aString);
 	    n = _byteArraySize(aString) / 2;
 	    if ((i1 >= 0) && (i2 >= i1) && (i2 < n)) {
 		cp += (i1 * 2);
 		BEGIN_INTERRUPTSBLOCKED
 destroyCursor:aCursorId
 %{  /* NOCONTEXT */
-if (__isSmallInteger(aCursorId)) {
+if (ISCONNECTED) {
-	BEGIN_INTERRUPTSBLOCKED
+	if (__isSmallInteger(aCursorId)) {
-	XFreeCursor(myDpy, _CursorVal(aCursorId));
+	    BEGIN_INTERRUPTSBLOCKED
-	END_INTERRUPTSBLOCKED
+	    XFreeCursor(myDpy, _CursorVal(aCursorId));
-	RETURN ( self );
+	    END_INTERRUPTSBLOCKED
+	    RETURN ( self );
+	}
 }
 %}
 .
 self primitiveFailed
 !
 createCursorSourceForm:sourceForm maskForm:maskForm hotX:hx hotY:hy
 "create a cursor given 2 bitmaps (source, mask) and a hotspot"
 |id sourceId maskId|
+displayId isNil ifTrue:[
+	self primitiveFailed.
+	^ nil
+].
 sourceId := sourceForm id.
 maskId := maskForm id.
 %{
 Cursor newCursor;
 XColor fgColor, bgColor;
 createCursorShape:aShape
 "create a cursor given a shape-symbol"
 |number id|
+displayId isNil ifTrue:[
+	self primitiveFailed.
+	^ nil
+].
 number := self shapeNumberFromSymbol:aShape.
 %{
 Cursor newCursor;
 if (__isSmallInteger(number)) {
 pointerPosition
 "return the current pointer position in root-window coordinates"
 |xpos ypos|
 %{
 Display *dpy = myDpy;
 Window w;
 int screen = _intVal(_INST(screen));
 Window rootRet, childRet;
 Display *dpy = myDpy;
 unsigned long color;
 int screen = _intVal(_INST(screen));
-if (__isSmallInteger(colorIndex)) {
+if (__isSmallInteger(colorIndex) && ISCONNECTED) {
 	color = (long) _intVal(colorIndex);
 	BEGIN_INTERRUPTSBLOCKED
 	XFreeColors(dpy, DefaultColormap(dpy, screen), &color, 1, 0L);
 	END_INTERRUPTSBLOCKED
 	RETURN ( self );
 Display *dpy = myDpy;
 XColor ecolor;
 int screen = _intVal(_INST(screen));
 Status ok;
-if (__bothSmallInteger(r, g) && __isSmallInteger(b)) {
+if (__bothSmallInteger(r, g)
+&& __isSmallInteger(b)
+&& ISCONNECTED) {
 	ecolor.red = _intVal(r);
 	ecolor.green= _intVal(g);
 	ecolor.blue = _intVal(b);
 	BEGIN_INTERRUPTSBLOCKED
 	ok = XAllocColor(dpy, DefaultColormap(dpy, screen), &ecolor);
 Display *dpy = myDpy;
 XColor scolor, ecolor;
 int screen =_intVal(_INST(screen));
 Status ok;
-if (__isString(aString) || __isSymbol(aString)) {
+if (ISCONNECTED) {
-	colorname = (char *)_stringVal(aString);
+	if (__isString(aString) || __isSymbol(aString)) {
+	    colorname = (char *)_stringVal(aString);
-	BEGIN_INTERRUPTSBLOCKED
-	ok = XParseColor(dpy, DefaultColormap(dpy, screen), colorname, &ecolor);
+	    BEGIN_INTERRUPTSBLOCKED
-	if (ok) {
+	    ok = XParseColor(dpy, DefaultColormap(dpy, screen), colorname, &ecolor);
-	    ok = XAllocColor(dpy, DefaultColormap(dpy, screen), &ecolor);
+	    if (ok) {
-	}
+		ok = XAllocColor(dpy, DefaultColormap(dpy, screen), &ecolor);
-	END_INTERRUPTSBLOCKED
+	    }
-	if (! ok) {
+	    END_INTERRUPTSBLOCKED
-	    RETURN ( nil );
+	    if (! ok) {
-	}
+		RETURN ( nil );
-	RETURN ( _MKSMALLINT(ecolor.pixel) );
+	    }
+	    RETURN ( _MKSMALLINT(ecolor.pixel) );
+	}
 }
 %}
 .
 self primitiveFailed.
 ^ nil
 getRGBFromName:colorName into:aBlock
 "get rgb components (0..100) of color named colorName,
 and evaluate the 3-arg block, aBlock with them"
 |r g b|
+displayId isNil ifTrue:[
+	self pimitiveFailed.
+	^ nil
+].
 %{
 Display *dpy = myDpy;
 int screen = _intVal(_INST(screen));
 XColor color;
 double fr, fg, fb;
 GC gc = _GCVal(aGCId);
 Window win = _WindowVal(aDrawableId);
 unsigned char *cp;
 int n;
 OBJ cls;
-#ifdef TWOBYTESTRINGS
-extern OBJ TwoByteString;
-#endif
 if (__bothSmallInteger(aGCId, aDrawableId)
 && __isNonNilObject(aString)
 && __bothSmallInteger(x, y)) {
 	cls = __qClass(aString);
 	    else
 		XDrawString(myDpy, win, gc, _intVal(x), _intVal(y), (char *)cp, n);
 	    RETURN ( self );
 	}
 #ifdef TWOBYTESTRINGS
-	if (cls == TwoByteString) {
+	if (cls == @global(TwoByteString)) {
 	    cp = _stringVal(aString);
 	    n = _byteArraySize(aString) / 2;
 	    if (n > 1000) n = 1000;
 	    if (opaque == true)
 		XDrawImageString16(myDpy, win, gc, _intVal(x), _intVal(y), (XChar2b *)cp, n);
 GC gc = _GCVal(aGCId);
 Window win = _WindowVal(aDrawableId);
 unsigned char *cp;
 OBJ cls;
 int  i1, i2, l, n;
-#ifdef TWOBYTESTRINGS
-extern OBJ TwoByteString;
-#endif
 if (__bothSmallInteger(aGCId, aDrawableId)
 && __isNonNilObject(aString)
 && __bothSmallInteger(index1, index2)
 && __bothSmallInteger(x, y)) {
 		}
 		RETURN ( self );
 	    }
 	}
 #ifdef TWOBYTESTRINGS
-	if (cls == TwoByteString) {
+	if (cls == @global(TwoByteString)) {
 	    i1 = _intVal(index1) - 1;
 	    i2 = _intVal(index2) - 1;
 	    n = _byteArraySize(aString) / 2;
 	    cp = _stringVal(aString);
 	    if ((i1 >= 0) && (i2 < n)) {
 #ifdef OLD
 	/* these may not be disabled */
 	mask |= ExposureMask | StructureNotifyMask |
 		KeyPressMask | KeyReleaseMask |
+		EnterWindowMask | LeaveWindowMask |
 		ButtonPressMask | ButtonMotionMask | ButtonReleaseMask;
 #endif
 	XSelectInput(myDpy, _WindowVal(aWindowId), mask);
 	RETURN ( self );
 Display *dpy = myDpy;
 Window win, wWanted;
 int evMask;
 OBJ eB;
 XEvent *ev;
+if (! ISCONNECTED) {
+	RETURN (false);
+}
 eB = _INST(eventBuffer);
 if (__isByteArray(eB)) {
 	ev = (XEvent *)(_ByteArrayInstPtr(eB)->ba_element);
 } else {
 int i, nchars;
 char *keySymString;
 char keySymStringBuffer[32];
 static unsigned multiClickTime = 0;
 unsigned nextMultiClickTime;
+OBJ upDown;
 struct inlineCache *ipS;
 static struct inlineCache vid = _ILC1;
 static struct inlineCache expS = _ILC5;
 switch (ev->type) {
 	case KeyRelease:
 	    symS = @symbol(keyRelease:x:y:view:);
 	    ipS = &skrS;
+	    upDown = false;
 	    goto keyPressAndRelease;
-	    break;
 	case KeyPress:
 	    symS = @symbol(keyPress:x:y:view:);
 	    ipS = &skpS;
+	    upDown = true;
+	    /* FALL INTO */
 	keyPressAndRelease:
 	    _INST(eventRootX) = _MKSMALLINT(ke->x_root);
 	    _INST(eventRootY) = _MKSMALLINT(ke->y_root);
 	    _INST(altDown) = (ke->state & Mod2Mask) ? true : false;
 	    _INST(metaDown) = (ke->state & Mod1Mask) ? true : false;
 	    _INST(shiftDown) = (ke->state & ShiftMask) ? true : false;
-	    _INST(controlDown) = (ke->state & ControlMask) ? true : false;
+	    _INST(ctrlDown) = (ke->state & ControlMask) ? true : false;
 	    arg = nil;
 	    nchars = XLookupString(ke, (char *)buffer, sizeof(buffer), &keySym, NULL);
 	    if (nchars
 	     && (((buffer[0] >= ' ') && (buffer[0] <= '~'))
 		 || (buffer[0] >= 0x80))) {
 		arg = _MKCHARACTER(buffer[0])/* *_CharacterTable[buffer[0]] */;
 		keySymString = NULL;
 	    } else {
+		switch (keySym) {
+		    case XK_Control_L:
+		    case XK_Control_R:
+			_INST(ctrlDown) = upDown;
+			break;
+		    case XK_Shift_L:
+		    case XK_Shift_R:
+			_INST(shiftDown) = upDown;
+			break;
+		    case XK_Meta_L:
+		    case XK_Meta_R:
+			_INST(metaDown) = upDown;
+			break;
+		    case XK_Alt_L:
+		    case XK_Alt_R:
+			_INST(altDown) = upDown;
+			break;
+		}
 		keySymString = XKeysymToString(keySym);
 		if (keySymString) {
 		    if (keySymString[0] == 'D') {
 			/*
 			 * remove underscore, dont want it in symbols
 	    }
 	    _INST(eventRootX) = _MKSMALLINT(me->x_root);
 	    _INST(eventRootY) = _MKSMALLINT(me->y_root);
+	    _INST(altDown) = (me->state & Mod2Mask) ? true : false;
+	    _INST(metaDown) = (me->state & Mod1Mask) ? true : false;
+	    _INST(shiftDown) = (me->state & ShiftMask) ? true : false;
+	    _INST(ctrlDown) = (me->state & ControlMask) ? true : false;
 	    (*motS.ilc_func)(self,
 			     @symbol(buttonMotion:x:y:view:)
 			     COMMA_CON, nil, &motS,
 			     _MKSMALLINT(me->state),
 			     _MKSMALLINT(me->x),
 				COMMA_CON, nil, &focOutS,
 				theView);
 	    break;
 	case EnterNotify:
+	    _INST(altDown) = (ewe->state & Mod2Mask) ? true : false;
+	    _INST(metaDown) = (ewe->state & Mod1Mask) ? true : false;
+	    _INST(shiftDown) = (ewe->state & ShiftMask) ? true : false;
+	    _INST(ctrlDown) = (ewe->state & ControlMask) ? true : false;
 	    (*peS.ilc_func)(self,
 			    @symbol(pointerEnter:x:y:view:)
 			    COMMA_CON, nil, &peS,
 			    _MKSMALLINT(ewe->state),
 			    _MKSMALLINT(ewe->x),
 %{  /* UNLIMITEDSTACK */
 Display *dpy = myDpy;
-XSync(dpy, 0);      /* make certain everything is flushed */
+if (ISCONNECTED) {
-RETURN ( (XPending(dpy)) ? true : false );
+	XSync(dpy, 0);      /* make certain everything is flushed */
+	if (XPending(dpy)) {
+	    RETURN (true);
+	}
+}
+RETURN ( false );
 %}
 !
 eventPendingWithoutSync
 "return true, if any event is pending."
 %{  /* UNLIMITEDSTACK */
-RETURN ( (XPending(myDpy)) ? true : false );
+if (ISCONNECTED) {
+	if (XPending(myDpy)) {
+	    RETURN (true);
+	}
+}
+RETURN ( false );
 %}
 !
 exposeEventPendingFor:aWindowIdOrNil
 "return true, if any expose event is pending"
 Display *dpy = myDpy;
 XEvent ev;
 Window win;
 int thereIsOne;
-XSync(dpy, 0);      /* make certain everything is flushed */
+if (ISCONNECTED) {
-if (__isSmallInteger(aWindowIdOrNil)) {
+	XSync(dpy, 0);      /* make certain everything is flushed */
-	win = _WindowVal(aWindowIdOrNil);
+	if (__isSmallInteger(aWindowIdOrNil)) {
-	thereIsOne = XCheckWindowEvent(dpy, win, ExposureMask, &ev);
+	    win = _WindowVal(aWindowIdOrNil);
-} else {
+	    thereIsOne = XCheckWindowEvent(dpy, win, ExposureMask, &ev);
-	thereIsOne = XCheckMaskEvent(dpy, ExposureMask, &ev);
+	} else {
-}
+	    thereIsOne = XCheckMaskEvent(dpy, ExposureMask, &ev);
-if (thereIsOne) {
+	}
-	XPutBackEvent(dpy, &ev);
+	if (thereIsOne) {
-	RETURN ( true );
+	    XPutBackEvent(dpy, &ev);
+	    RETURN ( true );
+	}
 }
 RETURN ( false );
 %}
 !
 Display *dpy = myDpy;
 XEvent ev;
 Window win;
 int thereIsOne;
-if (__isSmallInteger(anEventMask)) {
+if (ISCONNECTED && __isSmallInteger(anEventMask)) {
 	XSync(dpy, 0);      /* make certain everything is flushed */
 	if (__isSmallInteger(aWindowIdOrNil)) {
 	    win = _WindowVal(aWindowIdOrNil);
 	    thereIsOne = XCheckWindowEvent(dpy, win, _intVal(anEventMask), &ev);
 	} else {

changeset 150	5d0b9d669832
parent 146	8fdc30b8e8b1
child 152	17cc0709e898