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