spaf@PURDUE.EDU (Gene Spafford) (12/23/88)
Index:
Sun 3/60, SunOS 3.4, gcc 1.32
Problem:
compiling the enclosed source with the flags
-traditional -m68881 -O -finline-functions
causes a signal 11. Removing the "-finline-functions" results in
a complete compile.
Stack traceback:
Script started on Thu Dec 22 14:45:16 1988
uther(158)> dbx /u17/serc/lib/gcc-cc1 core
Reading symbolic information...
Read 48501 symbols
(dbx) where
copy_rtx(orig = 0x1), line 192 in "rtl.c"
copy_substitutions(), line 717 in "combine.c"
try_combine(i3 = 0xed2b0, i2 = 0xed0b0, i1 = (nil)), line 613 in "combine.c"
combine_instructions(f = (nil), nregs = 95), line 261 in "combine.c"
rest_of_compilation(decl = 0xed290), line 1341 in "toplev.c"
finish_function(), line 3433 in "c-decl.c"
yyparse(), line 244 in "bison.simple"
compile_file(name = (nil)), line 968 in "toplev.c"
main(argc = 14, argv = 0xed290, envp = 0xefffad8), line 1695 in "toplev.c"
(dbx) quit
uther(159)>
script done on Thu Dec 22 14:46:04 1988
Source code (after gcc -E):
# 1 "events.c"
# 1 "../../X11/X.h"
typedef unsigned long XID;
typedef XID Window;
typedef XID Drawable;
typedef XID Font;
typedef XID Pixmap;
typedef XID Cursor;
typedef XID Colormap;
typedef XID GContext;
typedef XID KeySym;
typedef unsigned long Mask;
typedef unsigned long Atom;
typedef unsigned long VisualID;
typedef unsigned long Time;
typedef unsigned char KeyCode;
# 311 "../../X11/X.h"
# 28 "events.c"
# 1 "../include/misc.h"
extern unsigned long globalSerialNumber;
typedef unsigned char *pointer;
typedef int Bool;
typedef unsigned long PIXEL;
typedef unsigned long ATOM;
# 1 "../include/os.h"
# 1 "../include/misc.h"
# 117 "../include/misc.h"
# 29 "../include/os.h"
typedef pointer FID;
typedef struct _FontPathRec *FontPathPtr;
typedef struct _NewClientRec *NewClientPtr;
# 69 "../include/os.h"
# 87 "../include/os.h"
# 97 "../include/os.h"
char *ReadRequestFromClient();
char *strcat();
char *strncat();
char *strcpy();
char *strncpy();
Bool CloseDownConnection();
FontPathPtr GetFontPath();
FontPathPtr ExpandFontNamePattern();
FID FiOpenForRead();
void CreateWellKnownSockets();
void SetDefaultFontPath();
void FreeFontRecord();
void SetFontPath();
void ErrorF();
void Error();
void FatalError();
void ProcessCommandLine();
void Xfree();
void FlushAllOutput();
void FlushIfCriticalOutputPending();
unsigned long *Xalloc();
unsigned long *Xrealloc();
long GetTimeInMillis();
# 58 "../include/misc.h"
typedef struct _DDXPoint *DDXPointPtr;
typedef struct _Box *BoxPtr;
# 29 "events.c"
# 1 "../include/resource.h"
# 1 "../include/misc.h"
# 117 "../include/misc.h"
# 27 "../include/resource.h"
unsigned short CreateNewResourceType();
short CreateNewResourceClass();
unsigned long FakeClientID();
void AddResource();
void FreeResource();
void FreeClientResources();
pointer LookupID();
# 30 "events.c"
# 1 "../../X11/Xproto.h"
# 1 "../../X11/Xmd.h"
typedef long INT32;
typedef short INT16;
typedef char INT8;
typedef unsigned long CARD32;
typedef unsigned short CARD16;
typedef unsigned char CARD8;
typedef unsigned long BITS32;
typedef unsigned short BITS16;
typedef unsigned char BYTE;
typedef unsigned char BOOL;
# 53 "../../X11/Xproto.h"
# 1 "../../X11/Xprotostr.h"
# 1 "../../X11/Xmd.h"
# 139 "../../X11/Xmd.h"
# 28 "../../X11/Xprotostr.h"
typedef struct _xSegment {
INT16 x1 , y1 , x2 , y2 ;
} xSegment;
typedef struct _xPoint {
INT16 x , y ;
} xPoint;
typedef struct _xRectangle {
INT16 x , y ;
CARD16 width , height ;
} xRectangle;
typedef struct _xArc {
INT16 x , y ;
CARD16 width , height ;
INT16 angle1 , angle2 ;
} xArc;
# 54 "../../X11/Xproto.h"
typedef CARD16 KeyButMask;
typedef struct {
CARD8 byteOrder;
BYTE pad;
CARD16 majorVersion , minorVersion ;
CARD16 nbytesAuthProto ;
CARD16 nbytesAuthString ;
CARD16 pad2;
} xConnClientPrefix;
typedef struct {
BOOL success;
BYTE lengthReason;
CARD16 majorVersion ,
minorVersion ;
CARD16 length ;
} xConnSetupPrefix;
typedef struct {
CARD32 release ;
CARD32 ridBase ,
ridMask ;
CARD32 motionBufferSize ;
CARD16 nbytesVendor ;
CARD16 maxRequestSize ;
CARD8 numRoots;
CARD8 numFormats;
CARD8 imageByteOrder;
CARD8 bitmapBitOrder;
CARD8 bitmapScanlineUnit,
bitmapScanlinePad;
CARD8 minKeyCode, maxKeyCode;
CARD32 pad2 ;
} xConnSetup;
typedef struct {
CARD8 depth;
CARD8 bitsPerPixel;
CARD8 scanLinePad;
CARD8 pad1;
CARD32 pad2 ;
} xPixmapFormat;
typedef struct {
CARD8 depth;
CARD8 pad1;
CARD16 nVisuals ;
CARD32 pad2 ;
} xDepth;
typedef struct {
CARD32 visualID ;
CARD8 class;
CARD8 bitsPerRGB;
CARD16 colormapEntries ;
CARD32 redMask , greenMask , blueMask ;
CARD32 pad ;
} xVisualType;
typedef struct {
CARD32 windowId ;
CARD32 defaultColormap ;
CARD32 whitePixel , blackPixel ;
CARD32 currentInputMask ;
CARD16 pixWidth , pixHeight ;
CARD16 mmWidth , mmHeight ;
CARD16 minInstalledMaps , maxInstalledMaps ;
CARD32 rootVisualID ;
CARD8 backingStore;
BOOL saveUnders;
CARD8 rootDepth;
CARD8 nDepths;
} xWindowRoot;
typedef struct {
CARD32 time ;
INT16 x , y ;
} xTimecoord;
typedef struct {
CARD8 family;
BYTE pad;
CARD16 length ;
} xHostEntry;
typedef struct {
INT16 leftSideBearing ,
rightSideBearing ,
characterWidth ,
ascent ,
descent ;
CARD16 attributes ;
} xCharInfo;
typedef struct {
CARD32 name ;
CARD32 value ;
} xFontProp;
typedef struct {
CARD8 len;
INT8 delta;
} xTextElt;
typedef struct {
CARD32 pixel ;
CARD16 red , green , blue ;
CARD8 flags;
CARD8 pad;
} xColorItem;
typedef struct {
CARD16 red , green , blue , pad ;
} xrgb;
typedef CARD8 KEYCODE;
typedef struct {
BYTE type;
BYTE data1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 data00 ;
CARD32 data01 ;
CARD32 data02 ;
CARD32 data03 ;
CARD32 data04 ;
CARD32 data05 ;
} xGenericReply;
typedef struct {
BYTE type;
CARD8 backingStore;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 visualID ;
CARD16 class ;
CARD8 bitGravity;
CARD8 winGravity;
CARD32 backingBitPlanes ;
CARD32 backingPixel ;
BOOL saveUnder;
BOOL mapInstalled;
CARD8 mapState;
BOOL override;
CARD32 colormap ;
CARD32 allEventMasks ;
CARD32 yourEventMask ;
CARD16 doNotPropagateMask ;
CARD16 pad ;
} xGetWindowAttributesReply;
typedef struct {
BYTE type;
CARD8 depth;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 root ;
INT16 x , y ;
CARD16 width , height ;
CARD16 borderWidth ;
CARD16 pad1 ;
CARD32 pad2 ;
CARD32 pad3 ;
} xGetGeometryReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 root , parent ;
CARD16 nChildren ;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
} xQueryTreeReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 atom ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
} xInternAtomReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nameLength ;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xGetAtomNameReply;
typedef struct {
BYTE type;
CARD8 format;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 propertyType ;
CARD32 bytesAfter ;
CARD32 nItems ;
CARD32 pad1 ;
CARD32 pad2 ;
CARD32 pad3 ;
} xGetPropertyReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nProperties ;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xListPropertiesReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 owner ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
} xGetSelectionOwnerReply;
typedef struct {
BYTE type;
BYTE status;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 pad1 ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
} xGrabPointerReply;
typedef xGrabPointerReply xGrabKeyboardReply;
typedef struct {
BYTE type;
BOOL sameScreen;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 root , child ;
INT16 rootX , rootY , winX , winY ;
CARD16 mask ;
CARD16 pad1 ;
CARD32 pad ;
} xQueryPointerReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 nEvents ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
} xGetMotionEventsReply;
typedef struct {
BYTE type;
BOOL sameScreen;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 child ;
INT16 dstX , dstY ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
} xTranslateCoordsReply;
typedef struct {
BYTE type;
CARD8 revertTo;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 focus ;
CARD32 pad1 ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
} xGetInputFocusReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
BYTE map[32];
} xQueryKeymapReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
xCharInfo minBounds;
CARD32 walign1 ;
xCharInfo maxBounds;
CARD32 walign2 ;
CARD16 minCharOrByte2 , maxCharOrByte2 ;
CARD16 defaultChar ;
CARD16 nFontProps ;
CARD8 drawDirection;
CARD8 minByte1, maxByte1;
BOOL allCharsExist;
INT16 fontAscent , fontDescent ;
CARD32 nCharInfos ;
} xQueryFontReply;
typedef struct {
BYTE type;
CARD8 drawDirection;
CARD16 sequenceNumber ;
CARD32 length ;
INT16 fontAscent , fontDescent ;
INT16 overallAscent , overallDescent ;
INT32 overallWidth , overallLeft , overallRight ;
CARD32 pad ;
} xQueryTextExtentsReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nFonts ;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xListFontsReply;
typedef struct {
BYTE type;
CARD8 nameLength;
CARD16 sequenceNumber ;
CARD32 length ;
xCharInfo minBounds;
CARD32 walign1 ;
xCharInfo maxBounds;
CARD32 walign2 ;
CARD16 minCharOrByte2 , maxCharOrByte2 ;
CARD16 defaultChar ;
CARD16 nFontProps ;
CARD8 drawDirection;
CARD8 minByte1, maxByte1;
BOOL allCharsExist;
INT16 fontAscent , fontDescent ;
CARD32 nReplies ;
} xListFontsWithInfoReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nPaths ;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xGetFontPathReply;
typedef struct {
BYTE type;
CARD8 depth;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 visual ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xGetImageReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nColormaps ;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xListInstalledColormapsReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 red , green , blue ;
CARD16 pad2 ;
CARD32 pixel ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
} xAllocColorReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 pixel ;
CARD16 exactRed , exactGreen , exactBlue ;
CARD16 screenRed , screenGreen , screenBlue ;
CARD32 pad2 ;
CARD32 pad3 ;
} xAllocNamedColorReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nPixels , nMasks ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xAllocColorCellsReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nPixels ;
CARD16 pad2 ;
CARD32 redMask , greenMask , blueMask ;
CARD32 pad3 ;
CARD32 pad4 ;
} xAllocColorPlanesReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nColors ;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xQueryColorsReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 exactRed , exactGreen , exactBlue ;
CARD16 screenRed , screenGreen , screenBlue ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
} xLookupColorReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 width , height ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xQueryBestSizeReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
BOOL present;
CARD8 major_opcode;
CARD8 first_event;
CARD8 first_error;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xQueryExtensionReply;
typedef struct {
BYTE type;
CARD8 nExtensions;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xListExtensionsReply;
typedef struct {
BYTE type;
CARD8 success;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xSetMappingReply;
typedef xSetMappingReply xSetPointerMappingReply;
typedef xSetMappingReply xSetModifierMappingReply;
typedef struct {
BYTE type;
CARD8 nElts;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xGetPointerMappingReply;
typedef struct {
BYTE type;
CARD8 keySymsPerKeyCode;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xGetKeyboardMappingReply;
typedef struct {
BYTE type;
CARD8 numKeyPerModifier;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 pad1 ;
CARD32 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
} xGetModifierMappingReply;
typedef struct {
BYTE type;
BOOL globalAutoRepeat;
CARD16 sequenceNumber ;
CARD32 length ;
CARD32 ledMask ;
CARD8 keyClickPercent, bellPercent;
CARD16 bellPitch , bellDuration ;
CARD16 pad ;
BYTE map[32];
} xGetKeyboardControlReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 accelNumerator , accelDenominator ;
CARD16 threshold ;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
} xGetPointerControlReply;
typedef struct {
BYTE type;
BYTE pad1;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 timeout , interval ;
BOOL preferBlanking;
BOOL allowExposures;
CARD16 pad2 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
} xGetScreenSaverReply;
typedef struct {
BYTE type;
BOOL enabled;
CARD16 sequenceNumber ;
CARD32 length ;
CARD16 nHosts ;
CARD16 pad1 ;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xListHostsReply;
typedef struct {
BYTE type;
BYTE errorCode;
CARD16 sequenceNumber ;
CARD32 resourceID ;
CARD16 minorCode ;
CARD8 majorCode;
BYTE pad1;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xError;
typedef struct {
union {
struct {
BYTE type;
BYTE detail;
CARD16 sequenceNumber ;
} u;
struct {
CARD32 pad00 ;
CARD32 time ;
CARD32 root , event , child ;
INT16 rootX , rootY , eventX , eventY ;
KeyButMask state ;
BOOL sameScreen;
BYTE pad1;
} keyButtonPointer;
struct {
CARD32 pad00 ;
CARD32 time ;
CARD32 root , event , child ;
INT16 rootX , rootY , eventX , eventY ;
KeyButMask state ;
BYTE mode;
BYTE flags;
} enterLeave;
struct {
CARD32 pad00 ;
CARD32 window ;
BYTE mode;
BYTE pad1, pad2, pad3;
} focus;
struct {
CARD32 pad00 ;
CARD32 window ;
CARD16 x , y , width , height ;
CARD16 count ;
CARD16 pad2 ;
} expose;
struct {
CARD32 pad00 ;
CARD32 drawable ;
CARD16 x , y , width , height ;
CARD16 minorEvent ;
CARD16 count ;
BYTE majorEvent;
BYTE pad1, pad2, pad3;
} graphicsExposure;
struct {
CARD32 pad00 ;
CARD32 drawable ;
CARD16 minorEvent ;
BYTE majorEvent;
BYTE bpad;
} noExposure;
struct {
CARD32 pad00 ;
CARD32 window ;
CARD8 state;
BYTE pad1, pad2, pad3;
} visibility;
struct {
CARD32 pad00 ;
CARD32 parent , window ;
INT16 x , y ;
CARD16 width , height , borderWidth ;
BOOL override;
BYTE bpad;
} createNotify;
struct {
CARD32 pad00 ;
CARD32 event , window ;
} destroyNotify;
struct {
CARD32 pad00 ;
CARD32 event , window ;
BOOL fromConfigure;
BYTE pad1, pad2, pad3;
} unmapNotify;
struct {
CARD32 pad00 ;
CARD32 event , window ;
BOOL override;
BYTE pad1, pad2, pad3;
} mapNotify;
struct {
CARD32 pad00 ;
CARD32 parent , window ;
} mapRequest;
struct {
CARD32 pad00 ;
CARD32 event , window , parent ;
INT16 x , y ;
BOOL override;
BYTE pad1, pad2, pad3;
} reparent;
struct {
CARD32 pad00 ;
CARD32 event , window , aboveSibling ;
INT16 x , y ;
CARD16 width , height , borderWidth ;
BOOL override;
BYTE bpad;
} configureNotify;
struct {
CARD32 pad00 ;
CARD32 parent , window , sibling ;
INT16 x , y ;
CARD16 width , height , borderWidth ;
CARD16 valueMask ;
CARD32 pad1 ;
} configureRequest;
struct {
CARD32 pad00 ;
CARD32 event , window ;
INT16 x , y ;
CARD32 pad1, pad2, pad3, pad4;
} gravity;
struct {
CARD32 pad00 ;
CARD32 window ;
CARD16 width , height ;
} resizeRequest;
struct {
CARD32 pad00 ;
CARD32 event , window , parent ;
BYTE place;
BYTE pad1, pad2, pad3;
} circulate;
struct {
CARD32 pad00 ;
CARD32 window ;
CARD32 atom ;
CARD32 time ;
BYTE state;
BYTE pad1;
CARD16 pad2 ;
} property;
struct {
CARD32 pad00 ;
CARD32 time ;
CARD32 window ;
CARD32 atom ;
} selectionClear;
struct {
CARD32 pad00 ;
CARD32 time ;
CARD32 owner , requestor ;
CARD32 selection , target , property ;
} selectionRequest;
struct {
CARD32 pad00 ;
CARD32 time ;
CARD32 requestor ;
CARD32 selection , target , property ;
} selectionNotify;
struct {
CARD32 pad00 ;
CARD32 window ;
CARD32 colormap ;
BOOL new;
BYTE state;
BYTE pad1, pad2;
} colormap;
struct {
CARD32 pad00 ;
CARD8 request;
CARD8 firstKeyCode;
CARD8 count;
BYTE pad1;
} mappingNotify;
struct {
CARD32 pad00 ;
CARD32 window ;
union {
struct {
CARD32 type ;
INT32 longs0 ;
INT32 longs1 ;
INT32 longs2 ;
INT32 longs3 ;
INT32 longs4 ;
} l;
struct {
CARD32 type ;
INT16 shorts0 ;
INT16 shorts1 ;
INT16 shorts2 ;
INT16 shorts3 ;
INT16 shorts4 ;
INT16 shorts5 ;
INT16 shorts6 ;
INT16 shorts7 ;
INT16 shorts8 ;
INT16 shorts9 ;
} s;
struct {
CARD32 type ;
INT8 bytes[20];
} b;
} u;
} clientMessage;
} u;
} xEvent;
typedef struct {
BYTE type;
BYTE map[31];
} xKeymapEvent;
typedef union {
xGenericReply generic;
xGetGeometryReply geom;
xQueryTreeReply tree;
xInternAtomReply atom;
xGetAtomNameReply atomName;
xGetPropertyReply property;
xListPropertiesReply listProperties;
xGetSelectionOwnerReply selection;
xGrabPointerReply grabPointer;
xGrabKeyboardReply grabKeyboard;
xQueryPointerReply pointer;
xGetMotionEventsReply motionEvents;
xTranslateCoordsReply coords;
xGetInputFocusReply inputFocus;
xQueryTextExtentsReply textExtents;
xListFontsReply fonts;
xGetFontPathReply fontPath;
xGetImageReply image;
xListInstalledColormapsReply colormaps;
xAllocColorReply allocColor;
xAllocNamedColorReply allocNamedColor;
xAllocColorCellsReply colorCells;
xAllocColorPlanesReply colorPlanes;
xQueryColorsReply colors;
xLookupColorReply lookupColor;
xQueryBestSizeReply bestSize;
xQueryExtensionReply extension;
xListExtensionsReply extensions;
xSetModifierMappingReply setModifierMapping;
xGetModifierMappingReply getModifierMapping;
xSetPointerMappingReply setPointerMapping;
xGetKeyboardMappingReply getKeyboardMapping;
xGetPointerMappingReply getPointerMapping;
xGetPointerControlReply pointerControl;
xGetScreenSaverReply screenSaver;
xListHostsReply hosts;
xError error;
xEvent event;
} xReply;
typedef struct {
CARD8 reqType;
CARD8 data;
CARD16 length ;
} xReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 id ;
} xResourceReq;
typedef struct {
CARD8 reqType;
CARD8 depth;
CARD16 length ;
CARD32 wid , parent ;
INT16 x , y ;
CARD16 width , height , borderWidth ;
CARD16 class ;
CARD32 visual ;
CARD32 mask ;
} xCreateWindowReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD32 valueMask ;
} xChangeWindowAttributesReq;
typedef struct {
CARD8 reqType;
BYTE mode;
CARD16 length ;
CARD32 window ;
} xChangeSaveSetReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window , parent ;
INT16 x , y ;
} xReparentWindowReq;
typedef struct {
CARD8 reqType;
CARD8 pad;
CARD16 length ;
CARD32 window ;
CARD16 mask ;
CARD16 pad2 ;
} xConfigureWindowReq;
typedef struct {
CARD8 reqType;
CARD8 direction;
CARD16 length ;
CARD32 window ;
} xCirculateWindowReq;
typedef struct {
CARD8 reqType;
BOOL onlyIfExists;
CARD16 length ;
CARD16 nbytes ;
CARD16 pad ;
} xInternAtomReq;
typedef struct {
CARD8 reqType;
CARD8 mode;
CARD16 length ;
CARD32 window ;
CARD32 property , type ;
CARD8 format;
BYTE pad[3];
CARD32 nUnits ;
} xChangePropertyReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD32 property ;
} xDeletePropertyReq;
typedef struct {
CARD8 reqType;
BOOL delete;
CARD16 length ;
CARD32 window ;
CARD32 property , type ;
CARD32 longOffset ;
CARD32 longLength ;
} xGetPropertyReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD32 selection ;
CARD32 time ;
} xSetSelectionOwnerReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 requestor ;
CARD32 selection , target , property ;
CARD32 time ;
} xConvertSelectionReq;
typedef struct {
CARD8 reqType;
BOOL propagate;
CARD16 length ;
CARD32 destination ;
CARD32 eventMask ;
xEvent event;
} xSendEventReq;
typedef struct {
CARD8 reqType;
BOOL ownerEvents;
CARD16 length ;
CARD32 grabWindow ;
CARD16 eventMask ;
BYTE pointerMode, keyboardMode;
CARD32 confineTo ;
CARD32 cursor ;
CARD32 time ;
} xGrabPointerReq;
typedef struct {
CARD8 reqType;
BOOL ownerEvents;
CARD16 length ;
CARD32 grabWindow ;
CARD16 eventMask ;
BYTE pointerMode, keyboardMode;
CARD32 confineTo ;
CARD32 cursor ;
CARD8 button;
BYTE pad;
CARD16 modifiers ;
} xGrabButtonReq;
typedef struct {
CARD8 reqType;
CARD8 button;
CARD16 length ;
CARD32 grabWindow ;
CARD16 modifiers ;
CARD16 pad ;
} xUngrabButtonReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cursor ;
CARD32 time ;
CARD16 eventMask ;
CARD16 pad2 ;
} xChangeActivePointerGrabReq;
typedef struct {
CARD8 reqType;
BOOL ownerEvents;
CARD16 length ;
CARD32 grabWindow ;
CARD32 time ;
BYTE pointerMode, keyboardMode;
CARD16 pad ;
} xGrabKeyboardReq;
typedef struct {
CARD8 reqType;
BOOL ownerEvents;
CARD16 length ;
CARD32 grabWindow ;
CARD16 modifiers ;
CARD8 key;
BYTE pointerMode, keyboardMode;
BYTE pad1, pad2, pad3;
} xGrabKeyReq;
typedef struct {
CARD8 reqType;
CARD8 key;
CARD16 length ;
CARD32 grabWindow ;
CARD16 modifiers ;
CARD16 pad ;
} xUngrabKeyReq;
typedef struct {
CARD8 reqType;
CARD8 mode;
CARD16 length ;
CARD32 time ;
} xAllowEventsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD32 start , stop ;
} xGetMotionEventsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcWid , dstWid ;
INT16 srcX , srcY ;
} xTranslateCoordsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcWid , dstWid ;
INT16 srcX , srcY ;
CARD16 srcWidth , srcHeight ;
INT16 dstX , dstY ;
} xWarpPointerReq;
typedef struct {
CARD8 reqType;
CARD8 revertTo;
CARD16 length ;
CARD32 focus ;
CARD32 time ;
} xSetInputFocusReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 fid ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xOpenFontReq;
typedef struct {
CARD8 reqType;
BOOL oddLength;
CARD16 length ;
CARD32 fid ;
} xQueryTextExtentsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD16 maxNames ;
CARD16 nbytes ;
} xListFontsReq;
typedef xListFontsReq xListFontsWithInfoReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD16 nFonts ;
BYTE pad1, pad2;
} xSetFontPathReq;
typedef struct {
CARD8 reqType;
CARD8 depth;
CARD16 length ;
CARD32 pid ;
CARD32 drawable ;
CARD16 width , height ;
} xCreatePixmapReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 gc ;
CARD32 drawable ;
CARD32 mask ;
} xCreateGCReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 gc ;
CARD32 mask ;
} xChangeGCReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcGC , dstGC ;
CARD32 mask ;
} xCopyGCReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 gc ;
CARD16 dashOffset ;
CARD16 nDashes ;
} xSetDashesReq;
typedef struct {
CARD8 reqType;
BYTE ordering;
CARD16 length ;
CARD32 gc ;
INT16 xOrigin , yOrigin ;
} xSetClipRectanglesReq;
typedef struct {
CARD8 reqType;
BOOL exposures;
CARD16 length ;
CARD32 window ;
INT16 x , y ;
CARD16 width , height ;
} xClearAreaReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcDrawable , dstDrawable ;
CARD32 gc ;
INT16 srcX , srcY , dstX , dstY ;
CARD16 width , height ;
} xCopyAreaReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcDrawable , dstDrawable ;
CARD32 gc ;
INT16 srcX , srcY , dstX , dstY ;
CARD16 width , height ;
CARD32 bitPlane ;
} xCopyPlaneReq;
typedef struct {
CARD8 reqType;
BYTE coordMode;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
} xPolyPointReq;
typedef xPolyPointReq xPolyLineReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
} xPolySegmentReq;
typedef xPolySegmentReq xPolyArcReq;
typedef xPolySegmentReq xPolyRectangleReq;
typedef xPolySegmentReq xPolyFillRectangleReq;
typedef xPolySegmentReq xPolyFillArcReq;
typedef struct _FillPolyReq {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
BYTE shape;
BYTE coordMode;
CARD16 pad1 ;
} xFillPolyReq;
typedef struct _PutImageReq {
CARD8 reqType;
CARD8 format;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
CARD16 width , height ;
INT16 dstX , dstY ;
CARD8 leftPad;
CARD8 depth;
CARD16 pad ;
} xPutImageReq;
typedef struct {
CARD8 reqType;
CARD8 format;
CARD16 length ;
CARD32 drawable ;
INT16 x , y ;
CARD16 width , height ;
CARD32 planeMask ;
} xGetImageReq;
typedef struct {
CARD8 reqType;
CARD8 pad;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
INT16 x , y ;
} xPolyTextReq;
typedef xPolyTextReq xPolyText8Req;
typedef xPolyTextReq xPolyText16Req;
typedef struct {
CARD8 reqType;
BYTE nChars;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
INT16 x , y ;
} xImageTextReq;
typedef xImageTextReq xImageText8Req;
typedef xImageTextReq xImageText16Req;
typedef struct {
CARD8 reqType;
BYTE alloc;
CARD16 length ;
CARD32 mid ;
CARD32 window ;
CARD32 visual ;
} xCreateColormapReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 mid ;
CARD32 srcCmap ;
} xCopyColormapAndFreeReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
CARD16 red , green , blue ;
CARD16 pad2 ;
} xAllocColorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xAllocNamedColorReq;
typedef struct {
CARD8 reqType;
BOOL contiguous;
CARD16 length ;
CARD32 cmap ;
CARD16 colors , planes ;
} xAllocColorCellsReq;
typedef struct {
CARD8 reqType;
BOOL contiguous;
CARD16 length ;
CARD32 cmap ;
CARD16 colors , red , green , blue ;
} xAllocColorPlanesReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
CARD32 planeMask ;
} xFreeColorsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
} xStoreColorsReq;
typedef struct {
CARD8 reqType;
CARD8 flags;
CARD16 length ;
CARD32 cmap ;
CARD32 pixel ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xStoreNamedColorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
} xQueryColorsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xLookupColorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cid ;
CARD32 source , mask ;
CARD16 foreRed , foreGreen , foreBlue ;
CARD16 backRed , backGreen , backBlue ;
CARD16 x , y ;
} xCreateCursorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cid ;
CARD32 source , mask ;
CARD16 sourceChar , maskChar ;
CARD16 foreRed , foreGreen , foreBlue ;
CARD16 backRed , backGreen , backBlue ;
} xCreateGlyphCursorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cursor ;
CARD16 foreRed , foreGreen , foreBlue ;
CARD16 backRed , backGreen , backBlue ;
} xRecolorCursorReq;
typedef struct {
CARD8 reqType;
CARD8 class;
CARD16 length ;
CARD32 drawable ;
CARD16 width , height ;
} xQueryBestSizeReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xQueryExtensionReq;
typedef struct {
CARD8 reqType;
CARD8 numKeyPerModifier;
CARD16 length ;
} xSetModifierMappingReq;
typedef struct {
CARD8 reqType;
CARD8 nElts;
CARD16 length ;
} xSetPointerMappingReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD8 firstKeyCode;
CARD8 count;
CARD16 pad1 ;
} xGetKeyboardMappingReq;
typedef struct {
CARD8 reqType;
CARD8 keyCodes;
CARD16 length ;
CARD8 firstKeyCode;
CARD8 keySymsPerKeyCode;
CARD16 pad1 ;
} xChangeKeyboardMappingReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 mask ;
} xChangeKeyboardControlReq;
typedef struct {
CARD8 reqType;
INT8 percent;
CARD16 length ;
} xBellReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
INT16 accelNum , accelDenum ;
INT16 threshold ;
BOOL doAccel, doThresh;
} xChangePointerControlReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
INT16 timeout , interval ;
BYTE preferBlank, allowExpose;
CARD16 pad2 ;
} xSetScreenSaverReq;
typedef struct {
CARD8 reqType;
BYTE mode;
CARD16 length ;
CARD8 hostFamily;
BYTE pad;
CARD16 hostLength ;
} xChangeHostsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
} xListHostsReq;
typedef struct {
CARD8 reqType;
BYTE mode;
CARD16 length ;
} xChangeModeReq;
typedef xChangeModeReq xSetAccessControlReq;
typedef xChangeModeReq xSetCloseDownModeReq;
typedef xChangeModeReq xForceScreenSaverReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD16 nAtoms ;
INT16 nPositions ;
} xRotatePropertiesReq;
# 33 "events.c"
# 1 "../include/windowstr.h"
# 1 "../include/window.h"
typedef struct _BackingStore *BackingStorePtr;
typedef struct _Window *WindowPtr;
# 29 "../include/windowstr.h"
# 1 "../include/pixmapstr.h"
# 1 "../include/pixmap.h"
typedef struct _DrawInfo *DrawablePtr;
typedef struct _Pixmap *PixmapPtr;
# 28 "../include/pixmapstr.h"
# 1 "../include/screenint.h"
typedef struct _PixmapFormat *PixmapFormatPtr;
typedef struct _Visual *VisualPtr;
typedef struct _Depth *DepthPtr;
typedef struct _Screen *ScreenPtr;
# 29 "../include/pixmapstr.h"
# 1 "../include/misc.h"
# 117 "../include/misc.h"
# 30 "../include/pixmapstr.h"
typedef struct _DrawInfo {
short type;
ScreenPtr pScreen;
int depth;
unsigned long serialNumber;
} DrawableRec;
typedef struct _Pixmap {
DrawableRec drawable;
int width, height;
int refcnt;
int devKind;
pointer devPrivate;
} PixmapRec;
# 30 "../include/windowstr.h"
# 1 "../include/region.h"
typedef struct _Region *RegionPtr;
extern int SingleRectRegionEqual();
# 31 "../include/windowstr.h"
# 1 "../include/cursor.h"
typedef struct _Cursor *CursorPtr;
typedef struct _CursorMetric *CursorMetricPtr;
extern CursorPtr rootCursor;
# 32 "../include/windowstr.h"
# 1 "../include/property.h"
typedef struct _Property *PropertyPtr;
# 33 "../include/windowstr.h"
# 1 "../include/resource.h"
# 74 "../include/resource.h"
# 34 "../include/windowstr.h"
# 1 "../include/dix.h"
# 1 "../include/gc.h"
typedef struct _GCInterest *GCInterestPtr;
typedef struct _GC *GCPtr;
extern void ValidateGC();
extern int ChangeGC();
extern GCPtr CreateGC();
extern int CopyGC();
extern int FreeGC();
extern void SetGCMask();
extern GCPtr GetScratchGC();
extern void FreeScratchGC();
# 29 "../include/dix.h"
# 1 "../include/window.h"
# 53 "../include/window.h"
# 30 "../include/dix.h"
typedef struct _TimeStamp *TimeStampPtr;
typedef struct _Client *ClientPtr;
extern ClientPtr requestingClient;
extern ClientPtr *clients;
extern ClientPtr serverClient;
extern int currentMaxClients;
extern int ProcAllowEvents();
extern int ProcBell();
extern int ProcChangeActivePointerGrab();
extern int ProcChangeKeyboardControl();
extern int ProcChangePointerControl();
extern int ProcGetKeyboardMapping();
extern int ProcGetPointerMapping();
extern int ProcGetInputFocus();
extern int ProcGetKeyboardControl();
extern int ProcGetMotionEvents();
extern int ProcGetPointerControl();
extern int ProcGrabButton();
extern int ProcGrabKey();
extern int ProcGrabKeyboard();
extern int ProcGrabPointer();
extern int ProcQueryKeymap();
extern int ProcQueryPointer();
extern int ProcSetInputFocus();
extern int ProcSetKeyboardMapping();
extern int ProcSetPointerMapping();
extern int ProcSendEvent();
extern int ProcUngrabButton();
extern int ProcUngrabKey();
extern int ProcUngrabKeyboard();
extern int ProcUngrabPointer();
extern int ProcWarpPointer();
extern int ProcRecolorCursor();
extern WindowPtr LookupWindow();
extern pointer LookupDrawable();
extern void NoopDDA();
# 35 "../include/windowstr.h"
# 1 "../include/miscstruct.h"
# 1 "../include/misc.h"
# 117 "../include/misc.h"
# 28 "../include/miscstruct.h"
extern unsigned long globalSerialNumber;
typedef struct _DDXPoint {
short x, y;
} DDXPointRec;
typedef struct _Box {
short x1, y1, x2, y2;
} BoxRec;
# 36 "../include/windowstr.h"
# 1 "../../X11/Xprotostr.h"
# 55 "../../X11/Xprotostr.h"
# 37 "../include/windowstr.h"
typedef struct _BackingStore {
RegionPtr obscured;
DDXPointRec oldAbsCorner;
void (* SaveDoomedAreas)();
RegionPtr (* RestoreAreas)();
void (* ExposeCopy)();
void (* TranslateBackingStore)();
void (* ClearToBackground)();
void (* DrawGuarantee)();
} BackingStoreRec;
typedef struct _Window {
DrawableRec drawable;
VisualID visual;
struct _Window *parent;
struct _Window *nextSib;
struct _Window *prevSib;
struct _Window *firstChild;
struct _Window *lastChild;
CursorPtr cursor;
ClientPtr client;
Window wid;
RegionPtr clipList;
RegionPtr winSize;
RegionPtr borderClip;
RegionPtr borderSize;
RegionPtr exposed;
RegionPtr borderExposed;
xRectangle clientWinSize;
DDXPointRec absCorner;
DDXPointRec oldAbsCorner;
int class;
Mask eventMask;
Mask dontPropagateMask;
Mask allEventMasks;
Mask deliverableEvents;
pointer otherClients;
pointer passiveGrabs;
PropertyPtr userProps;
XID nolongerused;
PixmapPtr backgroundTile;
unsigned long backgroundPixel;
PixmapPtr borderTile;
unsigned long borderPixel;
int borderWidth;
void (* PaintWindowBackground)();
void (* PaintWindowBorder)();
void (* CopyWindow)();
void (* ClearToBackground)();
unsigned long backingBitPlanes;
unsigned long backingPixel;
int backingStore;
BackingStorePtr backStorage;
char bitGravity;
char winGravity;
Colormap colormap;
Bool saveUnder:1;
unsigned visibility:2;
unsigned mapped:1;
unsigned realized:1;
unsigned viewable:1;
unsigned overrideRedirect:1;
unsigned marked:1;
pointer devBackingStore;
pointer devPrivate;
} WindowRec;
extern int DeleteWindow();
extern int ChangeWindowAttributes();
extern int WalkTree();
extern CreateRootWindow();
extern WindowPtr CreateWindow();
extern int DeleteWindow();
extern int DestroySubwindows();
extern int ChangeWindowAttributes();
extern int GetWindowAttributes();
extern int ConfigureWindow();
extern int ReparentWindow();
extern int MapWindow();
extern int MapSubwindow();
extern int UnmapWindow();
extern int UnmapSubwindow();
extern RegionPtr NotClippedByChildren();
# 34 "events.c"
# 1 "../include/inputstr.h"
# 1 "../include/input.h"
# 1 "../include/misc.h"
# 117 "../include/misc.h"
# 27 "../include/input.h"
typedef unsigned long Leds;
typedef struct _OtherClients *OtherClientsPtr;
typedef struct _GrabRec *GrabPtr;
typedef int (*DeviceProc)();
typedef void (*ProcessInputProc)();
typedef struct _DeviceRec {
pointer devicePrivate;
ProcessInputProc processInputProc;
Bool on;
} DeviceRec, *DevicePtr;
typedef struct {
int count;
DevicePtr *devices;
} DevicesDescriptor;
typedef struct {
int click, bell, bell_pitch, bell_duration;
Bool autoRepeat;
unsigned char autoRepeats[32];
Leds leds;
} KeybdCtrl;
typedef struct {
KeySym *map;
KeyCode minKeyCode,
maxKeyCode;
int mapWidth;
} KeySymsRec, *KeySymsPtr;
typedef struct {
int num, den, threshold;
} PtrCtrl;
extern KeybdCtrl defaultKeyboardControl;
extern PtrCtrl defaultPointerControl;
extern int DeliverEvents();
extern int MaybeDeliverEventsToClient(
);
extern DevicePtr AddInputDevice();
extern void RegisterPointerDevice();
extern void RegisterKeyboardDevice();
extern void ProcessPointerEvent();
extern void ProcessKeyboardEvent();
extern void ProcessOtherEvent();
extern void InitPointerDeviceStruct();
extern void InitKeyboardDeviceStruct();
extern void InitOtherDeviceStruct();
extern GrabPtr SetDeviceGrab();
extern DevicesDescriptor GetInputDevices();
extern DevicePtr LookupInputDevice();
extern DevicePtr LookupKeyboardDevice();
extern DevicePtr LookupPointerDevice();
extern void CloseDownDevices();
extern int InitAndStartDevices();
extern int NumMotionEvents();
extern void WriteEventsToClient();
extern int EventSelectForWindow();
extern int EventSuppressForWindow();
# 30 "../include/inputstr.h"
# 1 "../include/window.h"
# 53 "../include/window.h"
# 31 "../include/inputstr.h"
# 1 "../include/dixstruct.h"
# 1 "../include/dix.h"
# 100 "../include/dix.h"
# 29 "../include/dixstruct.h"
# 1 "../include/resource.h"
# 74 "../include/resource.h"
# 30 "../include/dixstruct.h"
# 1 "../include/cursor.h"
# 33 "../include/cursor.h"
# 31 "../include/dixstruct.h"
# 1 "../include/gc.h"
# 65 "../include/gc.h"
# 32 "../include/dixstruct.h"
# 1 "../include/pixmap.h"
# 45 "../include/pixmap.h"
# 33 "../include/dixstruct.h"
typedef struct _TimeStamp {
unsigned long months;
unsigned long milliseconds;
} TimeStamp;
typedef struct _Client {
int index;
Mask clientAsMask;
pointer requestBuffer;
pointer osPrivate;
Bool swapped;
void (* pSwapReplyFunc)();
XID errorValue;
int sequence;
int closeDownMode;
int clientGone;
int noClientException;
DrawablePtr lastDrawable;
Drawable lastDrawableID;
GCPtr lastGC;
GContext lastGCID;
pointer *saveSet;
int numSaved;
int requestLog[100];
int requestLogIndex;
pointer screenPrivate[3];
} ClientRec;
extern TimeStamp currentTime;
extern void CloseDownClient();
extern TimeStamp ClientTimeToServerTime();
# 32 "../include/inputstr.h"
typedef struct _OtherClients {
OtherClientsPtr next;
ClientPtr client;
XID resource;
Mask mask;
} OtherClients;
typedef struct _DeviceIntRec *DeviceIntPtr;
typedef struct _DetailRec {
unsigned short exact;
Mask *pMask;
} DetailRec;
typedef struct _GrabRec {
GrabPtr next;
XID resource;
ClientPtr client;
DeviceIntPtr device;
WindowPtr window;
Bool ownerEvents;
Bool keyboardMode, pointerMode;
DetailRec modifiersDetail;
Mask eventMask;
DetailRec detail;
WindowPtr confineTo;
CursorPtr cursor;
} GrabRec;
typedef struct {
WindowPtr win;
int revert;
TimeStamp time;
} FocusRec, *FocusPtr;
typedef struct _DeviceIntRec {
DeviceRec public;
TimeStamp grabTime;
Bool startup;
DeviceProc deviceProc;
Bool inited;
GrabPtr grab;
struct {
Bool frozen;
int state;
GrabPtr other;
xEvent event;
} sync;
BYTE down[32 ];
union {
struct {
CARD8 modifierMap[256];
KeybdCtrl ctrl;
void (*BellProc) ();
void (*CtrlProc) ();
FocusRec focus;
Bool passiveGrab;
} keybd;
struct {
PtrCtrl ctrl;
void (*CtrlProc) ();
int (*GetMotionProc) ();
Bool autoReleaseGrab;
BYTE map[256];
int mapLength;
} ptr;
struct {
FocusRec focus;
BYTE map[256];
int mapLength;
} other;
} u;
} DeviceIntRec;
typedef struct {
int numMotionEvents;
int numDevices;
int arraySize;
DeviceIntPtr *devices;
DeviceIntPtr keyboard;
DeviceIntPtr pointer;
} InputInfo;
typedef struct _QdEvent *QdEventPtr;
typedef struct _QdEvent {
QdEventPtr forw;
QdEventPtr back;
DeviceIntPtr device;
xEvent event;
} QdEventRec;
# 35 "events.c"
# 1 "../include/scrnintstr.h"
# 1 "../include/screenint.h"
# 33 "../include/screenint.h"
# 28 "../include/scrnintstr.h"
# 1 "../include/misc.h"
# 117 "../include/misc.h"
# 29 "../include/scrnintstr.h"
# 1 "../include/region.h"
# 41 "../include/region.h"
# 30 "../include/scrnintstr.h"
# 1 "../include/pixmap.h"
# 45 "../include/pixmap.h"
# 31 "../include/scrnintstr.h"
# 1 "../include/gc.h"
# 65 "../include/gc.h"
# 32 "../include/scrnintstr.h"
# 1 "../include/colormap.h"
# 55 "../include/colormap.h"
typedef unsigned long Pixel;
typedef struct _CMEntry *EntryPtr;
typedef struct _ColormapRec *ColormapPtr;
extern int CreateColormap();
extern Pixel FindColor();
extern int FreeColormap();
extern int TellLostMap();
extern int TellGainedMap();
extern int IsMapInstalled();
extern void UninstallColormap();
# 33 "../include/scrnintstr.h"
typedef struct _PixmapFormat {
unsigned char depth;
unsigned char bitsPerPixel;
unsigned char scanlinePad;
} PixmapFormatRec;
typedef struct _Visual {
unsigned long vid;
short screen;
short class;
unsigned long redMask, greenMask, blueMask;
int offsetRed, offsetGreen, offsetBlue;
short bitsPerRGBValue;
short ColormapEntries;
short nplanes;
} VisualRec;
typedef struct _Depth {
int depth;
int numVids;
unsigned long *vids;
} DepthRec;
typedef struct _Screen {
int myNum;
ATOM id;
short width, height;
short mmWidth, mmHeight;
short numDepths;
DepthPtr allowedDepths;
short rootDepth;
unsigned long rootVisual;
unsigned long defColormap;
short minInstalledCmaps, maxInstalledCmaps;
char backingStoreSupport, saveUnderSupport;
unsigned long whitePixel, blackPixel;
unsigned long rgf;
GCPtr GCperDepth[8+1];
PixmapPtr PixmapPerDepth[1];
pointer devPrivate;
short numVisuals;
VisualPtr visuals;
Bool (* CloseScreen)();
void (* QueryBestSize)();
Bool (* SaveScreen)();
void (* GetImage)();
unsigned int *(* GetSpans)();
void (* PointerNonInterestBox)();
Bool (* CreateWindow)();
Bool (* DestroyWindow)();
Bool (* PositionWindow)();
Bool (* ChangeWindowAttributes)();
Bool (* RealizeWindow)();
Bool (* UnrealizeWindow)();
int (* ValidateTree)();
void (* WindowExposures)();
PixmapPtr (* CreatePixmap)();
Bool (* DestroyPixmap)();
Bool (* RealizeFont)();
Bool (* UnrealizeFont)();
void (* ConstrainCursor)();
void (* CursorLimits)();
Bool (* DisplayCursor)();
Bool (* RealizeCursor)();
Bool (* UnrealizeCursor)();
void (* RecolorCursor)();
Bool (* SetCursorPosition)();
Bool (* CreateGC)();
void (* CreateColormap)();
void (* DestroyColormap)();
void (* InstallColormap)();
void (* UninstallColormap)();
int (* ListInstalledColormaps) ();
void (* StoreColors)();
void (* ResolveColor)();
RegionPtr (* RegionCreate)();
void (* RegionCopy)();
void (* RegionDestroy)();
int (* Intersect)();
int (* Union)();
int (* Subtract)();
int (* Inverse)();
void (* RegionReset)();
void (* TranslateRegion)();
int (* RectIn)();
Bool (* PointInRegion)();
Bool (* RegionNotEmpty)();
void (* RegionEmpty)();
BoxPtr (*RegionExtents)();
void (* SendGraphicsExpose)();
void (* BlockHandler)();
void (* WakeupHandler)();
pointer blockData;
pointer wakeupData;
} ScreenRec;
typedef struct _ScreenInfo {
int imageByteOrder;
int bitmapScanlineUnit;
int bitmapScanlinePad;
int bitmapBitOrder;
int numPixmapFormats;
PixmapFormatRec
formats[8];
int arraySize;
int numScreens;
ScreenPtr screen;
} ScreenInfo;
extern ScreenInfo screenInfo;
# 36 "events.c"
# 1 "../include/cursorstr.h"
# 1 "../include/cursor.h"
# 33 "../include/cursor.h"
# 28 "../include/cursorstr.h"
# 1 "../include/pixmap.h"
# 45 "../include/pixmap.h"
# 29 "../include/cursorstr.h"
# 1 "../include/misc.h"
# 117 "../include/misc.h"
# 30 "../include/cursorstr.h"
typedef struct _Cursor {
unsigned char *source;
unsigned char *mask;
long width;
long height;
long xhot;
long yhot;
unsigned foreRed, foreGreen, foreBlue;
unsigned backRed, backGreen, backBlue;
int refcnt;
pointer devPriv[3];
} CursorRec;
typedef struct _CursorMetric {
long width, height, xhot, yhot;
} CursorMetricRec;
extern int FreeCursor();
extern CursorPtr AllocCursor();
extern CursorPtr CreateRootCursor();
# 37 "events.c"
# 1 "../include/dixstruct.h"
# 75 "../include/dixstruct.h"
# 39 "events.c"
extern WindowRec WindowTable[];
extern void (* EventSwapVector[128]) ();
extern void (* ReplySwapVector[256]) ();
extern void CopySwap32Write(), SwapTimeCoordWrite();
static debug_events = 0;
static debug_modifiers = 0;
static InputInfo inputInfo;
static int keyThatActivatedPassiveGrab;
static KeySymsRec curKeySyms;
static GrabRec keybdGrab;
static GrabRec ptrGrab;
static struct {
unsigned int num;
QdEventRec pending, free;
DeviceIntPtr replayDev;
WindowPtr replayWin;
Bool playingEvents;
} syncEvents;
static WindowPtr *spriteTrace = (WindowPtr *) 0;
static int spriteTraceSize = 0;
static int spriteTraceGood;
static WindowPtr *focusTrace = (WindowPtr *) 0;
static int focusTraceSize = 0;
static int focusTraceGood;
static CARD16 keyButtonState = 0;
static int modifierKeyCount[8];
static int buttonsDown = 0;
static Mask buttonMotionMask = 0;
typedef struct {
int x, y;
} HotSpot;
static struct {
CursorPtr current;
BoxRec hotLimits;
BoxRec physLimits;
WindowPtr win;
HotSpot hot;
} sprite;
static WindowPtr motionHintWindow;
static void DoEnterLeaveEvents();
static WindowPtr XYToWindow();
extern Bool CheckKeyboardGrabs();
static void NormalKeyboardEvent();
extern int DeliverDeviceEvents();
static void DoFocusEvents();
extern Mask EventMaskForClient();
static WindowPtr CheckMotion();
extern void WriteEventsToClient();
static Bool CheckDeviceGrabs();
extern GrabPtr CreateGrab();
extern void DeleteGrab();
extern Bool GrabMatchesSecond();
extern void DeletePassiveGrabFromList();
extern void AddPassiveGrabToWindowList();
static ScreenPtr currentScreen;
CARD16 keyModifiersList[256];
static CARD8 maxKeysPerModifier;
static KeyCode *modifierKeyMap;
static Mask lastEventMask;
static Mask filters[128] =
{
0x80000000 ,
0x80000000 ,
(1L<<0) ,
(1L<<1) ,
(1L<<2) ,
(1L<<3) ,
( (1L<<6) | (1L<<8) | (1L<<9) | (1L<<10) | (1L<<11) | (1L<<12) | (1L<<13) ),
(1L<<4) ,
(1L<<5) ,
(1L<<21) ,
(1L<<21) ,
(1L<<14),
(1L<<15) ,
0L,
0L,
(1L<<16) ,
(1L<<19) ,
( (1L<<17) | (1L<<19) ),
( (1L<<17) | (1L<<19) ),
( (1L<<17) | (1L<<19) ),
(1L<<20) ,
( (1L<<17) | (1L<<19) ),
( (1L<<17) | (1L<<19) ),
(1L<<20) ,
( (1L<<17) | (1L<<19) ),
(1L<<18) ,
( (1L<<17) | (1L<<19) ),
(1L<<20) ,
(1L<<22) ,
0L,
0L,
0L,
(1L<<23) ,
0L
};
Mask
GetNextEventMask()
{
lastEventMask <<= 1;
return lastEventMask;
}
void
SetMaskForEvent(mask, event)
Mask mask;
int event;
{
if ((event < 35 ) || (event >= 128))
FatalError("MaskForEvent: bogus event number");
filters[event] = mask;
}
static void
SyntheticMotion(x, y)
int x, y;
{
xEvent xE;
xE.u.keyButtonPointer.rootX = x;
xE.u.keyButtonPointer.rootY = y;
xE.u.keyButtonPointer.time = currentTime.milliseconds;
xE.u.u.type = 6;
ProcessPointerEvent(&xE, inputInfo.pointer);
}
static void
CheckPhysLimits(cursor, generateEvents)
CursorPtr cursor;
Bool generateEvents;
{
HotSpot new;
if (!cursor)
return;
new = sprite.hot;
(*currentScreen->CursorLimits) (
currentScreen, cursor, &sprite.hotLimits, &sprite.physLimits);
if (new.x < sprite.physLimits.x1)
new.x = sprite.physLimits.x1;
else
if (new.x >= sprite.physLimits.x2)
new.x = sprite.physLimits.x2 - 1;
if (new.y < sprite.physLimits.y1)
new.y = sprite.physLimits.y1;
else
if (new.y >= sprite.physLimits.y2)
new.y = sprite.physLimits.y2 - 1;
if ((new.x != sprite.hot.x) || (new.y != sprite.hot.y))
{
(*currentScreen->SetCursorPosition) (
currentScreen, new.x, new.y, generateEvents);
if (!generateEvents)
SyntheticMotion(new.x, new.y);
}
}
static void
ConfineCursorToWindow(pWin, x, y, generateEvents)
WindowPtr pWin;
int x, y;
Bool generateEvents;
{
ScreenPtr pScreen = pWin->drawable.pScreen;
sprite.hotLimits = *(* pScreen->RegionExtents)(pWin->borderSize);
if (currentScreen != pScreen)
{
currentScreen = pScreen;
spriteTrace[0] = &WindowTable[pScreen->myNum];
if (x < sprite.hotLimits.x1)
x = sprite.hotLimits.x1;
else if (x >= sprite.hotLimits.x2)
x = sprite.hotLimits.x2 - 1;
if (y < sprite.hotLimits.y1)
y = sprite.hotLimits.y1;
else if (y >= sprite.hotLimits.y2)
y = sprite.hotLimits.y2 - 1;
sprite.hot.x = -1;
sprite.hot.y = -1;
(* pScreen->SetCursorPosition)(pScreen, x, y, generateEvents);
if (!generateEvents)
SyntheticMotion(x, y);
}
CheckPhysLimits(sprite.current, generateEvents);
(* pScreen->ConstrainCursor)(pScreen, &sprite.physLimits);
}
static void
ChangeToCursor(cursor)
CursorPtr cursor;
{
if (!cursor)
FatalError("Somebody is setting NullCursor");
if (cursor != sprite.current)
{
if ((sprite.current->xhot != cursor->xhot) ||
(sprite.current->yhot != cursor->yhot))
CheckPhysLimits(cursor, 0);
(*currentScreen->DisplayCursor) (currentScreen, cursor);
sprite.current = cursor;
}
}
static Bool
IsParent(a, b)
register WindowPtr a, b;
{
for (b = b->parent; b; b = b->parent)
if (b == a) return 1;
return 0;
}
static void
PostNewCursor()
{
register WindowPtr win;
register GrabPtr grab = inputInfo.pointer->grab;
if (grab)
{
if (grab->cursor)
{
ChangeToCursor(grab->cursor);
return;
}
if (IsParent(grab->window, sprite.win))
win = sprite.win;
else
win = grab->window;
}
else
win = sprite.win;
for (; win; win = win->parent)
if (win->cursor != ((CursorPtr) 0))
{
ChangeToCursor(win->cursor);
return;
}
}
static void
EnqueueEvent(device, event)
xEvent *event;
DeviceIntPtr device;
{
register QdEventPtr tail = syncEvents.pending.back;
register QdEventPtr new;
if ((event->u.u.type == 6) &&
(tail->event.u.u.type == 6))
{
tail->event = *event;
return;
}
syncEvents.num++;
if (syncEvents.free.forw == &syncEvents.free)
new = (QdEventPtr)Xalloc((unsigned long)(sizeof(QdEventRec)));
else
{
new = syncEvents.free.forw;
remque(new);
}
new->device = device;
new->event = *event;
insque(new, tail);
if (syncEvents.num > 5000)
{
return;
}
}
static void
PlayReleasedEvents()
{
register QdEventPtr qe = syncEvents.pending.forw;
QdEventPtr next;
while (qe != &syncEvents.pending)
{
register DeviceIntPtr device = qe->device;
if (!device->sync.frozen)
{
next = qe->forw;;
remque(qe);
(*device->public.processInputProc)(&qe->event, device);
insque(qe, &syncEvents.free);
qe = next;
}
else
qe = qe->forw;
}
}
static void
ComputeFreezes(dev1, dev2)
DeviceIntPtr dev1, dev2;
{
register DeviceIntPtr replayDev = syncEvents.replayDev;
int i;
WindowPtr w;
Bool isKbd ;
register xEvent *xE ;
dev1->sync.frozen =
((dev1->sync.other != ((GrabPtr) 0)) || (dev1->sync.state >= 5 ));
dev2->sync.frozen =
((dev2->sync.other != ((GrabPtr) 0)) || (dev2->sync.state >= 5 ));
if (syncEvents.playingEvents)
return;
syncEvents.playingEvents = 1;
if (replayDev)
{
isKbd = (replayDev == inputInfo.keyboard);
xE = &replayDev->sync.event;
syncEvents.replayDev = (DeviceIntPtr) 0;
w = XYToWindow(
xE->u.keyButtonPointer.rootX, xE->u.keyButtonPointer.rootY);
for (i = 0; i < spriteTraceGood; i++)
if (syncEvents.replayWin == spriteTrace[i])
{
if (!CheckDeviceGrabs(replayDev, xE, i+1, isKbd))
if (isKbd)
NormalKeyboardEvent(replayDev, xE, w);
else
DeliverDeviceEvents(w, xE, ((GrabPtr) 0), ((WindowPtr) 0));
goto playmore;
}
if (isKbd)
NormalKeyboardEvent(replayDev, xE, w);
else
DeliverDeviceEvents(w, xE, ((GrabPtr) 0), ((WindowPtr) 0));
}
playmore:
if (!dev1->sync.frozen || !dev2->sync.frozen)
PlayReleasedEvents();
syncEvents.playingEvents = 0;
}
CheckGrabForSyncs(grab, thisDev, thisMode, otherDev, otherMode)
GrabPtr grab;
DeviceIntPtr thisDev, otherDev;
int thisMode, otherMode;
{
if (thisMode == 0)
thisDev->sync.state = 5;
else
{
thisDev->sync.state = 1;
if (thisDev->sync.other &&
(thisDev->sync.other->client == grab->client))
thisDev->sync.other = ((GrabPtr) 0);
}
if (otherMode == 0)
otherDev->sync.other = grab;
else
{
if (otherDev->sync.other &&
(otherDev->sync.other->client == grab->client))
otherDev->sync.other = ((GrabPtr) 0);
}
ComputeFreezes(thisDev, otherDev);
}
static void
ActivatePointerGrab(mouse, grab, time, autoGrab)
GrabPtr grab;
register DeviceIntPtr mouse;
TimeStamp time;
Bool autoGrab;
{
WindowPtr oldWin = (mouse->grab) ? mouse->grab->window
: sprite.win;
if (grab->confineTo)
ConfineCursorToWindow(grab->confineTo, 0, 0, 0);
DoEnterLeaveEvents(oldWin, grab->window, 1);
motionHintWindow = ((WindowPtr) 0);
mouse->grabTime = time;
ptrGrab = *grab;
if (grab->cursor)
grab->cursor->refcnt++;
mouse->grab = &ptrGrab;
mouse->u.ptr.autoReleaseGrab = autoGrab;
PostNewCursor();
CheckGrabForSyncs(
mouse->grab, mouse, grab->pointerMode,
inputInfo.keyboard, grab->keyboardMode);
}
static void
DeactivatePointerGrab(mouse)
DeviceIntPtr mouse;
{
GrabPtr grab = mouse->grab;
DeviceIntPtr keybd = inputInfo.keyboard;
motionHintWindow = ((WindowPtr) 0);
mouse->grab = ((GrabPtr) 0);
mouse->sync.state = 0;
mouse->u.ptr.autoReleaseGrab = 0;
if (keybd->sync.other == grab)
keybd->sync.other = ((GrabPtr) 0);
DoEnterLeaveEvents(grab->window, sprite.win, 2);
if (grab->confineTo)
ConfineCursorToWindow(spriteTrace[0], 0, 0, 0);
PostNewCursor();
if (grab->cursor)
FreeCursor(grab->cursor, 0);
ComputeFreezes(keybd, mouse);
}
static void
ActivateKeyboardGrab(keybd, grab, time, passive)
GrabPtr grab;
register DeviceIntPtr keybd;
TimeStamp time;
Bool passive;
{
WindowPtr oldWin = (keybd->grab) ? keybd->grab->window
: keybd->u.keybd.focus.win;
DoFocusEvents(oldWin, grab->window, 1);
keybd->grabTime = time;
keybdGrab = *grab;
keybd->grab = &keybdGrab;
keybd->u.keybd.passiveGrab = passive;
CheckGrabForSyncs(
keybd->grab, keybd, grab->keyboardMode,
inputInfo.pointer, grab->pointerMode);
}
static void
DeactivateKeyboardGrab(keybd)
DeviceIntPtr keybd;
{
DeviceIntPtr mouse = inputInfo.pointer;
GrabPtr grab = keybd->grab;
keybd->grab = ((GrabPtr) 0);
keybd->sync.state = 0;
keybd->u.keybd.passiveGrab = 0;
if (mouse->sync.other == grab)
mouse->sync.other = ((GrabPtr) 0);
DoFocusEvents(grab->window, keybd->u.keybd.focus.win, 2);
ComputeFreezes(keybd, mouse);
}
static void
AllowSome(client, time, thisDev, otherDev, newState)
ClientPtr client;
TimeStamp time;
DeviceIntPtr thisDev, otherDev;
int newState;
{
Bool thisGrabbed, otherGrabbed;
TimeStamp grabTime;
thisGrabbed = thisDev->grab && (thisDev->grab->client == client);
otherGrabbed = otherDev->grab && (otherDev->grab->client == client);
if (!((thisGrabbed && thisDev->sync.state >= 5 ) ||
(otherGrabbed && thisDev->sync.other)))
return;
if (thisGrabbed &&
(!otherGrabbed ||
(CompareTimeStamps(otherDev->grabTime, thisDev->grabTime) == -1)))
grabTime = thisDev->grabTime;
else
grabTime = otherDev->grabTime;
if ((CompareTimeStamps(time, currentTime) == 1) ||
(CompareTimeStamps(time, grabTime) == -1))
return;
switch (newState)
{
case 1:
if (thisGrabbed)
thisDev->sync.state = 1;
if (otherGrabbed)
thisDev->sync.other = ((GrabPtr) 0);
ComputeFreezes(thisDev, otherDev);
break;
case 3:
if (thisGrabbed)
{
thisDev->sync.state = 3;
if (otherGrabbed)
thisDev->sync.other = ((GrabPtr) 0);
ComputeFreezes(thisDev, otherDev);
}
break;
case 2 :
if ((otherGrabbed && otherDev->sync.state >= 5 ) ||
(thisGrabbed && otherDev->sync.other))
{
if (thisGrabbed)
{
thisDev->sync.state = 1;
otherDev->sync.other = ((GrabPtr) 0);
}
if (otherGrabbed)
{
otherDev->sync.state = 1;
thisDev->sync.other = ((GrabPtr) 0);
}
ComputeFreezes(thisDev, otherDev);
}
break;
case 4:
if ((otherGrabbed && otherDev->sync.state >= 5 ) ||
(thisGrabbed && otherDev->sync.other))
{
if (thisGrabbed)
{
thisDev->sync.state = 4;
otherDev->sync.other = ((GrabPtr) 0);
}
if (otherGrabbed)
{
otherDev->sync.state = 4;
thisDev->sync.other = ((GrabPtr) 0);
}
ComputeFreezes(thisDev, otherDev);
}
break;
case 0:
if (thisGrabbed && thisDev->sync.state == 6)
{
syncEvents.replayDev = thisDev;
syncEvents.replayWin = thisDev->grab->window;
if (thisDev == inputInfo.pointer)
DeactivatePointerGrab(thisDev);
else
DeactivateKeyboardGrab(thisDev);
syncEvents.replayDev = (DeviceIntPtr) 0;
}
break;
}
}
int
ProcAllowEvents(client)
register ClientPtr client;
{
TimeStamp time;
DeviceIntPtr mouse = inputInfo.pointer;
DeviceIntPtr keybd = inputInfo.keyboard;
register xAllowEventsReq *stuff = (xAllowEventsReq *)client->requestBuffer;
if ((sizeof(xAllowEventsReq) >> 2) != stuff->length) return( 16 );
time = ClientTimeToServerTime(stuff->time);
switch (stuff->mode)
{
case 2:
AllowSome(client, time, mouse, keybd, 0);
break;
case 1:
AllowSome(client, time, mouse, keybd, 3);
break;
case 0:
AllowSome(client, time, mouse, keybd, 1);
break;
case 5:
AllowSome(client, time, keybd, mouse, 0);
break;
case 4:
AllowSome(client, time, keybd, mouse, 3);
break;
case 3:
AllowSome(client, time, keybd, mouse, 1);
break;
case 7:
AllowSome(client, time, keybd, mouse, 4);
break;
case 6:
AllowSome(client, time, keybd, mouse, 2 );
break;
default:
client->errorValue = stuff->mode;
return 2 ;
}
return 0 ;
}
void
ReleaseActiveGrabs(client)
ClientPtr client;
{
int i;
register DeviceIntPtr d;
for (i = 0; i < inputInfo.numDevices; i++)
{
d = inputInfo.devices[i];
if (d->grab && (d->grab->client == client))
{
if (d == inputInfo.keyboard)
DeactivateKeyboardGrab(d);
else if (d == inputInfo.pointer)
DeactivatePointerGrab(d);
else
d->grab = ((GrabPtr) 0);
}
}
}
int
TryClientEvents (client, pEvents, count, mask, filter, grab)
ClientPtr client;
GrabPtr grab;
xEvent *pEvents;
int count;
Mask mask, filter;
{
int i;
if (debug_events) ErrorF(
"Event([%d, %d], mask=0x%x), client=%d",
pEvents->u.u.type, pEvents->u.u.detail, mask, client->index);
if ((client) && (client != serverClient) && (!client->clientGone) &&
((filter == 0L) || (mask & filter)))
{
if (grab && (client != grab->client))
return -1;
if (pEvents->u.u.type == 6)
{
if (mask & (1L<<7) )
{
if (((motionHintWindow) ? ((motionHintWindow)->wid) : 0) == pEvents->u.keyButtonPointer.event)
{
if (debug_events) ErrorF("\n");
return 1;
}
pEvents->u.u.detail = 1 ;
}
else
{
pEvents->u.u.detail = 0;
}
}
if ((pEvents->u.u.type & 0177) != 11)
{
for (i = 0; i < count; i++)
pEvents[i].u.u.sequenceNumber = client->sequence;
}
if (filters[pEvents->u.u.type] &
( (1L<<2) | (1L<<3)
| (1L<<0) | (1L<<1) ))
SetCriticalOutputPending();
WriteEventsToClient(client, count, pEvents);
if (debug_events) ErrorF( " delivered\n");
return 1;
}
else
{
if (debug_events) ErrorF("\n");
return 0;
}
}
static int
DeliverEventsToWindow(pWin, pEvents, count, filter, grab)
WindowPtr pWin;
GrabPtr grab;
xEvent *pEvents;
int count;
Mask filter;
{
int deliveries = 0, nondeliveries = 0;
int attempt;
OtherClients *other;
ClientPtr client = ((ClientPtr) 0);
Mask deliveryMask;
if ((filter != 0L) && !(pWin->allEventMasks & filter))
return 0;
if (attempt = TryClientEvents(
pWin->client, pEvents, count, pWin->eventMask, filter, grab))
{
if (attempt > 0)
{
deliveries++;
client = pWin->client;
deliveryMask = pWin->eventMask;
} else
nondeliveries--;
}
if (filter != 0L)
for (other = ((OtherClientsPtr)(pWin)->otherClients); other; other = other->next)
{
if (attempt = TryClientEvents(
other->client, pEvents, count, other->mask, filter, grab))
{
if (attempt > 0)
{
deliveries++;
client = other->client;
deliveryMask = other->mask;
} else
nondeliveries--;
}
}
if ((pEvents->u.u.type == 4) && deliveries && (!grab))
{
GrabRec tempGrab;
tempGrab.device = inputInfo.pointer;
tempGrab.client = client;
tempGrab.window = pWin;
tempGrab.ownerEvents = (deliveryMask & (1L<<24) ) ? 1 : 0;
tempGrab.eventMask = deliveryMask;
tempGrab.keyboardMode = 1;
tempGrab.pointerMode = 1;
tempGrab.confineTo = ((WindowPtr) 0);
tempGrab.cursor = ((CursorPtr) 0);
ActivatePointerGrab(inputInfo.pointer, &tempGrab, currentTime, 1);
}
else if ((pEvents->u.u.type == 6) && deliveries)
motionHintWindow = pWin;
if (deliveries)
return deliveries;
return nondeliveries;
}
int
MaybeDeliverEventsToClient(pWin, pEvents, count, filter, dontDeliverToMe)
WindowPtr pWin;
xEvent *pEvents;
int count;
Mask filter;
ClientPtr dontDeliverToMe;
{
OtherClients * other;
if (pWin->eventMask & filter)
{
if (pWin->client == dontDeliverToMe)
return 0;
return TryClientEvents(
pWin->client, pEvents, count, pWin->eventMask, filter, ((GrabPtr) 0));
}
for (other = ((OtherClientsPtr)(pWin)->otherClients); other; other = other->next)
if (other->mask & filter)
{
if (other->client == dontDeliverToMe)
return 0;
return TryClientEvents(
other->client, pEvents, count, other->mask, filter, ((GrabPtr) 0));
}
return 2;
}
static WindowPtr
RootForWindow(pWin)
WindowPtr pWin;
{
return &WindowTable[pWin->drawable.pScreen->myNum];
}
static void
FixUpEventFromWindow(xE, pWin, child, calcChild)
xEvent *xE;
WindowPtr pWin;
Window child;
Bool calcChild;
{
if (calcChild)
{
WindowPtr w=spriteTrace[spriteTraceGood-1];
while (w)
{
if (w == pWin)
{
child = 0L ;
break;
}
if (w->parent == pWin)
{
child = w->wid;
break;
}
w = w->parent;
}
}
xE->u.keyButtonPointer.root = spriteTrace[0]->wid;
xE->u.keyButtonPointer.event = pWin->wid;
if (currentScreen == pWin->drawable.pScreen)
{
xE->u.keyButtonPointer.sameScreen = 1;
xE->u.keyButtonPointer.child = child;
xE->u.keyButtonPointer.eventX =
xE->u.keyButtonPointer.rootX - pWin->absCorner.x;
xE->u.keyButtonPointer.eventY =
xE->u.keyButtonPointer.rootY - pWin->absCorner.y;
}
else
{
xE->u.keyButtonPointer.sameScreen = 0;
xE->u.keyButtonPointer.child = 0L ;
xE->u.keyButtonPointer.eventX = 0;
xE->u.keyButtonPointer.eventY = 0;
}
}
int
DeliverDeviceEvents(pWin, xE, grab, stopAt)
register WindowPtr pWin, stopAt;
register xEvent *xE;
GrabPtr grab;
{
Mask filter;
int deliveries;
Window child = 0L ;
filter = filters[xE->u.u.type];
if ((filter != 0L) && !(filter & pWin->deliverableEvents))
return 0;
while (pWin)
{
FixUpEventFromWindow(xE, pWin, child, 0);
deliveries = DeliverEventsToWindow(pWin, xE, 1, filter, grab);
if (deliveries > 0)
return deliveries;
if ((deliveries < 0) ||
(pWin == stopAt) ||
(filter & pWin->dontPropagateMask))
return 0;
child = pWin->wid;
pWin = pWin->parent;
}
return 0;
}
int
DeliverEvents(pWin, xE, count, otherParent)
register WindowPtr pWin, otherParent;
register xEvent *xE;
int count;
{
Mask filter;
int deliveries;
if (!count)
return 0;
filter = filters[xE->u.u.type];
if ((filter & (1L<<19) ) && (xE->u.u.type != 16))
xE->u.destroyNotify.event = pWin->wid;
if (filter != ( (1L<<17) | (1L<<19) ))
return DeliverEventsToWindow(pWin, xE, count, filter, ((GrabPtr) 0));
deliveries = DeliverEventsToWindow(
pWin, xE, count, (1L<<17) , ((GrabPtr) 0));
if (pWin->parent)
{
xE->u.destroyNotify.event = pWin->parent->wid;
deliveries += DeliverEventsToWindow(
pWin->parent, xE, count, (1L<<19) , ((GrabPtr) 0));
if (xE->u.u.type == 21)
{
xE->u.destroyNotify.event = otherParent->wid;
deliveries += DeliverEventsToWindow(
otherParent, xE, count, (1L<<19) , ((GrabPtr) 0));
}
}
return deliveries;
}
static WindowPtr
XYToWindow(x, y)
int x, y;
{
register WindowPtr pWin;
spriteTraceGood = 1;
pWin = spriteTrace[0]->firstChild;
while (pWin)
{
if ((pWin->mapped) &&
(x >= pWin->absCorner.x - pWin->borderWidth) &&
(x < pWin->absCorner.x + (int)pWin->clientWinSize.width +
pWin->borderWidth) &&
(y >= pWin->absCorner.y - pWin->borderWidth) &&
(y < pWin->absCorner.y + (int)pWin->clientWinSize.height +
pWin->borderWidth))
{
if (spriteTraceGood >= spriteTraceSize)
{
spriteTraceSize += 10;
spriteTrace = (WindowPtr *)Xrealloc((pointer)(
spriteTrace), (unsigned long)( spriteTraceSize*sizeof(WindowPtr)));
}
spriteTrace[spriteTraceGood] = pWin;
pWin = spriteTrace[spriteTraceGood++]->firstChild;
}
else
pWin = pWin->nextSib;
}
return spriteTrace[spriteTraceGood-1];
}
static WindowPtr
CheckMotion(x, y, ignoreCache)
int x, y;
Bool ignoreCache;
{
WindowPtr prevSpriteWin = sprite.win;
if ((x != sprite.hot.x) || (y != sprite.hot.y))
{
sprite.win = XYToWindow(x, y);
sprite.hot.x = x;
sprite.hot.y = y;
}
else
{
if ((ignoreCache) || (!sprite.win))
sprite.win = XYToWindow(x, y);
}
if (sprite.win != prevSpriteWin)
{
if (prevSpriteWin != ((WindowPtr) 0))
DoEnterLeaveEvents(prevSpriteWin, sprite.win, 0);
PostNewCursor();
return ((WindowPtr) 0);
}
return sprite.win;
}
WindowsRestructured()
{
(void) CheckMotion(sprite.hot.x, sprite.hot.y, 1);
}
void
DefineInitialRootWindow(win)
WindowPtr win;
{
register CursorPtr c = win->cursor;
sprite.hot.x = currentScreen->width / 2;
sprite.hot.y = currentScreen->height / 2;
sprite.win = win;
sprite.current = c;
spriteTraceGood = 1;
spriteTrace[0] = win;
(*currentScreen->CursorLimits) (
currentScreen, win->cursor, &sprite.hotLimits, &sprite.physLimits);
(*currentScreen->ConstrainCursor) (
currentScreen, &sprite.physLimits);
(*currentScreen->SetCursorPosition) (
currentScreen, sprite.hot.x, sprite.hot.y, 0);
(*currentScreen->DisplayCursor) (currentScreen, c);
}
void
WindowHasNewCursor(pWin)
WindowPtr pWin;
{
PostNewCursor();
}
Bool
PointerConfinedToScreen()
{
register GrabPtr grab = inputInfo.pointer->grab;
return (grab && grab->confineTo);
}
void
NewCurrentScreen(newScreen, x, y)
ScreenPtr newScreen;
int x,y;
{
if (newScreen != currentScreen)
ConfineCursorToWindow(&WindowTable[newScreen->myNum], x, y, 1);
}
int
ProcWarpPointer(client)
ClientPtr client;
{
WindowPtr dest = 0;
int x, y;
ScreenPtr newScreen;
register xWarpPointerReq *stuff = (xWarpPointerReq *)client->requestBuffer;
if ((sizeof(xWarpPointerReq) >> 2) != stuff->length) return( 16 );
if (stuff->dstWid != 0L )
{
dest = LookupWindow(stuff->dstWid, client);
if (!dest)
return 3 ;
}
if (stuff->srcWid != 0L )
{
int winX, winY;
WindowPtr source = LookupWindow(stuff->srcWid, client);
if (!source)
return 3 ;
winX = source->absCorner.x;
winY = source->absCorner.y;
if (
(sprite.hot.x < (winX + stuff->srcX)) ||
(sprite.hot.y < (winY + stuff->srcY)) ||
((stuff->srcWidth != 0) &&
(winX + stuff->srcX + (int)stuff->srcWidth < sprite.hot.x)) ||
((stuff->srcHeight != 0) &&
(winY + stuff->srcY + (int)stuff->srcHeight < sprite.hot.y)) ||
(!PointInWindowIsVisible(source, sprite.hot.x, sprite.hot.y)))
return 0 ;
}
if (dest)
{
x = dest->absCorner.x + stuff->dstX;
y = dest->absCorner.y + stuff->dstY;
newScreen = dest->drawable.pScreen;
} else {
x = sprite.hot.x + stuff->dstX;
y = sprite.hot.y + stuff->dstY;
newScreen = currentScreen;
}
if (x < 0)
x = 0;
else if (x >= newScreen->width)
x = newScreen->width - 1;
if (y < 0)
y = 0;
else if (y >= newScreen->height)
y = newScreen->height - 1;
if (newScreen == currentScreen)
{
if (x < sprite.physLimits.x1)
x = sprite.physLimits.x1;
else if (x >= sprite.physLimits.x2)
x = sprite.physLimits.x2 - 1;
if (y < sprite.physLimits.y1)
y = sprite.physLimits.y1;
else if (y >= sprite.physLimits.y2)
y = sprite.physLimits.y2 - 1;
(*newScreen->SetCursorPosition)(newScreen, x, y, 1);
}
else if (!PointerConfinedToScreen())
{
NewCurrentScreen(newScreen, x, y);
}
return 0 ;
}
static void
NoticeTimeAndState(xE)
register xEvent *xE;
{
if (xE->u.keyButtonPointer.time < currentTime.milliseconds)
currentTime.months++;
currentTime.milliseconds = xE->u.keyButtonPointer.time;
xE->u.keyButtonPointer.pad1 = 0;
xE->u.keyButtonPointer.state = keyButtonState;
}
static Bool
CheckPassiveGrabsOnWindow(pWin, device, xE, isKeyboard)
WindowPtr pWin;
register DeviceIntPtr device;
register xEvent *xE;
int isKeyboard;
{
GrabPtr grab;
GrabRec temporaryGrab;
temporaryGrab.window = pWin;
temporaryGrab.device = device;
temporaryGrab.detail.exact = xE->u.u.detail;
temporaryGrab.detail.pMask = 0;
temporaryGrab.modifiersDetail.exact = xE->u.keyButtonPointer.state
& ( (1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6) | (1<<7) );
temporaryGrab.modifiersDetail.pMask = 0;
for (grab = ((GrabPtr)(pWin)->passiveGrabs); grab; grab = grab->next)
{
if (GrabMatchesSecond(&temporaryGrab, grab))
{
if (isKeyboard)
ActivateKeyboardGrab(device, grab, currentTime, 1);
else
ActivatePointerGrab(device, grab, currentTime, 1);
FixUpEventFromWindow(xE, grab->window, 0L , 1);
(void) TryClientEvents(grab->client, xE, 1, grab->eventMask,
filters[xE->u.u.type], grab);
if (device->sync.state == 5)
{
device->sync.event = *xE;
device->sync.state = 6;
}
return 1;
}
}
return 0;
}
static Bool
CheckDeviceGrabs(device, xE, checkFirst, isKeyboard)
register DeviceIntPtr device;
register xEvent *xE;
int checkFirst;
{
int i;
WindowPtr pWin;
i = checkFirst;
if (isKeyboard)
{
for (; i < focusTraceGood; i++)
{
pWin = focusTrace[i];
if (CheckPassiveGrabsOnWindow(pWin, device, xE, isKeyboard))
return 1;
}
if ((device->u.keybd.focus.win == ((WindowPtr) 0L )) ||
(i >= spriteTraceGood) ||
((i > 0) && (pWin != spriteTrace[i-1])))
return 0;
}
for (; i < spriteTraceGood; i++)
{
pWin = spriteTrace[i];
if (CheckPassiveGrabsOnWindow(pWin, device, xE, isKeyboard))
return 1;
}
return 0;
}
static void
NormalKeyboardEvent(keybd, xE, window)
xEvent *xE;
DeviceIntPtr keybd;
WindowPtr window;
{
WindowPtr focus = keybd->u.keybd.focus.win;
if (focus == ((WindowPtr) 0))
return;
if (focus == ((WindowPtr) 1L ))
{
DeliverDeviceEvents(window, xE, ((GrabPtr) 0), ((WindowPtr) 0));
return;
}
if ((focus == window) || IsParent(focus, window))
{
if (DeliverDeviceEvents(window, xE, ((GrabPtr) 0), focus))
return;
}
FixUpEventFromWindow(xE, focus, 0L , 0);
(void)DeliverEventsToWindow(focus, xE, 1, filters[xE->u.u.type], ((GrabPtr) 0));
}
static void
DeliverGrabbedEvent(xE, thisDev, otherDev, deactivateGrab, isKeyboard)
register xEvent *xE;
register DeviceIntPtr thisDev;
DeviceIntPtr otherDev;
Bool deactivateGrab;
Bool isKeyboard;
{
register GrabPtr grab = thisDev->grab;
int deliveries = 0;
if (grab->ownerEvents)
{
WindowPtr focus = isKeyboard ? thisDev->u.keybd.focus.win
: ((WindowPtr) 1L );
if (focus == ((WindowPtr) 1L ))
deliveries = DeliverDeviceEvents(sprite.win, xE, grab, ((WindowPtr) 0));
else if (focus && (focus == sprite.win || IsParent(focus, sprite.win)))
deliveries = DeliverDeviceEvents(sprite.win, xE, grab, focus);
}
if (!deliveries)
{
FixUpEventFromWindow(xE, grab->window, 0L , 1);
deliveries = TryClientEvents(grab->client, xE, 1, grab->eventMask,
filters[xE->u.u.type], grab);
if (deliveries && (xE->u.u.type == 6))
motionHintWindow = grab->window;
}
if (deliveries && !deactivateGrab && (xE->u.u.type != 6))
switch (thisDev->sync.state)
{
case 4:
otherDev->sync.frozen = 1;
if ((otherDev->sync.state == 4) &&
(otherDev->grab->client == thisDev->grab->client))
otherDev->sync.state = 5;
else
otherDev->sync.other = thisDev->grab;
case 3:
thisDev->sync.state = 6;
thisDev->sync.frozen = 1;
thisDev->sync.event = *xE;
break;
}
}
void
ProcessKeyboardEvent (xE, keybd)
register xEvent *xE;
register DeviceIntPtr keybd;
{
int key, bit;
register BYTE *kptr;
register int i;
register CARD16 modifiers;
register CARD16 mask;
GrabPtr grab = keybd->grab;
Bool deactivateGrab = 0;
if (keybd->sync.frozen)
{
EnqueueEvent(keybd, xE);
return;
}
NoticeTimeAndState(xE);
key = xE->u.u.detail;
kptr = &keybd->down[key >> 3];
bit = 1 << (key & 7);
modifiers = keyModifiersList[key];
switch (xE->u.u.type)
{
case 2:
if (*kptr & bit)
{
if (!modifiers)
{
xE->u.u.type = 3;
ProcessKeyboardEvent(xE, keybd);
xE->u.u.type = 2;
ProcessKeyboardEvent(xE, keybd);
}
return;
}
motionHintWindow = ((WindowPtr) 0);
*kptr |= bit;
for (i = 0, mask = 1; modifiers; i++, mask <<= 1)
{
if (mask & modifiers) {
modifierKeyCount[i]++;
keyButtonState |= mask;
modifiers &= ~mask;
}
}
if (!grab && CheckDeviceGrabs(keybd, xE, 0, 1))
{
keyThatActivatedPassiveGrab = key;
return;
}
break;
case 3:
if (!(*kptr & bit))
return;
motionHintWindow = ((WindowPtr) 0);
*kptr &= ~bit;
for (i = 0, mask = 1; modifiers; i++, mask <<= 1)
{
if (mask & modifiers) {
if (--modifierKeyCount[i] <= 0) {
keyButtonState &= ~mask;
modifierKeyCount[i] = 0;
}
modifiers &= ~mask;
}
}
if ((keybd->u.keybd.passiveGrab) &&
(key == keyThatActivatedPassiveGrab))
deactivateGrab = 1;
break;
default:
FatalError("Impossible keyboard event");
}
if (grab)
DeliverGrabbedEvent(xE, keybd, inputInfo.pointer, deactivateGrab,
1);
else
NormalKeyboardEvent(keybd, xE, sprite.win);
if (deactivateGrab)
DeactivateKeyboardGrab(keybd);
}
void
ProcessPointerEvent (xE, mouse)
register xEvent *xE;
register DeviceIntPtr mouse;
{
register int key;
register GrabPtr grab = mouse->grab;
Bool moveIt = 0;
Bool deactivateGrab = 0;
register BYTE *kptr;
int bit;
if (xE->u.keyButtonPointer.rootX < sprite.physLimits.x1)
{
xE->u.keyButtonPointer.rootX = sprite.physLimits.x1;
moveIt = 1;
}
else if (xE->u.keyButtonPointer.rootX >= sprite.physLimits.x2)
{
xE->u.keyButtonPointer.rootX = sprite.physLimits.x2 - 1;
moveIt = 1;
}
if (xE->u.keyButtonPointer.rootY < sprite.physLimits.y1)
{
xE->u.keyButtonPointer.rootY = sprite.physLimits.y1;
moveIt = 1;
}
else if (xE->u.keyButtonPointer.rootY >= sprite.physLimits.y2)
{
xE->u.keyButtonPointer.rootY = sprite.physLimits.y2 - 1;
moveIt = 1;
}
if (moveIt)
{
(*currentScreen->SetCursorPosition)(
currentScreen, xE->u.keyButtonPointer.rootX,
xE->u.keyButtonPointer.rootY, 0);
}
if (mouse->sync.frozen)
{
EnqueueEvent(mouse, xE);
return;
}
NoticeTimeAndState(xE);
key = xE->u.u.detail;
kptr = &mouse->down[key >> 3];
bit = 1 << (key & 7);
switch (xE->u.u.type)
{
case 4:
motionHintWindow = ((WindowPtr) 0);
buttonsDown++;
buttonMotionMask = (1L<<13) ;
*kptr |= bit;
xE->u.u.detail = mouse->u.ptr.map[key];
if (xE->u.u.detail == 0)
return;
if (xE->u.u.detail <= 5)
keyButtonState |= keyModifiersList[xE->u.u.detail];
filters[ 6] = ( (1L<<6) | (( (1<<8) | (1<<9) | (1<<10) | (1<<11) | (1<<12) ) & keyButtonState) | buttonMotionMask);
if (!grab)
if (CheckDeviceGrabs(mouse, xE, 0, 0))
return;
break;
case 5:
motionHintWindow = ((WindowPtr) 0);
buttonsDown--;
if (!buttonsDown)
buttonMotionMask = 0;
*kptr &= ~bit;
xE->u.u.detail = mouse->u.ptr.map[key];
if (xE->u.u.detail == 0)
return;
if (xE->u.u.detail <= 5)
keyButtonState &= ~keyModifiersList[xE->u.u.detail];
filters[ 6] = ( (1L<<6) | (( (1<<8) | (1<<9) | (1<<10) | (1<<11) | (1<<12) ) & keyButtonState) | buttonMotionMask);
if ((!(keyButtonState & ( (1<<8) | (1<<9) | (1<<10) | (1<<11) | (1<<12) ))) &&
(mouse->u.ptr.autoReleaseGrab))
deactivateGrab = 1;
break;
case 6:
if (!CheckMotion(xE->u.keyButtonPointer.rootX,
xE->u.keyButtonPointer.rootY,
0))
return;
break;
default:
FatalError("bogus pointer event from ddx");
}
if (grab)
DeliverGrabbedEvent(xE, mouse, inputInfo.keyboard, deactivateGrab,
0);
else
DeliverDeviceEvents(sprite.win, xE, ((GrabPtr) 0), ((WindowPtr) 0));
if (deactivateGrab)
DeactivatePointerGrab(mouse);
}
void
ProcessOtherEvent (xE, pDevice)
xEvent *xE;
DevicePtr pDevice;
{
}
void
RecalculateDeliverableEvents(pWin)
WindowPtr pWin;
{
OtherClients * others;
WindowPtr child;
pWin->allEventMasks = pWin->eventMask;
for (others = ((OtherClientsPtr)(pWin)->otherClients); others; others = others->next)
{
pWin->allEventMasks |= others->mask;
}
if (pWin->parent)
pWin->deliverableEvents = pWin->allEventMasks |
(pWin->parent->deliverableEvents & ~pWin->dontPropagateMask &
( (1L<<0) | (1L<<1) | (1L<<2) | (1L<<3) | ( (1L<<6) | (1L<<8) | (1L<<9) | (1L<<10) | (1L<<11) | (1L<<12) | (1L<<13) ) ));
else
pWin->deliverableEvents = pWin->allEventMasks;
for (child = pWin->firstChild; child; child = child->nextSib)
RecalculateDeliverableEvents(child);
}
static int
OtherClientGone(pWin, id)
WindowPtr pWin;
XID id;
{
register OtherClientsPtr *next;
register OtherClientsPtr other;
for (next = (OtherClientsPtr *)&(pWin->otherClients);
*next; next = &((*next)->next))
{
if ((other = *next)->resource == id)
{
*next = other->next;
Xfree((pointer)(other));
RecalculateDeliverableEvents(pWin);
return( 0 );
}
}
FatalError("client not on event list");
}
int
PassiveClientGone(pWin, id)
WindowPtr pWin;
XID id;
{
register GrabPtr *next;
register GrabPtr grab;
for (next = (GrabPtr *)&(pWin->passiveGrabs);
*next; next = &((*next)->next))
{
if ((grab = *next)->resource == id)
{
*next = grab->next;
DeleteGrab(grab);
return( 0 );
}
}
FatalError("client not on passive grab list");
}
int
EventSelectForWindow(pWin, client, mask)
WindowPtr pWin;
ClientPtr client;
Mask mask;
{
Mask check;
OtherClients * others;
check = (mask & ((1L<<20) | (1L<<18) | (1L<<2) ));
if (check & pWin->allEventMasks)
{
if ((pWin->client != client) && (check & pWin->eventMask))
return 10 ;
for (others = ((OtherClientsPtr)(pWin)->otherClients); others; others = others->next)
{
if ((others->client != client) && (check & others->mask))
return 10 ;
}
}
if (pWin->client == client)
{
check = pWin->eventMask;
pWin->eventMask = mask;
}
else
{
for (others = ((OtherClientsPtr)(pWin)->otherClients); others; others = others->next)
{
if (others->client == client)
{
check = others->mask;
if (mask == 0)
{
FreeResource(others->resource, 1);
return 0 ;
}
else
others->mask = mask;
goto maskSet;
}
}
check = 0;
others = (OtherClients *) Xalloc((unsigned long)(sizeof(OtherClients)));
others->client = client;
others->mask = mask;
others->resource = FakeClientID(client->index);
others->next = ((OtherClientsPtr)(pWin)->otherClients);
pWin->otherClients = (pointer)others;
AddResource(others->resource, 1<<6, (pointer)pWin,
OtherClientGone, 0);
}
maskSet:
if ((motionHintWindow == pWin) &&
(mask & (1L<<7) ) &&
!(check & (1L<<7) ) &&
!inputInfo.pointer->grab)
motionHintWindow = ((WindowPtr) 0);
RecalculateDeliverableEvents(pWin);
return 0 ;
}
int
EventSuppressForWindow(pWin, client, mask)
WindowPtr pWin;
ClientPtr client;
Mask mask;
{
pWin->dontPropagateMask = mask;
RecalculateDeliverableEvents(pWin);
return 0 ;
}
static WindowPtr
CommonAncestor(a, b)
register WindowPtr a, b;
{
for (b = b->parent; b; b = b->parent)
if (IsParent(b, a)) return b;
return ((WindowPtr) 0);
}
static void
EnterLeaveEvent(type, mode, detail, pWin)
int type, mode, detail;
WindowPtr pWin;
{
xEvent event;
DeviceIntPtr keybd = inputInfo.keyboard;
WindowPtr focus = keybd->u.keybd.focus.win;
GrabPtr grab = inputInfo.pointer->grab;
if ((pWin == motionHintWindow) && (detail != 2))
motionHintWindow = ((WindowPtr) 0);
if ((mode == 0) &&
grab && !grab->ownerEvents && (grab->window != pWin))
return;
event.u.u.type = type;
event.u.u.detail = detail;
event.u.enterLeave.time = currentTime.milliseconds;
event.u.enterLeave.rootX = sprite.hot.x;
event.u.enterLeave.rootY = sprite.hot.y;
FixUpEventFromWindow(&event, pWin, 0L , 1);
event.u.enterLeave.flags = event.u.keyButtonPointer.sameScreen ?
(1<<1) : 0;
event.u.enterLeave.state = keyButtonState;
event.u.enterLeave.mode = mode;
if ((focus != ((WindowPtr) 0L )) &&
((pWin == focus) || (focus == ((WindowPtr) 1L )) ||
IsParent(focus, pWin)))
event.u.enterLeave.flags |= (1<<0);
(void)DeliverEventsToWindow(pWin, &event, 1, filters[type], grab);
if (type == 7)
{
xKeymapEvent ke;
ke.type = 11;
bcopy((char *)&keybd->down[1], (char *)&ke.map[0], 31);
(void)DeliverEventsToWindow(pWin, (xEvent *)&ke, 1,
(1L<<14), grab);
}
}
static void
EnterNotifies(ancestor, child, mode, detail)
WindowPtr ancestor, child;
int mode, detail;
{
if (!child || (ancestor == child))
return;
EnterNotifies(ancestor, child->parent, mode, detail);
EnterLeaveEvent( 7, mode, detail, child);
}
static void
LeaveNotifies(child, ancestor, mode, detail, doAncestor)
WindowPtr child, ancestor;
int detail, mode;
{
register WindowPtr pWin;
if (ancestor == child)
return;
for (pWin = child->parent; pWin != ancestor; pWin = pWin->parent)
EnterLeaveEvent( 8, mode, detail, pWin);
if (doAncestor)
EnterLeaveEvent( 8, mode, detail, ancestor);
}
static void
DoEnterLeaveEvents(fromWin, toWin, mode)
WindowPtr fromWin, toWin;
int mode;
{
if (fromWin == toWin)
return;
if (IsParent(fromWin, toWin))
{
EnterLeaveEvent( 8, mode, 2, fromWin);
EnterNotifies(fromWin, toWin->parent, mode, 1);
EnterLeaveEvent( 7, mode, 0, toWin);
}
else if (IsParent(toWin, fromWin))
{
EnterLeaveEvent( 8, mode, 0, fromWin);
LeaveNotifies(fromWin, toWin, mode, 1, 0);
EnterLeaveEvent( 7, mode, 2, toWin);
}
else
{
WindowPtr common = CommonAncestor(toWin, fromWin);
EnterLeaveEvent( 8, mode, 3, fromWin);
if (common)
{
LeaveNotifies(
fromWin, common, mode, 4, 0);
EnterNotifies(common, toWin->parent, mode, 4);
}
else
{
LeaveNotifies(
fromWin, RootForWindow(fromWin), mode,
4, 1);
EnterNotifies(
RootForWindow(toWin), toWin->parent, mode, 4);
}
EnterLeaveEvent( 7, mode, 3, toWin);
}
}
static void
FocusEvent(type, mode, detail, pWin)
int type, mode, detail;
WindowPtr pWin;
{
xEvent event;
DeviceIntPtr keybd = inputInfo.keyboard;
event.u.focus.mode = mode;
event.u.u.type = type;
event.u.u.detail = detail;
event.u.focus.window = pWin->wid;
(void)DeliverEventsToWindow(pWin, &event, 1, filters[type], ((GrabPtr) 0));
if (type == 9)
{
xKeymapEvent ke;
ke.type = 11;
bcopy((char *)keybd->down, (char *)&ke.map[0], 31);
(void)DeliverEventsToWindow(pWin, (xEvent *)&ke, 1,
(1L<<14), ((GrabPtr) 0));
}
}
static Bool
FocusInEvents(ancestor, child, skipChild, mode, detail, doAncestor)
WindowPtr ancestor, child, skipChild;
int mode, detail;
Bool doAncestor;
{
if (child == ((WindowPtr) 0))
return ancestor == ((WindowPtr) 0);
if (ancestor == child)
{
if (doAncestor)
FocusEvent( 9, mode, detail, child);
return 1;
}
if (FocusInEvents(
ancestor, child->parent, skipChild, mode, detail, doAncestor))
{
if (child != skipChild)
FocusEvent( 9, mode, detail, child);
return 1;
}
return 0;
}
static void
FocusOutEvents(child, ancestor, mode, detail, doAncestor)
WindowPtr child, ancestor;
int detail;
Bool doAncestor;
{
register WindowPtr pWin;
for (pWin = child; pWin != ancestor; pWin = pWin->parent)
FocusEvent( 10, mode, detail, pWin);
if (doAncestor)
FocusEvent( 10, mode, detail, ancestor);
}
static void
DoFocusEvents(fromWin, toWin, mode)
WindowPtr fromWin, toWin;
int mode;
{
int out, in;
int i;
if (fromWin == toWin)
return;
out = (fromWin == ((WindowPtr) 0L )) ? 7 : 6;
in = (toWin == ((WindowPtr) 0L )) ? 7 : 6;
if ((toWin == ((WindowPtr) 0)) || (toWin == ((WindowPtr) 1L )))
{
if ((fromWin == ((WindowPtr) 0)) || (fromWin == ((WindowPtr) 1L )))
{
if (fromWin == ((WindowPtr) 1L ))
FocusOutEvents(sprite.win, spriteTrace[0], mode, 5, 1);
for (i=0; i<screenInfo.numScreens; i++)
FocusEvent( 10, mode, out, &WindowTable[i]);
}
else
{
if (IsParent(fromWin, sprite.win))
FocusOutEvents(sprite.win, fromWin, mode, 5, 0);
FocusEvent( 10, mode, 3, fromWin);
FocusOutEvents( fromWin->parent, ((WindowPtr) 0), mode,
4, 0);
}
for (i=0; i<screenInfo.numScreens; i++)
FocusEvent( 9, mode, in, &WindowTable[i]);
if (toWin == ((WindowPtr) 1L ))
(void)FocusInEvents(
spriteTrace[0], sprite.win, ((WindowPtr) 0), mode, 5, 1);
}
else
{
if ((fromWin == ((WindowPtr) 0)) || (fromWin == ((WindowPtr) 1L )))
{
if (fromWin == ((WindowPtr) 1L ))
FocusOutEvents(sprite.win, spriteTrace[0], mode, 5, 1);
for (i=0; i<screenInfo.numScreens; i++)
FocusEvent( 10, mode, out, &WindowTable[i]);
if (toWin->parent != ((WindowPtr) 0))
(void)FocusInEvents(
spriteTrace[0], toWin, toWin, mode, 4, 1);
FocusEvent( 9, mode, 3, toWin);
if (IsParent(toWin, sprite.win))
(void)FocusInEvents(
toWin, sprite.win, ((WindowPtr) 0), mode, 5, 0);
}
else
{
if (IsParent(toWin, fromWin))
{
FocusEvent( 10, mode, 0, fromWin);
FocusOutEvents(
fromWin->parent, toWin, mode, 1, 0);
FocusEvent( 9, mode, 2, toWin);
if ((IsParent(toWin, sprite.win)) &&
(sprite.win != fromWin) &&
(!IsParent(fromWin, sprite.win)) &&
(!IsParent(sprite.win, fromWin)))
(void)FocusInEvents(
toWin, sprite.win, ((WindowPtr) 0), mode,
5, 0);
}
else
if (IsParent(fromWin, toWin))
{
if ((IsParent(fromWin, sprite.win)) &&
(sprite.win != fromWin) &&
(!IsParent(toWin, sprite.win)) &&
(!IsParent(sprite.win, toWin)))
FocusOutEvents(
sprite.win, fromWin, mode, 5, 0);
FocusEvent( 10, mode, 2, fromWin);
(void)FocusInEvents(
fromWin, toWin, toWin, mode, 1, 0);
FocusEvent( 9, mode, 0, toWin);
}
else
{
WindowPtr common = CommonAncestor(toWin, fromWin);
if (IsParent(fromWin, sprite.win))
FocusOutEvents(
sprite.win, fromWin, mode, 5, 0);
FocusEvent( 10, mode, 3, fromWin);
if (fromWin->parent != ((WindowPtr) 0))
FocusOutEvents(
fromWin->parent, common, mode, 4,
0);
if (toWin->parent != ((WindowPtr) 0))
(void)FocusInEvents(
common, toWin, toWin, mode, 4,
0);
FocusEvent( 9, mode, 3, toWin);
if (IsParent(toWin, sprite.win))
(void)FocusInEvents(
toWin, sprite.win, ((WindowPtr) 0), mode,
5, 0);
}
}
}
}
int
ProcSetInputFocus(client)
ClientPtr client;
{
TimeStamp time;
WindowPtr focusWin;
int mode;
register DeviceIntPtr kbd = inputInfo.keyboard;
register FocusPtr focus = &kbd->u.keybd.focus;
register xSetInputFocusReq *stuff = (xSetInputFocusReq *)client->requestBuffer;
if ((sizeof(xSetInputFocusReq) >> 2) != stuff->length) return( 16 );
if ((stuff->revertTo != 2) &&
(stuff->revertTo != (int) 1L ) &&
(stuff->revertTo != (int) 0L ))
{
client->errorValue = stuff->revertTo;
return 2 ;
}
time = ClientTimeToServerTime(stuff->time);
if ((stuff->focus == 0L ) || (stuff->focus == 1L ))
focusWin = (WindowPtr)(stuff->focus);
else if (!(focusWin = LookupWindow(stuff->focus, client)))
return 3 ;
else
{
if(!focusWin->realized)
return( 8 );
}
if ((CompareTimeStamps(time, currentTime) == 1) ||
(CompareTimeStamps(time, focus->time) == -1))
return 0 ;
mode = (kbd->grab) ? 3 : 0;
DoFocusEvents(focus->win, focusWin, mode);
focus->time = time;
focus->revert = stuff->revertTo;
focus->win = focusWin;
if ((focusWin == ((WindowPtr) 0L )) || (focusWin == ((WindowPtr) 1L )))
focusTraceGood = 0;
else
{
int depth=0;
WindowPtr pWin;
for (pWin = focusWin; pWin; pWin = pWin->parent) depth++;
if (depth > focusTraceSize)
{
focusTraceSize = depth+1;
focusTrace = (WindowPtr *)Xrealloc((pointer)(
focusTrace), (unsigned long)( focusTraceSize*sizeof(WindowPtr)));
}
focusTraceGood = depth;
for (pWin = focusWin; pWin; pWin = pWin->parent, depth--)
focusTrace[depth-1] = pWin;
}
return 0 ;
}
int
ProcGetInputFocus(client)
ClientPtr client;
{
xGetInputFocusReply rep;
register xReq *stuff = (xReq *)client->requestBuffer;
FocusPtr focus = &(inputInfo.keyboard->u.keybd.focus);
if ((sizeof(xReq) >> 2) != stuff->length) return( 16 );
rep.type = 1 ;
rep.length = 0;
rep.sequenceNumber = client->sequence;
if (focus->win == ((WindowPtr) 0L ))
rep.focus = 0L ;
else if (focus->win == ((WindowPtr) 1L ))
rep.focus = 1L ;
else rep.focus = focus->win->wid;
rep.revertTo = focus->revert;
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGetInputFocusReply), &rep); else (void) WriteToClient(client, sizeof(xGetInputFocusReply), (char *) &rep);;
return 0 ;
}
int
ProcGrabPointer(client)
ClientPtr client;
{
xGrabPointerReply rep;
DeviceIntPtr device = inputInfo.pointer;
GrabPtr grab = device->grab;
WindowPtr pWin, confineTo;
CursorPtr cursor;
register xGrabPointerReq *stuff = (xGrabPointerReq *)client->requestBuffer;
TimeStamp time;
if ((sizeof(xGrabPointerReq) >> 2) != stuff->length) return( 16 );
if ((stuff->pointerMode != 0) &&
(stuff->pointerMode != 1))
{
client->errorValue = stuff->pointerMode;
return 2 ;
}
if ((stuff->keyboardMode != 0) &&
(stuff->keyboardMode != 1))
{
client->errorValue = stuff->keyboardMode;
return 2 ;
}
pWin = LookupWindow(stuff->grabWindow, client);
if (!pWin)
return 3 ;
if (stuff->confineTo == 0L )
confineTo = ((WindowPtr) 0);
else
{
confineTo = LookupWindow(stuff->confineTo, client);
if (!confineTo)
return 3 ;
}
if (stuff->cursor == 0L )
cursor = ((CursorPtr) 0);
else
{
cursor = (CursorPtr)LookupID(stuff->cursor, 1<<2, 0);
if (!cursor)
{
client->errorValue = stuff->cursor;
return 6 ;
}
}
time = ClientTimeToServerTime(stuff->time);
rep.type = 1 ;
rep.sequenceNumber = client->sequence;
rep.length = 0;
if ((grab) && (grab->client != client))
rep.status = 1;
else if ((!pWin->realized) ||
(confineTo &&
!(confineTo->realized &&
(* confineTo->drawable.pScreen->RegionNotEmpty)
(confineTo->borderSize))))
rep.status = 3;
else if (device->sync.frozen &&
((device->sync.other && (device->sync.other->client != client)) ||
((device->sync.state >= 5 ) &&
(device->grab->client != client))))
rep.status = 4;
else if ((CompareTimeStamps(time, currentTime) == 1) ||
(device->grab &&
(CompareTimeStamps(time, device->grabTime) == -1)))
rep.status = 2;
else
{
GrabRec tempGrab;
if (grab && grab->confineTo && !confineTo)
ConfineCursorToWindow(spriteTrace[0], 0, 0, 0);
tempGrab.cursor = cursor;
tempGrab.client = client;
tempGrab.ownerEvents = stuff->ownerEvents;
tempGrab.eventMask = stuff->eventMask;
tempGrab.confineTo = confineTo;
tempGrab.window = pWin;
tempGrab.keyboardMode = stuff->keyboardMode;
tempGrab.pointerMode = stuff->pointerMode;
tempGrab.device = inputInfo.pointer;
ActivatePointerGrab(inputInfo.pointer, &tempGrab, time, 0);
rep.status = 0;
}
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGrabPointerReply), &rep); else (void) WriteToClient(client, sizeof(xGrabPointerReply), (char *) &rep);;
return 0 ;
}
int
ProcChangeActivePointerGrab(client)
ClientPtr client;
{
DeviceIntPtr device = inputInfo.pointer;
register GrabPtr grab = device->grab;
CursorPtr newCursor;
register xChangeActivePointerGrabReq *stuff = (xChangeActivePointerGrabReq *)client->requestBuffer;
TimeStamp time;
if ((sizeof(xChangeActivePointerGrabReq) >> 2) != stuff->length) return( 16 );
if (!grab)
return 0 ;
if (grab->client != client)
return 10 ;
if (stuff->cursor == 0L )
newCursor = ((CursorPtr) 0);
else
{
newCursor = (CursorPtr)LookupID(stuff->cursor, 1<<2, 0);
if (!newCursor)
{
client->errorValue = stuff->cursor;
return 6 ;
}
}
time = ClientTimeToServerTime(stuff->time);
if ((CompareTimeStamps(time, currentTime) == 1) ||
(CompareTimeStamps(time, device->grabTime) == -1))
return 0 ;
if (grab->cursor)
FreeCursor(grab->cursor, 0);
grab->cursor = newCursor;
if (newCursor)
newCursor->refcnt++;
PostNewCursor();
grab->eventMask = stuff->eventMask;
return 0 ;
}
int
ProcUngrabPointer(client)
ClientPtr client;
{
DeviceIntPtr device = inputInfo.pointer;
GrabPtr grab = device->grab;
TimeStamp time;
register xResourceReq *stuff = (xResourceReq *)client->requestBuffer;
if ((sizeof(xResourceReq) >> 2) != stuff->length) return( 16 );
time = ClientTimeToServerTime(stuff->id);
if ((CompareTimeStamps(time, currentTime) != 1) &&
(CompareTimeStamps(time, device->grabTime) != -1) &&
(grab) && (grab->client == client))
DeactivatePointerGrab(inputInfo.pointer);
return 0 ;
}
int
ProcGrabKeyboard(client)
ClientPtr client;
{
xGrabKeyboardReply rep;
DeviceIntPtr device = inputInfo.keyboard;
GrabPtr grab = device->grab;
WindowPtr pWin;
TimeStamp time;
register xGrabKeyboardReq *stuff = (xGrabKeyboardReq *)client->requestBuffer;
if ((sizeof(xGrabKeyboardReq) >> 2) != stuff->length) return( 16 );
if ((stuff->pointerMode != 0) &&
(stuff->pointerMode != 1))
{
client->errorValue = stuff->pointerMode;
return 2 ;
}
if ((stuff->keyboardMode != 0) &&
(stuff->keyboardMode != 1))
{
client->errorValue = stuff->keyboardMode;
return 2 ;
}
pWin = LookupWindow(stuff->grabWindow, client);
if (!pWin)
return 3 ;
time = ClientTimeToServerTime(stuff->time);
rep.type = 1 ;
rep.sequenceNumber = client->sequence;
rep.length = 0;
if ((grab) && (grab->client != client))
rep.status = 1;
else if (!pWin->realized)
rep.status = 3;
else if ((CompareTimeStamps(time, currentTime) == 1) ||
(device->grab &&
(CompareTimeStamps(time, device->grabTime) == -1)))
rep.status = 2;
else if (device->sync.frozen &&
((device->sync.other && (device->sync.other->client != client)) ||
((device->sync.state >= 5 ) &&
(device->grab->client != client))))
rep.status = 4;
else
{
GrabRec tempGrab;
tempGrab.window = pWin;
tempGrab.client = client;
tempGrab.ownerEvents = stuff->ownerEvents;
tempGrab.keyboardMode = stuff->keyboardMode;
tempGrab.pointerMode = stuff->pointerMode;
tempGrab.eventMask = (1L<<0) | (1L<<1) ;
tempGrab.device = inputInfo.keyboard;
ActivateKeyboardGrab(
device, &tempGrab, ClientTimeToServerTime(stuff->time), 0);
rep.status = 0;
}
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGrabKeyboardReply), &rep); else (void) WriteToClient(client, sizeof(xGrabKeyboardReply), (char *) &rep);;
return 0 ;
}
int
ProcUngrabKeyboard(client)
ClientPtr client;
{
DeviceIntPtr device = inputInfo.keyboard;
GrabPtr grab = device->grab;
TimeStamp time;
register xResourceReq *stuff = (xResourceReq *)client->requestBuffer;
if ((sizeof(xResourceReq) >> 2) != stuff->length) return( 16 );
time = ClientTimeToServerTime(stuff->id);
if ((CompareTimeStamps(time, currentTime) != 1) &&
(CompareTimeStamps(time, device->grabTime) != -1) &&
(grab) && (grab->client == client))
DeactivateKeyboardGrab(device);
return 0 ;
}
static void
SetPointerStateMasks()
{
keyModifiersList[1] = (1<<8);
keyModifiersList[2] = (1<<9);
keyModifiersList[3] = (1<<10);
keyModifiersList[4] = (1<<11);
keyModifiersList[5] = (1<<12);
}
static void
SetKeyboardStateMasks(keybd)
DeviceIntPtr keybd;
{
int i;
for (i = 8; i < 256; i++)
keyModifiersList[i] = (CARD16) keybd->u.keybd.modifierMap[i];
}
DevicePtr
AddInputDevice(deviceProc, autoStart)
DeviceProc deviceProc;
Bool autoStart;
{
DeviceIntPtr d;
if (inputInfo.numDevices == inputInfo.arraySize)
{
inputInfo.arraySize += 5;
inputInfo.devices = (DeviceIntPtr *)Xrealloc((pointer)(
inputInfo.devices), (unsigned long)(
inputInfo.arraySize * sizeof(DeviceIntPtr)));
}
d = (DeviceIntPtr) Xalloc((unsigned long)(sizeof(DeviceIntRec)));
inputInfo.devices[inputInfo.numDevices++] = d;
d->public.on = 0;
d->public.processInputProc = NoopDDA;
d->deviceProc = deviceProc;
d->startup = autoStart;
d->sync.frozen = 0;
d->sync.other = ((GrabPtr) 0);
d->sync.state = 0;
d->grab = ((GrabPtr) 0);
bzero((char *)d->down, sizeof(d->down));
return &d->public;
}
DevicesDescriptor
GetInputDevices()
{
DevicesDescriptor devs;
devs.count = inputInfo.numDevices;
devs.devices = (DevicePtr *)inputInfo.devices;
return devs;
}
void
InitEvents()
{
curKeySyms.map = (KeySym *) 0;
curKeySyms.minKeyCode = 0;
curKeySyms.maxKeyCode = 0;
curKeySyms.mapWidth = 0;
currentScreen = &screenInfo.screen[0];
inputInfo.numDevices = 0;
if (spriteTraceSize == 0)
{
spriteTraceSize = 20;
spriteTrace = (WindowPtr *)Xalloc((unsigned long)(20*sizeof(WindowPtr)));
}
spriteTraceGood = 0;
if (focusTraceSize == 0)
{
focusTraceSize = 20;
focusTrace = (WindowPtr *)Xalloc((unsigned long)(20*sizeof(WindowPtr)));
}
focusTraceGood = 0;
lastEventMask = (1L<<24) ;
sprite.win = ((WindowPtr) 0);
sprite.current = ((CursorPtr) 0);
sprite.hotLimits.x1 = 0;
sprite.hotLimits.y1 = 0;
sprite.hotLimits.x2 = currentScreen->width;
sprite.hotLimits.y2 = currentScreen->height;
motionHintWindow = ((WindowPtr) 0);
syncEvents.replayDev = (DeviceIntPtr) 0;
syncEvents.pending.forw = &syncEvents.pending;
syncEvents.pending.back = &syncEvents.pending;
syncEvents.free.forw = &syncEvents.free;
syncEvents.free.back = &syncEvents.free;
syncEvents.num = 0;
syncEvents.playingEvents = 0;
currentTime.months = 0;
currentTime.milliseconds = GetTimeInMillis();
}
int
InitAndStartDevices(argc, argv)
int argc;
char *argv[];
{
int i;
DeviceIntPtr d;
for (i=0; i<8; i++)
modifierKeyCount[i] = 0;
keyButtonState = 0;
buttonsDown = 0;
buttonMotionMask = 0;
for (i = 0; i < inputInfo.numDevices; i++)
{
d = inputInfo.devices[i];
if ((*d->deviceProc) (d, 0, argc, argv) == 0 )
d->inited = 1;
else
d->inited = 0;
}
for (i = 0; i < inputInfo.numDevices; i++)
{
d = inputInfo.devices[i];
if ((d->startup) && (d->inited))
(*d->deviceProc) (d, 1, argc, argv);
}
if (inputInfo.pointer && inputInfo.pointer->inited &&
inputInfo.keyboard && inputInfo.keyboard->inited)
return 0 ;
return 17 ;
}
void
CloseDownDevices(argc, argv)
int argc;
char *argv[];
{
int i;
DeviceIntPtr d;
Xfree((pointer)(curKeySyms.map));
curKeySyms.map = (KeySym *) 0;
for (i = inputInfo.numDevices - 1; i >= 0; i--)
{
d = inputInfo.devices[i];
if (d->inited)
(*d->deviceProc) (d, 3, argc, argv);
inputInfo.numDevices = i;
Xfree((pointer)(d));
}
}
int
NumMotionEvents()
{
return inputInfo.numMotionEvents;
}
void
RegisterPointerDevice(device, numMotionEvents)
DevicePtr device;
int numMotionEvents;
{
inputInfo.pointer = (DeviceIntPtr)device;
inputInfo.numMotionEvents = numMotionEvents;
device->processInputProc = ProcessPointerEvent;
}
void
RegisterKeyboardDevice(device)
DevicePtr device;
{
inputInfo.keyboard = (DeviceIntPtr)device;
device->processInputProc = ProcessKeyboardEvent;
}
void
InitPointerDeviceStruct(device, map, mapLength, motionProc, controlProc)
DevicePtr device;
BYTE *map;
int mapLength;
void (*controlProc)();
int (*motionProc)();
{
int i;
DeviceIntPtr mouse = (DeviceIntPtr)device;
mouse->grab = ((GrabPtr) 0);
mouse->public.on = 0;
mouse->u.ptr.mapLength = mapLength;
mouse->u.ptr.map[0] = 0;
for (i = 1; i <= mapLength; i++)
mouse->u.ptr.map[i] = map[i];
mouse->u.ptr.ctrl = defaultPointerControl;
mouse->u.ptr.GetMotionProc = motionProc;
mouse->u.ptr.CtrlProc = controlProc;
mouse->u.ptr.autoReleaseGrab = 0;
if (mouse == inputInfo.pointer)
SetPointerStateMasks();
(*mouse->u.ptr.CtrlProc)(mouse, &mouse->u.ptr.ctrl);
}
void
QueryMinMaxKeyCodes(minCode, maxCode)
KeyCode *minCode, *maxCode;
{
*minCode = curKeySyms.minKeyCode;
*maxCode = curKeySyms.maxKeyCode;
}
static void
SetKeySymsMap(pKeySyms)
KeySymsPtr pKeySyms;
{
int i, j;
int rowDif = pKeySyms->minKeyCode - curKeySyms.minKeyCode;
if (pKeySyms->mapWidth < curKeySyms.mapWidth)
{
for (i = pKeySyms->minKeyCode; i <= pKeySyms->maxKeyCode; i++)
{
for (j = 0; j < pKeySyms->mapWidth; j++)
curKeySyms.map[(((i - curKeySyms.minKeyCode)*curKeySyms.mapWidth) + ( j))] = pKeySyms->map[(((i-pKeySyms->minKeyCode)*pKeySyms->mapWidth) + ( j))];
for (j = pKeySyms->mapWidth; j < curKeySyms.mapWidth; j++)
curKeySyms.map[(((i - curKeySyms.minKeyCode)*curKeySyms.mapWidth) + ( j))] = 0L ;
}
return;
}
else if (pKeySyms->mapWidth > curKeySyms.mapWidth)
{
KeySym *map;
int bytes = sizeof(KeySym) * pKeySyms->mapWidth *
(curKeySyms.maxKeyCode - curKeySyms.minKeyCode + 1);
map = (KeySym *)Xalloc((unsigned long)(bytes));
bzero((char *)map, bytes);
if (curKeySyms.map)
{
for (i = 0; i <= curKeySyms.maxKeyCode-curKeySyms.minKeyCode; i++)
bcopy(
(char *)&curKeySyms.map[i*curKeySyms.mapWidth],
(char *)&map[i*pKeySyms->mapWidth],
curKeySyms.mapWidth * sizeof(KeySym));
Xfree((pointer)(curKeySyms.map));
}
curKeySyms.mapWidth = pKeySyms->mapWidth;
curKeySyms.map = map;
}
bcopy(
(char *)pKeySyms->map,
(char *)&curKeySyms.map[rowDif * curKeySyms.mapWidth],
(pKeySyms->maxKeyCode - pKeySyms->minKeyCode + 1) *
curKeySyms.mapWidth * sizeof(KeySym));
}
static CARD8
WidthOfModifierTable(modifierMap)
CARD8 modifierMap[];
{
int i;
CARD8 keysPerModifier[8],maxKeysPerMod;
maxKeysPerMod = 0;
bzero((char *)keysPerModifier, sizeof keysPerModifier);
for (i = 8; i < 256; i++) {
int j;
CARD8 mask;
for (j = 0, mask = 1; j < 8; j++, mask <<= 1) {
if (mask & modifierMap[i]) {
if (++keysPerModifier[j] > maxKeysPerMod) {
maxKeysPerMod = keysPerModifier[j];
}
if (debug_modifiers)
ErrorF("Key 0x%x modifier %d sequence %d\n",
i, j, keysPerModifier[j]);
}
}
}
if (debug_modifiers)
ErrorF("Max Keys per Modifier = %d\n", maxKeysPerMod);
if (modifierKeyMap)
Xfree((pointer)(modifierKeyMap));
modifierKeyMap = (KeyCode *)Xalloc((unsigned long)(8*maxKeysPerMod));
bzero((char *)modifierKeyMap, 8*maxKeysPerMod);
bzero((char *)keysPerModifier, sizeof keysPerModifier);
for (i = 8; i < 256; i++) {
int j;
CARD8 mask;
for (j = 0, mask = 1; j < 8; j++, mask <<= 1) {
if (mask & modifierMap[i]) {
if (debug_modifiers)
ErrorF("Key 0x%x modifier %d index %d\n", i, j,
j*maxKeysPerMod+keysPerModifier[j]);
modifierKeyMap[j*maxKeysPerMod+keysPerModifier[j]] = i;
keysPerModifier[j]++;
}
}
}
return (maxKeysPerMod);
}
void
InitKeyboardDeviceStruct(device, pKeySyms, pModifiers,
bellProc, controlProc)
DevicePtr device;
KeySymsPtr pKeySyms;
CARD8 pModifiers[];
void (*bellProc)();
void (*controlProc)();
{
DeviceIntPtr keybd = (DeviceIntPtr)device;
keybd->grab = ((GrabPtr) 0);
keybd->public.on = 0;
keybd->u.keybd.ctrl = defaultKeyboardControl;
keybd->u.keybd.BellProc = bellProc;
keybd->u.keybd.CtrlProc = controlProc;
keybd->u.keybd.focus.win = ((WindowPtr) 1L );
keybd->u.keybd.focus.revert = 0L ;
keybd->u.keybd.focus.time = currentTime;
keybd->u.keybd.passiveGrab = 0;
curKeySyms.minKeyCode = pKeySyms->minKeyCode;
curKeySyms.maxKeyCode = pKeySyms->maxKeyCode;
{
int i;
for (i = 8; i < 256; i++) {
keybd->u.keybd.modifierMap[i] = pModifiers[i];
}
maxKeysPerModifier = WidthOfModifierTable(pModifiers);
}
if (keybd == inputInfo.keyboard)
{
SetKeyboardStateMasks(keybd);
SetKeySymsMap(pKeySyms);
}
(*keybd->u.keybd.CtrlProc)(keybd, &keybd->u.keybd.ctrl);
}
void
InitOtherDeviceStruct(device, map, mapLength)
DevicePtr device;
BYTE *map;
int mapLength;
{
int i;
DeviceIntPtr other = (DeviceIntPtr)device;
other->grab = ((GrabPtr) 0);
other->public.on = 0;
other->u.other.mapLength = mapLength;
other->u.other.map[0] = 0;
for (i = 1; i <= mapLength; i++)
other->u.other.map[i] = map[i];
other->u.other.focus.win = ((WindowPtr) 0L );
other->u.other.focus.revert = 0L ;
other->u.other.focus.time = currentTime;
}
GrabPtr
SetDeviceGrab(device, grab)
DevicePtr device;
GrabPtr grab;
{
register DeviceIntPtr dev = (DeviceIntPtr)device;
GrabPtr oldGrab = dev->grab;
dev->grab = grab;
return oldGrab;
}
# 2777 "events.c"
DevicePtr
LookupKeyboardDevice()
{
return &inputInfo.keyboard->public;
}
DevicePtr
LookupPointerDevice()
{
return &inputInfo.pointer->public;
}
static int
SendMappingNotify(request, firstKeyCode, count)
CARD8 request, count;
KeyCode firstKeyCode;
{
int i;
xEvent event;
event.u.u.type = 34;
event.u.mappingNotify.request = request;
if (request == 1)
{
event.u.mappingNotify.firstKeyCode = firstKeyCode;
event.u.mappingNotify.count = count;
}
for (i=1; i<currentMaxClients; i++)
if (clients[i] && ! clients[i]->clientGone)
{
event.u.u.sequenceNumber = clients[i]->sequence;
WriteEventsToClient(clients[i], 1, &event);
}
}
static Bool
BadDeviceMap(buff, length, low, high, errval)
register BYTE *buff;
int length;
unsigned low, high;
XID *errval;
{
register int i, j;
for (i = 0; i < length; i++)
if (buff[i])
{
if ((low > buff[i]) || (high < buff[i]))
{
*errval = buff[i];
return 1;
}
for (j = i + 1; j < length; j++)
if (buff[i] == buff[j])
{
*errval = buff[i];
return 1;
}
}
return 0;
}
static Bool
AllModifierKeysAreUp(map1, per1, map2, per2)
register CARD8 *map1, *map2;
int per1, per2;
{
register int i, j, k;
for (i = 8; --i >= 0; map2 += per2)
{
for (j = per1; --j >= 0; map1++)
{
if (*map1 && (((BYTE *) (inputInfo.keyboard->down))[( *map1)>>3] & (1 << (( *map1) & 7))))
{
for (k = per2; (--k >= 0) && (*map1 != map2[k]);)
;
if (k < 0)
return 0;
}
}
}
return 1;
}
int
ProcSetModifierMapping(client)
ClientPtr client;
{
xSetModifierMappingReply rep;
register xSetModifierMappingReq *stuff = (xSetModifierMappingReq *)client->requestBuffer;
KeyCode *inputMap;
int inputMapLen;
register int i;
if ((sizeof(xSetModifierMappingReq) >> 2) > stuff->length ) return( 16 );
if (stuff->length != ((stuff->numKeyPerModifier<<1) +
(sizeof (xSetModifierMappingReq)>>2)))
return 16 ;
inputMapLen = 8*stuff->numKeyPerModifier;
inputMap = (KeyCode *)&stuff[1];
i = inputMapLen;
while (i--) {
if (inputMap[i]
&& (inputMap[i] < curKeySyms.minKeyCode
|| inputMap[i] > curKeySyms.maxKeyCode)) {
client->errorValue = inputMap[i];
return 2 ;
}
}
rep.type = 1 ;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.success = 0;
if (!AllModifierKeysAreUp(modifierKeyMap, (int)maxKeysPerModifier,
inputMap, (int)stuff->numKeyPerModifier)
||
!AllModifierKeysAreUp(inputMap, (int)stuff->numKeyPerModifier,
modifierKeyMap, (int)maxKeysPerModifier)) {
if (debug_modifiers)
ErrorF("Busy\n");
rep.success = 1;
} else {
for (i = 0; i < inputMapLen; i++) {
if (inputMap[i] && !LegalModifier(inputMap[i])) {
if (debug_modifiers)
ErrorF("Key 0x%x refused\n", inputMap[i]);
rep.success = 2;
break;
}
}
}
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xSetModifierMappingReply), &rep); else (void) WriteToClient(client, sizeof(xSetModifierMappingReply), (char *) &rep);;
if (rep.success == 0)
{
if (modifierKeyMap)
Xfree((pointer)(modifierKeyMap));
modifierKeyMap = (KeyCode *)Xalloc((unsigned long)(inputMapLen));
bcopy((char *)inputMap, (char *)modifierKeyMap, inputMapLen);
maxKeysPerModifier = stuff->numKeyPerModifier;
for (i = 0; i < 256; i++)
inputInfo.keyboard->u.keybd.modifierMap[i] = 0;
for (i = 0; i < inputMapLen; i++) if (inputMap[i]) {
inputInfo.keyboard->u.keybd.modifierMap[inputMap[i]]
|= (1<<(i/maxKeysPerModifier));
if (debug_modifiers)
ErrorF("Key 0x%x mod %d\n", inputMap[i], i/maxKeysPerModifier);
}
SetKeyboardStateMasks(inputInfo.keyboard);
SendMappingNotify( 0, 0, 0);
}
return(client->noClientException);
}
int
ProcGetModifierMapping(client)
ClientPtr client;
{
xGetModifierMappingReply rep;
register xReq *stuff = (xReq *)client->requestBuffer;
if ((sizeof(xReq) >> 2) != stuff->length) return( 16 );
rep.type = 1 ;
rep.numKeyPerModifier = maxKeysPerModifier;
rep.sequenceNumber = client->sequence;
rep.length = 2*maxKeysPerModifier;
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGetModifierMappingReply), &rep); else (void) WriteToClient(client, sizeof(xGetModifierMappingReply), (char *) &rep);;
(void)WriteToClient(client, 8*maxKeysPerModifier, (char *)modifierKeyMap);
return client->noClientException;
}
int
ProcChangeKeyboardMapping(client)
ClientPtr client;
{
register xChangeKeyboardMappingReq *stuff = (xChangeKeyboardMappingReq *)client->requestBuffer;
unsigned len;
KeySymsRec keysyms;
if ((sizeof(xChangeKeyboardMappingReq) >> 2) > stuff->length ) return( 16 );
len = stuff->length - (sizeof(xChangeKeyboardMappingReq) >> 2);
if (len != (stuff->keyCodes * stuff->keySymsPerKeyCode))
return 16 ;
if ((stuff->firstKeyCode < curKeySyms.minKeyCode) ||
(stuff->firstKeyCode + stuff->keyCodes - 1 > curKeySyms.maxKeyCode))
{
client->errorValue = stuff->firstKeyCode;
return 2 ;
}
if (stuff->keySymsPerKeyCode == 0)
{
client->errorValue = 0;
return 2 ;
}
keysyms.minKeyCode = stuff->firstKeyCode;
keysyms.maxKeyCode = stuff->firstKeyCode + stuff->keyCodes - 1;
keysyms.mapWidth = stuff->keySymsPerKeyCode;
keysyms.map = (KeySym *)&stuff[1];
SetKeySymsMap(&keysyms);
SendMappingNotify( 1, stuff->firstKeyCode, stuff->keyCodes);
return client->noClientException;
}
int
ProcSetPointerMapping(client)
ClientPtr client;
{
register xSetPointerMappingReq *stuff = (xSetPointerMappingReq *)client->requestBuffer;
BYTE *map;
xSetPointerMappingReply rep;
register int i;
if ((sizeof(xSetPointerMappingReq) >> 2) > stuff->length ) return( 16 );
if (stuff->length != (sizeof(xSetPointerMappingReq) + stuff->nElts + 3)>>2)
return 16 ;
rep.type = 1 ;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.success = 0;
map = (BYTE *)&stuff[1];
if (stuff->nElts != inputInfo.pointer->u.ptr.mapLength)
{
client->errorValue = stuff->nElts;
return 2 ;
}
if (BadDeviceMap(&map[0], (int)stuff->nElts, 1, 255, &client->errorValue))
return 2 ;
for (i=0; i < stuff->nElts; i++)
if ((inputInfo.pointer->u.ptr.map[i + 1] != map[i]) &&
(((BYTE *) (inputInfo.pointer->down))[( i + 1)>>3] & (1 << (( i + 1) & 7))))
{
rep.success = 1;
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xSetPointerMappingReply), &rep); else (void) WriteToClient(client, sizeof(xSetPointerMappingReply), (char *) &rep);;
return 0 ;
}
for (i = 0; i < stuff->nElts; i++)
inputInfo.pointer->u.ptr.map[i + 1] = map[i];
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xSetPointerMappingReply), &rep); else (void) WriteToClient(client, sizeof(xSetPointerMappingReply), (char *) &rep);;
SendMappingNotify( 2, 0, 0);
return 0 ;
}
int
ProcGetKeyboardMapping(client)
ClientPtr client;
{
xGetKeyboardMappingReply rep;
register xGetKeyboardMappingReq *stuff = (xGetKeyboardMappingReq *)client->requestBuffer;
if ((sizeof(xGetKeyboardMappingReq) >> 2) != stuff->length) return( 16 );
if ((stuff->firstKeyCode < curKeySyms.minKeyCode) ||
(stuff->firstKeyCode > curKeySyms.maxKeyCode))
{
client->errorValue = stuff->firstKeyCode;
return 2 ;
}
if (stuff->firstKeyCode + stuff->count > curKeySyms.maxKeyCode + 1)
{
client->errorValue = stuff->count;
return 2 ;
}
rep.type = 1 ;
rep.sequenceNumber = client->sequence;
rep.keySymsPerKeyCode = curKeySyms.mapWidth;
rep.length = (curKeySyms.mapWidth * stuff->count);
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGetKeyboardMappingReply), &rep); else (void) WriteToClient(client, sizeof(xGetKeyboardMappingReply), (char *) &rep);;
client->pSwapReplyFunc = CopySwap32Write;
if (
client->swapped) (*
client->pSwapReplyFunc)(
client,
curKeySyms.mapWidth * stuff->count * sizeof(KeySym),
&curKeySyms.map[(stuff->firstKeyCode - curKeySyms.minKeyCode) *
curKeySyms.mapWidth]); else (void) WriteToClient (
client,
curKeySyms.mapWidth * stuff->count * sizeof(KeySym), (char *)
&curKeySyms.map[(stuff->firstKeyCode - curKeySyms.minKeyCode) *
curKeySyms.mapWidth]);;
# 3087 "events.c"
return client->noClientException;
}
int
ProcGetPointerMapping(client)
ClientPtr client;
{
xGetPointerMappingReply rep;
register xReq *stuff = (xReq *)client->requestBuffer;
if ((sizeof(xReq) >> 2) != stuff->length) return( 16 );
rep.type = 1 ;
rep.sequenceNumber = client->sequence;
rep.nElts = inputInfo.pointer->u.ptr.mapLength;
rep.length = (rep.nElts + (4-1))/4;
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGetPointerMappingReply), &rep); else (void) WriteToClient(client, sizeof(xGetPointerMappingReply), (char *) &rep);;
(void)WriteToClient(client, rep.nElts,
(char *)&inputInfo.pointer->u.ptr.map[1]);
return 0 ;
}
int
Ones(mask)
Mask mask;
{
register Mask y;
y = (mask >> 1) &033333333333;
y = mask - y - ((y >>1) & 033333333333);
return (((y + (y >> 3)) & 030707070707) % 077);
}
void
NoteLedState(keybd, led, on)
DeviceIntPtr keybd;
int led;
Bool on;
{
KeybdCtrl *ctrl = &keybd->u.keybd.ctrl;
if (on)
ctrl->leds |= ((Leds)1 << (led - 1));
else
ctrl->leds &= ~((Leds)1 << (led - 1));
}
int
ProcChangeKeyboardControl (client)
ClientPtr client;
{
KeybdCtrl ctrl;
DeviceIntPtr keybd = inputInfo.keyboard;
XID *vlist;
int t;
int led = (-1);
int key = (-1);
BITS32 vmask, index;
int mask, i;
register xChangeKeyboardControlReq *stuff = (xChangeKeyboardControlReq *)client->requestBuffer;
if ((sizeof(xChangeKeyboardControlReq) >> 2) > stuff->length ) return( 16 );
vmask = stuff->mask;
if (stuff->length !=(sizeof(xChangeKeyboardControlReq)>>2) + Ones(vmask))
return 16 ;
vlist = (XID *)&stuff[1];
ctrl = keybd->u.keybd.ctrl;
while (vmask)
{
index = (BITS32) ((vmask) & (~(vmask) + 1));
vmask &= ~index;
switch (index)
{
case (1L<<0):
t = (INT8)*vlist;
vlist++;
if (t == -1)
t = defaultKeyboardControl.click;
else if (t < 0 || t > 100)
{
client->errorValue = t;
return 2 ;
}
ctrl.click = t;
break;
case (1L<<1):
t = (INT8)*vlist;
vlist++;
if (t == -1)
t = defaultKeyboardControl.bell;
else if (t < 0 || t > 100)
{
client->errorValue = t;
return 2 ;
}
ctrl.bell = t;
break;
case (1L<<2):
t = (INT16)*vlist;
vlist++;
if (t == -1)
t = defaultKeyboardControl.bell_pitch;
else if (t < 0)
{
client->errorValue = t;
return 2 ;
}
ctrl.bell_pitch = t;
break;
case (1L<<3):
t = (INT16)*vlist;
vlist++;
if (t == -1)
t = defaultKeyboardControl.bell_duration;
else if (t < 0)
{
client->errorValue = t;
return 2 ;
}
ctrl.bell_duration = t;
break;
case (1L<<4):
led = (CARD8)*vlist;
vlist++;
if (led < 1 || led > 32)
{
client->errorValue = led;
return 2 ;
}
if (!(stuff->mask & (1L<<5)))
return 8 ;
break;
case (1L<<5):
t = (CARD8)*vlist;
vlist++;
if (t == 0)
{
if (led == (-1))
ctrl.leds = 0x0;
else
ctrl.leds &= ~(((Leds)(1)) << (led - 1));
}
else if (t == 1)
{
if (led == (-1))
ctrl.leds = ~0L;
else
ctrl.leds |= (((Leds)(1)) << (led - 1));
}
else
{
client->errorValue = t;
return 2 ;
}
break;
case (1L<<6):
key = (KeyCode)*vlist;
vlist++;
if (key < 8 || key > 255)
{
client->errorValue = key;
return 2 ;
}
if (!(stuff->mask & (1L<<7)))
return 8 ;
break;
case (1L<<7):
i = (key >> 3);
mask = (1 << (key & 7));
t = (CARD8)*vlist;
vlist++;
if (t == 0)
{
if (key == (-1))
ctrl.autoRepeat = 0;
else
ctrl.autoRepeats[i] &= ~mask;
}
else if (t == 1)
{
if (key == (-1))
ctrl.autoRepeat = 1;
else
ctrl.autoRepeats[i] |= mask;
}
else if (t == 2)
{
if (key == (-1))
ctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
else
ctrl.autoRepeats[i] &= ~mask;
ctrl.autoRepeats[i] =
(ctrl.autoRepeats[i] & ~mask) |
(defaultKeyboardControl.autoRepeats[i] & mask);
}
else
{
client->errorValue = t;
return 2 ;
}
break;
default:
client->errorValue = stuff->mask;
return 2 ;
}
}
keybd->u.keybd.ctrl = ctrl;
(*keybd->u.keybd.CtrlProc)(keybd, &keybd->u.keybd.ctrl);
return 0 ;
}
int
ProcGetKeyboardControl (client)
ClientPtr client;
{
int i;
DeviceIntPtr keybd = inputInfo.keyboard;
xGetKeyboardControlReply rep;
register xReq *stuff = (xReq *)client->requestBuffer;
if ((sizeof(xReq) >> 2) != stuff->length) return( 16 );
rep.type = 1 ;
rep.length = 5;
rep.sequenceNumber = client->sequence;
rep.globalAutoRepeat = keybd->u.keybd.ctrl.autoRepeat;
rep.keyClickPercent = keybd->u.keybd.ctrl.click;
rep.bellPercent = keybd->u.keybd.ctrl.bell;
rep.bellPitch = keybd->u.keybd.ctrl.bell_pitch;
rep.bellDuration = keybd->u.keybd.ctrl.bell_duration;
rep.ledMask = keybd->u.keybd.ctrl.leds;
for (i = 0; i < 32; i++)
rep.map[i] = keybd->u.keybd.ctrl.autoRepeats[i];
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGetKeyboardControlReply), &rep); else (void) WriteToClient(client, sizeof(xGetKeyboardControlReply), (char *) &rep);;
return 0 ;
}
int
ProcBell(client)
ClientPtr client;
{
register DeviceIntPtr keybd = inputInfo.keyboard;
int base = keybd->u.keybd.ctrl.bell;
int newpercent;
register xBellReq *stuff = (xBellReq *)client->requestBuffer;
if ((sizeof(xBellReq) >> 2) != stuff->length) return( 16 );
if (stuff->percent < -100 || stuff->percent > 100)
{
client->errorValue = stuff->percent;
return 2 ;
}
newpercent = (base * stuff->percent) / 100;
if (stuff->percent < 0)
newpercent = base + newpercent;
else
newpercent = base - newpercent + stuff->percent;
(*keybd->u.keybd.BellProc)(newpercent, keybd);
return 0 ;
}
int
ProcChangePointerControl(client)
ClientPtr client;
{
DeviceIntPtr mouse = inputInfo.pointer;
PtrCtrl ctrl;
register xChangePointerControlReq *stuff = (xChangePointerControlReq *)client->requestBuffer;
if ((sizeof(xChangePointerControlReq) >> 2) != stuff->length) return( 16 );
ctrl = mouse->u.ptr.ctrl;
if (stuff->doAccel)
{
if (stuff->accelNum == -1)
ctrl.num = defaultPointerControl.num;
else if (stuff->accelNum < 0)
{
client->errorValue = stuff->accelNum;
return 2 ;
}
else ctrl.num = stuff->accelNum;
if (stuff->accelDenum == -1)
ctrl.den = defaultPointerControl.den;
else if (stuff->accelDenum <= 0)
{
client->errorValue = stuff->accelDenum;
return 2 ;
}
else ctrl.den = stuff->accelDenum;
}
if (stuff->doThresh)
{
if (stuff->threshold == -1)
ctrl.threshold = defaultPointerControl.threshold;
else if (stuff->threshold < 0)
{
client->errorValue = stuff->threshold;
return 2 ;
}
else ctrl.threshold = stuff->threshold;
}
mouse->u.ptr.ctrl = ctrl;
(*mouse->u.ptr.CtrlProc)(mouse, &mouse->u.ptr.ctrl);
return 0 ;
}
int
ProcGetPointerControl(client)
ClientPtr client;
{
register DeviceIntPtr mouse = inputInfo.pointer;
register xReq *stuff = (xReq *)client->requestBuffer;
xGetPointerControlReply rep;
if ((sizeof(xReq) >> 2) != stuff->length) return( 16 );
rep.type = 1 ;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.threshold = mouse->u.ptr.ctrl.threshold;
rep.accelNumerator = mouse->u.ptr.ctrl.num;
rep.accelDenominator = mouse->u.ptr.ctrl.den;
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGenericReply), &rep); else (void) WriteToClient(client, sizeof(xGenericReply), (char *) &rep);;
return 0 ;
}
static void
MaybeStopHint(client)
ClientPtr client;
{
GrabPtr grab = inputInfo.pointer->grab;
Mask mask;
if ((grab && (client == grab->client) &&
(grab->eventMask & (1L<<7) )) ||
(!grab && (EventMaskForClient(motionHintWindow, client, &mask) &
(1L<<7) )))
motionHintWindow = ((WindowPtr) 0);
}
int
ProcGetMotionEvents(client)
ClientPtr client;
{
WindowPtr pWin;
xTimecoord * coords;
xGetMotionEventsReply rep;
int i, count, xmin, xmax, ymin, ymax;
unsigned long nEvents;
DeviceIntPtr mouse = inputInfo.pointer;
TimeStamp start, stop;
register xGetMotionEventsReq *stuff = (xGetMotionEventsReq *)client->requestBuffer;
if ((sizeof(xGetMotionEventsReq) >> 2) != stuff->length) return( 16 );
pWin = LookupWindow(stuff->window, client);
if (!pWin)
return 3 ;
if (motionHintWindow)
MaybeStopHint(client);
rep.type = 1 ;
rep.sequenceNumber = client->sequence;
rep.nEvents = 0;
start = ClientTimeToServerTime(stuff->start);
stop = ClientTimeToServerTime(stuff->stop);
if (CompareTimeStamps(start, stop) == 1)
return 0 ;
if (CompareTimeStamps(start, currentTime) == 1)
return 0 ;
if (CompareTimeStamps(stop, currentTime) == 1)
stop = currentTime;
if (inputInfo.numMotionEvents)
{
coords = (xTimecoord *) Xalloc((unsigned long)(
inputInfo.numMotionEvents * sizeof(xTimecoord)));
count = (*mouse->u.ptr.GetMotionProc) (
mouse, coords, start.milliseconds, stop.milliseconds);
xmin = pWin->absCorner.x - pWin->borderWidth;
xmax =
pWin->absCorner.x + (int)pWin->clientWinSize.width + pWin->borderWidth;
ymin = pWin->absCorner.y - pWin->borderWidth;
ymax =
pWin->absCorner.y + (int)pWin->clientWinSize.height + pWin->borderWidth;
for (i = 0; i < count; i++)
if ((xmin <= coords[i].x) && (coords[i].x < xmax) &&
(ymin <= coords[i].y) && (coords[i].y < ymax))
{
coords[rep.nEvents].x = coords[i].x - pWin->absCorner.x;
coords[rep.nEvents].y = coords[i].y - pWin->absCorner.y;
rep.nEvents++;
}
}
rep.length = rep.nEvents * (sizeof(xTimecoord) / 4);
nEvents = rep.nEvents;
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xGetMotionEventsReply), &rep); else (void) WriteToClient(client, sizeof(xGetMotionEventsReply), (char *) &rep);;
if (inputInfo.numMotionEvents)
{
client->pSwapReplyFunc = SwapTimeCoordWrite;
if (client->swapped) (*client->pSwapReplyFunc)(client, nEvents * sizeof(xTimecoord),
(char *)coords); else (void) WriteToClient (client, nEvents * sizeof(xTimecoord), (char *)
(char *)coords);;
# 3485 "events.c"
Xfree((pointer)(coords));
}
return 0 ;
}
int
ProcQueryPointer(client)
ClientPtr client;
{
xQueryPointerReply rep;
WindowPtr pWin, t;
register xResourceReq *stuff = (xResourceReq *)client->requestBuffer;
if ((sizeof(xResourceReq) >> 2) != stuff->length) return( 16 );
pWin = LookupWindow(stuff->id, client);
if (!pWin)
return 3 ;
if (motionHintWindow)
MaybeStopHint(client);
rep.type = 1 ;
rep.sequenceNumber = client->sequence;
rep.mask = keyButtonState;
rep.length = 0;
rep.root = (spriteTrace[0])->wid;
rep.rootX = sprite.hot.x;
rep.rootY = sprite.hot.y;
rep.child = 0L ;
if (currentScreen == pWin->drawable.pScreen)
{
rep.sameScreen = 1;
rep.winX = sprite.hot.x - pWin->absCorner.x;
rep.winY = sprite.hot.y - pWin->absCorner.y;
for (t = sprite.win; t; t = t->parent)
if (t->parent == pWin)
{
rep.child = t->wid;
break;
}
}
else
{
rep.sameScreen = 0;
rep.winX = 0;
rep.winY = 0;
}
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xQueryPointerReply), &rep); else (void) WriteToClient(client, sizeof(xQueryPointerReply), (char *) &rep);;
return( 0 );
}
int
ProcQueryKeymap(client)
ClientPtr client;
{
xQueryKeymapReply rep;
int i;
rep.type = 1 ;
rep.sequenceNumber = client->sequence;
rep.length = 2;
for (i = 0; i<32; i++)
rep.map[i] = inputInfo.keyboard->down[i];
if (client->swapped) (*ReplySwapVector[((xReq *)client->requestBuffer)->reqType]) (client, sizeof(xQueryKeymapReply), &rep); else (void) WriteToClient(client, sizeof(xQueryKeymapReply), (char *) &rep);;
return 0 ;
}
int
ProcSendEvent(client)
ClientPtr client;
{
extern int lastEvent;
WindowPtr pWin;
WindowPtr effectiveFocus = ((WindowPtr) 0);
register xSendEventReq *stuff = (xSendEventReq *)client->requestBuffer;
if ((sizeof(xSendEventReq) >> 2) != stuff->length) return( 16 );
if ( ! ((stuff->event.u.u.type < 35 ) ||
(( 64 <= stuff->event.u.u.type) &&
(stuff->event.u.u.type < lastEvent))) )
{
client->errorValue = stuff->event.u.u.type;
return 2 ;
}
if (stuff->destination == 0L )
pWin = sprite.win;
else if (stuff->destination == 1L )
{
WindowPtr inputFocus = inputInfo.keyboard->u.keybd.focus.win;
if (inputFocus == ((WindowPtr) 0L ))
return 0 ;
if (inputFocus == ((WindowPtr) 1L ))
inputFocus = spriteTrace[0];
if (IsParent(inputFocus, sprite.win))
{
effectiveFocus = inputFocus;
pWin = sprite.win;
}
else
effectiveFocus = pWin = inputFocus;
}
else
pWin = LookupWindow(stuff->destination, client);
if (!pWin)
return 3 ;
stuff->event.u.u.type |= 0x80;
if (stuff->propagate)
{
for (;pWin; pWin = pWin->parent)
{
if (DeliverEventsToWindow(
pWin, &stuff->event, 1, stuff->eventMask, ((GrabPtr) 0)))
return 0 ;
if (pWin == effectiveFocus)
return 0 ;
stuff->eventMask &= ~pWin->dontPropagateMask;
}
}
else
(void)DeliverEventsToWindow(
pWin, &stuff->event, 1, stuff->eventMask, ((GrabPtr) 0));
return 0 ;
}
int
ProcUngrabKey(client)
ClientPtr client;
{
register xUngrabKeyReq *stuff = (xUngrabKeyReq *)client->requestBuffer;
WindowPtr pWin;
GrabRec temporaryGrab;
if ((sizeof(xUngrabKeyReq) >> 2) != stuff->length) return( 16 );
pWin = LookupWindow(stuff->grabWindow, client);
if (!pWin)
return 3 ;
temporaryGrab.client = client;
temporaryGrab.device = inputInfo.keyboard;
temporaryGrab.window = pWin;
temporaryGrab.modifiersDetail.exact = stuff->modifiers;
temporaryGrab.modifiersDetail.pMask = 0;
temporaryGrab.detail.exact = stuff->key;
temporaryGrab.detail.pMask = 0;
DeletePassiveGrabFromList(&temporaryGrab);
return( 0 );
}
int
ProcGrabKey(client)
ClientPtr client;
{
WindowPtr pWin;
register xGrabKeyReq *stuff = (xGrabKeyReq *)client->requestBuffer;
GrabPtr grab;
GrabPtr temporaryGrab;
if ((sizeof(xGrabKeyReq) >> 2) != stuff->length) return( 16 );
if (((stuff->key > curKeySyms.maxKeyCode) || (stuff->key < curKeySyms.minKeyCode))
&& (stuff->key != 0L ))
{
client->errorValue = stuff->key;
return 2 ;
}
pWin = LookupWindow(stuff->grabWindow, client);
if (!pWin)
return 3 ;
temporaryGrab = CreateGrab(client, inputInfo.keyboard, pWin,
(Mask)( (1L<<0) | (1L<<1) ), (Bool)stuff->ownerEvents,
(Bool)stuff->keyboardMode, (Bool)stuff->pointerMode,
stuff->modifiers, stuff->key, ((WindowPtr) 0), ((CursorPtr) 0));
for (grab = ((GrabPtr)(pWin)->passiveGrabs); grab; grab = grab->next)
{
if (GrabMatchesSecond(temporaryGrab, grab))
{
if (client != grab->client)
{
DeleteGrab(temporaryGrab);
return 10 ;
}
}
}
DeletePassiveGrabFromList(temporaryGrab);
AddPassiveGrabToWindowList(temporaryGrab);
return( 0 );
}
int
ProcGrabButton(client)
ClientPtr client;
{
WindowPtr pWin, confineTo;
register xGrabButtonReq *stuff = (xGrabButtonReq *)client->requestBuffer;
GrabPtr grab;
CursorPtr cursor;
GrabPtr temporaryGrab;
if ((sizeof(xGrabButtonReq) >> 2) != stuff->length) return( 16 );
if ((stuff->pointerMode != 0) &&
(stuff->pointerMode != 1))
{
client->errorValue = stuff->pointerMode;
return 2 ;
}
if ((stuff->keyboardMode != 0) &&
(stuff->keyboardMode != 1))
{
client->errorValue = stuff->keyboardMode;
return 2 ;
}
pWin = LookupWindow(stuff->grabWindow, client);
if (!pWin)
return 3 ;
if (stuff->confineTo == 0L )
confineTo = ((WindowPtr) 0);
else
{
confineTo = LookupWindow(stuff->confineTo, client);
if (!confineTo)
return 3 ;
}
if (stuff->cursor == 0L )
cursor = ((CursorPtr) 0);
else
{
cursor = (CursorPtr)LookupID(stuff->cursor, 1<<2, 0);
if (!cursor)
{
client->errorValue = stuff->cursor;
return 6 ;
}
}
temporaryGrab = CreateGrab(client, inputInfo.pointer, pWin,
(Mask)(stuff->eventMask | (1L<<2) | (1L<<3) ),
(Bool)stuff->ownerEvents, (Bool) stuff->keyboardMode,
(Bool)stuff->pointerMode, stuff->modifiers, stuff->button,
confineTo, cursor);
for (grab = ((GrabPtr)(pWin)->passiveGrabs); grab; grab = grab->next)
{
if (GrabMatchesSecond(temporaryGrab, grab))
{
if (client != grab->client)
{
DeleteGrab(temporaryGrab);
return 10 ;
}
}
}
DeletePassiveGrabFromList(temporaryGrab);
AddPassiveGrabToWindowList(temporaryGrab);
return( 0 );
}
int
ProcUngrabButton(client)
ClientPtr client;
{
register xUngrabButtonReq *stuff = (xUngrabButtonReq *)client->requestBuffer;
WindowPtr pWin;
GrabRec temporaryGrab;
if ((sizeof(xUngrabButtonReq) >> 2) != stuff->length) return( 16 );
pWin = LookupWindow(stuff->grabWindow, client);
if (!pWin)
return 3 ;
temporaryGrab.client = client;
temporaryGrab.device = inputInfo.pointer;
temporaryGrab.window = pWin;
temporaryGrab.modifiersDetail.exact = stuff->modifiers;
temporaryGrab.modifiersDetail.pMask = 0;
temporaryGrab.detail.exact = stuff->button;
temporaryGrab.detail.pMask = 0;
DeletePassiveGrabFromList(&temporaryGrab);
return( 0 );
}
void
DeleteWindowFromAnyEvents(pWin, freeResources)
WindowPtr pWin;
Bool freeResources;
{
WindowPtr parent;
FocusPtr focus = &inputInfo.keyboard->u.keybd.focus;
DeviceIntPtr mouse = inputInfo.pointer;
OtherClientsPtr oc;
GrabPtr passive;
if ((mouse->grab) &&
((mouse->grab->window == pWin) ||
(mouse->grab->confineTo == pWin)))
DeactivatePointerGrab(mouse);
if ((inputInfo.keyboard->grab) &&
(inputInfo.keyboard->grab->window == pWin))
DeactivateKeyboardGrab(inputInfo.keyboard);
if ((pWin == focus->win) && (pWin->parent != ((WindowPtr) 0)))
{
int focusEventMode = 0;
if (inputInfo.keyboard->grab)
focusEventMode = 3;
switch (focus->revert)
{
case (int) 0L :
DoFocusEvents(pWin, ((WindowPtr) 0L ), focusEventMode);
focus->win = ((WindowPtr) 0L );
focusTraceGood = 0;
break;
case 2:
parent = pWin;
do
{
parent = parent->parent;
focusTraceGood--;
} while (!parent->realized);
DoFocusEvents(pWin, parent, focusEventMode);
focus->win = parent;
focus->revert = (int) 0L ;
break;
case (int) 1L :
DoFocusEvents(pWin, ((WindowPtr) 1L ), focusEventMode);
focus->win = ((WindowPtr) 1L );
focusTraceGood = 0;
break;
}
}
if (motionHintWindow == pWin)
motionHintWindow = ((WindowPtr) 0);
if (freeResources)
{
while (oc = ((OtherClientsPtr)(pWin)->otherClients))
FreeResource(oc->resource, 1);
while (passive = ((GrabPtr)(pWin)->passiveGrabs))
FreeResource(passive->resource, 1);
}
}
void
CheckCursorConfinement(pWin)
WindowPtr pWin;
{
GrabPtr grab = inputInfo.pointer->grab;
WindowPtr confineTo;
if (grab && (confineTo = grab->confineTo))
{
if (!(* confineTo->drawable.pScreen->RegionNotEmpty)
(confineTo->borderSize))
DeactivatePointerGrab(inputInfo.pointer);
else if (pWin->firstChild || (pWin == confineTo))
ConfineCursorToWindow(confineTo, sprite.hot.x, sprite.hot.y, 1);
}
}
Mask
EventMaskForClient(win, client, allMask)
WindowPtr win;
ClientPtr client;
Mask *allMask;
{
OtherClientsPtr other;
Mask him = 0;
if (win->client == client)
him = win->eventMask;
*allMask = win->eventMask;
for (other = ((OtherClientsPtr)(win)->otherClients); other; other = other->next)
{
if (other->client == client)
him = other->mask;
*allMask |= other->mask;
}
return him;
}
int
ProcRecolorCursor(client)
ClientPtr client;
{
CursorPtr pCursor;
int nscr;
ScreenPtr pscr;
register xRecolorCursorReq *stuff = (xRecolorCursorReq *)client->requestBuffer;
if ((sizeof(xRecolorCursorReq) >> 2) != stuff->length) return( 16 );
pCursor = (CursorPtr)LookupID(stuff->cursor, 1<<2, 0);
if ( !pCursor)
{
client->errorValue = stuff->cursor;
return ( 6 );
}
pCursor->foreRed = stuff->foreRed;
pCursor->foreGreen = stuff->foreGreen;
pCursor->foreBlue = stuff->foreBlue;
pCursor->backRed = stuff->backRed;
pCursor->backGreen = stuff->backGreen;
pCursor->backBlue = stuff->backBlue;
for ( nscr=0, pscr=screenInfo.screen;
nscr<screenInfo.numScreens;
nscr++, pscr++)
{
( *pscr->RecolorCursor)(pscr, pCursor,
(pCursor == sprite.current) && (pscr == currentScreen));
}
return ( 0 );
}
void
WriteEventsToClient(pClient, count, events)
ClientPtr pClient;
int count;
xEvent *events;
{
if(pClient->swapped)
{
int i;
xEvent eventTo, *eventFrom;
for(i = 0; i < count; i++)
{
eventFrom = &events[i];
(*EventSwapVector[eventFrom->u.u.type & 0177])
(eventFrom, &eventTo);
(void)WriteToClient(pClient, sizeof(xEvent), (char *)&eventTo);
}
}
else
{
(void)WriteToClient(pClient, count * sizeof(xEvent), (char *) events);
}
}