From d7b2ae0270615e56ddfaa37bdc3fae97499ccbff Mon Sep 17 00:00:00 2001 From: Spoike Date: Mon, 23 Aug 2004 01:37:23 +0000 Subject: [PATCH] built in X server git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@17 fc73d0e0-1445-4013-8a0c-d673dee63da5 --- engine/qux/X.h | 717 +++++++++ engine/qux/Xmd.h | 205 +++ engine/qux/Xproto.h | 2132 ++++++++++++++++++++++++++ engine/qux/Xprotostr.h | 80 + engine/qux/bigreqstr.h | 63 + engine/qux/keysymdef.h | 2016 +++++++++++++++++++++++++ engine/qux/m_x.c | 1833 ++++++++++++++++++++++ engine/qux/qux.h | 171 +++ engine/qux/x_reqs.c | 3256 ++++++++++++++++++++++++++++++++++++++++ engine/qux/x_res.c | 541 +++++++ 10 files changed, 11014 insertions(+) create mode 100644 engine/qux/X.h create mode 100644 engine/qux/Xmd.h create mode 100644 engine/qux/Xproto.h create mode 100644 engine/qux/Xprotostr.h create mode 100644 engine/qux/bigreqstr.h create mode 100644 engine/qux/keysymdef.h create mode 100644 engine/qux/m_x.c create mode 100644 engine/qux/qux.h create mode 100644 engine/qux/x_reqs.c create mode 100644 engine/qux/x_res.c diff --git a/engine/qux/X.h b/engine/qux/X.h new file mode 100644 index 000000000..ffeea80ec --- /dev/null +++ b/engine/qux/X.h @@ -0,0 +1,717 @@ +/* + * $Xorg: X.h,v 1.4 2001/02/09 02:03:22 xorgcvs Exp $ + */ + +/* Definitions for the X window system likely to be used by applications */ + +#ifndef X_H +#define X_H + +/*********************************************************** + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ +/* $XFree86: xc/include/X.h,v 1.5 2001/12/14 19:53:25 dawes Exp $ */ + +#define X_PROTOCOL 11 /* current protocol version */ +#define X_PROTOCOL_REVISION 0 /* current minor version */ + +/* Resources */ + +/* + * _XSERVER64 must ONLY be defined when compiling X server sources on + * systems where unsigned long is not 32 bits, must NOT be used in + * client or library code. + */ +#ifndef _XSERVER64 +# ifndef _XTYPEDEF_XID +# define _XTYPEDEF_XID +typedef unsigned long XID; +# endif +# ifndef _XTYPEDEF_MASK +# define _XTYPEDEF_MASK +typedef unsigned long Mask; +# endif +# ifndef _XTYPEDEF_ATOM +# define _XTYPEDEF_ATOM +typedef unsigned long Atom; /* Also in Xdefs.h */ +# endif +typedef unsigned long VisualID; +typedef unsigned long Time; +#else +# include +# ifndef _XTYPEDEF_XID +# define _XTYPEDEF_XID +typedef CARD32 XID; +# endif +# ifndef _XTYPEDEF_MASK +# define _XTYPEDEF_MASK +typedef CARD32 Mask; +# endif +# ifndef _XTYPEDEF_ATOM +# define _XTYPEDEF_ATOM +typedef CARD32 Atom; +# endif +typedef CARD32 VisualID; +typedef CARD32 Time; +#endif + +typedef XID Window; +typedef XID Drawable; +#ifndef _XTYPEDEF_FONT +# define _XTYPEDEF_FONT +typedef XID Font; +#endif +typedef XID Pixmap; +typedef XID Cursor; +typedef XID Colormap; +typedef XID GContext; +typedef XID KeySym; + +typedef unsigned char KeyCode; + +/***************************************************************** + * RESERVED RESOURCE AND CONSTANT DEFINITIONS + *****************************************************************/ + +#ifndef None +#define None 0L /* universal null resource or null atom */ +#endif + +#define ParentRelative 1L /* background pixmap in CreateWindow + and ChangeWindowAttributes */ + +#define CopyFromParent 0L /* border pixmap in CreateWindow + and ChangeWindowAttributes + special VisualID and special window + class passed to CreateWindow */ + +#define PointerWindow 0L /* destination window in SendEvent */ +#define InputFocus 1L /* destination window in SendEvent */ + +#define PointerRoot 1L /* focus window in SetInputFocus */ + +#define AnyPropertyType 0L /* special Atom, passed to GetProperty */ + +#define AnyKey 0L /* special Key Code, passed to GrabKey */ + +#define AnyButton 0L /* special Button Code, passed to GrabButton */ + +#define AllTemporary 0L /* special Resource ID passed to KillClient */ + +#define CurrentTime 0L /* special Time */ + +#define NoSymbol 0L /* special KeySym */ + +/***************************************************************** + * EVENT DEFINITIONS + *****************************************************************/ + +/* Input Event Masks. Used as event-mask window attribute and as arguments + to Grab requests. Not to be confused with event names. */ + +#define NoEventMask 0L +#define KeyPressMask (1L<<0) +#define KeyReleaseMask (1L<<1) +#define ButtonPressMask (1L<<2) +#define ButtonReleaseMask (1L<<3) +#define EnterWindowMask (1L<<4) +#define LeaveWindowMask (1L<<5) +#define PointerMotionMask (1L<<6) +#define PointerMotionHintMask (1L<<7) +#define Button1MotionMask (1L<<8) +#define Button2MotionMask (1L<<9) +#define Button3MotionMask (1L<<10) +#define Button4MotionMask (1L<<11) +#define Button5MotionMask (1L<<12) +#define ButtonMotionMask (1L<<13) +#define KeymapStateMask (1L<<14) +#define ExposureMask (1L<<15) +#define VisibilityChangeMask (1L<<16) +#define StructureNotifyMask (1L<<17) +#define ResizeRedirectMask (1L<<18) +#define SubstructureNotifyMask (1L<<19) +#define SubstructureRedirectMask (1L<<20) +#define FocusChangeMask (1L<<21) +#define PropertyChangeMask (1L<<22) +#define ColormapChangeMask (1L<<23) +#define OwnerGrabButtonMask (1L<<24) + +/* Event names. Used in "type" field in XEvent structures. Not to be +confused with event masks above. They start from 2 because 0 and 1 +are reserved in the protocol for errors and replies. */ + +#define KeyPress 2 +#define KeyRelease 3 +#define ButtonPress 4 +#define ButtonRelease 5 +#define MotionNotify 6 +#define EnterNotify 7 +#define LeaveNotify 8 +#define FocusIn 9 +#define FocusOut 10 +#define KeymapNotify 11 +#define Expose 12 +#define GraphicsExpose 13 +#define NoExpose 14 +#define VisibilityNotify 15 +#define CreateNotify 16 +#define DestroyNotify 17 +#define UnmapNotify 18 +#define MapNotify 19 +#define MapRequest 20 +#define ReparentNotify 21 +#define ConfigureNotify 22 +#define ConfigureRequest 23 +#define GravityNotify 24 +#define ResizeRequest 25 +#define CirculateNotify 26 +#define CirculateRequest 27 +#define PropertyNotify 28 +#define SelectionClear 29 +#define SelectionRequest 30 +#define SelectionNotify 31 +#define ColormapNotify 32 +#define ClientMessage 33 +#define MappingNotify 34 +#define LASTEvent 35 /* must be bigger than any event # */ + + +/* Key masks. Used as modifiers to GrabButton and GrabKey, results of QueryPointer, + state in various key-, mouse-, and button-related events. */ + +#define ShiftMask (1<<0) +#define LockMask (1<<1) +#define ControlMask (1<<2) +#define Mod1Mask (1<<3) +#define Mod2Mask (1<<4) +#define Mod3Mask (1<<5) +#define Mod4Mask (1<<6) +#define Mod5Mask (1<<7) + +/* modifier names. Used to build a SetModifierMapping request or + to read a GetModifierMapping request. These correspond to the + masks defined above. */ +#define ShiftMapIndex 0 +#define LockMapIndex 1 +#define ControlMapIndex 2 +#define Mod1MapIndex 3 +#define Mod2MapIndex 4 +#define Mod3MapIndex 5 +#define Mod4MapIndex 6 +#define Mod5MapIndex 7 + + +/* button masks. Used in same manner as Key masks above. Not to be confused + with button names below. */ + +#define Button1Mask (1<<8) +#define Button2Mask (1<<9) +#define Button3Mask (1<<10) +#define Button4Mask (1<<11) +#define Button5Mask (1<<12) + +#define AnyModifier (1<<15) /* used in GrabButton, GrabKey */ + + +/* button names. Used as arguments to GrabButton and as detail in ButtonPress + and ButtonRelease events. Not to be confused with button masks above. + Note that 0 is already defined above as "AnyButton". */ + +#define Button1 1 +#define Button2 2 +#define Button3 3 +#define Button4 4 +#define Button5 5 + +/* Notify modes */ + +#define NotifyNormal 0 +#define NotifyGrab 1 +#define NotifyUngrab 2 +#define NotifyWhileGrabbed 3 + +#define NotifyHint 1 /* for MotionNotify events */ + +/* Notify detail */ + +#define NotifyAncestor 0 +#define NotifyVirtual 1 +#define NotifyInferior 2 +#define NotifyNonlinear 3 +#define NotifyNonlinearVirtual 4 +#define NotifyPointer 5 +#define NotifyPointerRoot 6 +#define NotifyDetailNone 7 + +/* Visibility notify */ + +#define VisibilityUnobscured 0 +#define VisibilityPartiallyObscured 1 +#define VisibilityFullyObscured 2 + +/* Circulation request */ + +#define PlaceOnTop 0 +#define PlaceOnBottom 1 + +/* protocol families */ + +#define FamilyInternet 0 +#define FamilyDECnet 1 +#define FamilyChaos 2 + +/* Property notification */ + +#define PropertyNewValue 0 +#define PropertyDelete 1 + +/* Color Map notification */ + +#define ColormapUninstalled 0 +#define ColormapInstalled 1 + +/* GrabPointer, GrabButton, GrabKeyboard, GrabKey Modes */ + +#define GrabModeSync 0 +#define GrabModeAsync 1 + +/* GrabPointer, GrabKeyboard reply status */ + +#define GrabSuccess 0 +#define AlreadyGrabbed 1 +#define GrabInvalidTime 2 +#define GrabNotViewable 3 +#define GrabFrozen 4 + +/* AllowEvents modes */ + +#define AsyncPointer 0 +#define SyncPointer 1 +#define ReplayPointer 2 +#define AsyncKeyboard 3 +#define SyncKeyboard 4 +#define ReplayKeyboard 5 +#define AsyncBoth 6 +#define SyncBoth 7 + +/* Used in SetInputFocus, GetInputFocus */ + +#define RevertToNone (int)None +#define RevertToPointerRoot (int)PointerRoot +#define RevertToParent 2 + +/***************************************************************** + * ERROR CODES + *****************************************************************/ + +#define Success 0 /* everything's okay */ +#define BadRequest 1 /* bad request code */ +#define BadValue 2 /* int parameter out of range */ +#define BadWindow 3 /* parameter not a Window */ +#define BadPixmap 4 /* parameter not a Pixmap */ +#define BadAtom 5 /* parameter not an Atom */ +#define BadCursor 6 /* parameter not a Cursor */ +#define BadFont 7 /* parameter not a Font */ +#define BadMatch 8 /* parameter mismatch */ +#define BadDrawable 9 /* parameter not a Pixmap or Window */ +#define BadAccess 10 /* depending on context: + - key/button already grabbed + - attempt to free an illegal + cmap entry + - attempt to store into a read-only + color map entry. + - attempt to modify the access control + list from other than the local host. + */ +#define BadAlloc 11 /* insufficient resources */ +#define BadColor 12 /* no such colormap */ +#define BadGC 13 /* parameter not a GC */ +#define BadIDChoice 14 /* choice not in range or already used */ +#define BadName 15 /* font or color name doesn't exist */ +#define BadLength 16 /* Request length incorrect */ +#define BadImplementation 17 /* server is defective */ + +#define FirstExtensionError 128 +#define LastExtensionError 255 + +/***************************************************************** + * WINDOW DEFINITIONS + *****************************************************************/ + +/* Window classes used by CreateWindow */ +/* Note that CopyFromParent is already defined as 0 above */ + +#define InputOutput 1 +#define InputOnly 2 + +/* Window attributes for CreateWindow and ChangeWindowAttributes */ + +#define CWBackPixmap (1L<<0) +#define CWBackPixel (1L<<1) +#define CWBorderPixmap (1L<<2) +#define CWBorderPixel (1L<<3) +#define CWBitGravity (1L<<4) +#define CWWinGravity (1L<<5) +#define CWBackingStore (1L<<6) +#define CWBackingPlanes (1L<<7) +#define CWBackingPixel (1L<<8) +#define CWOverrideRedirect (1L<<9) +#define CWSaveUnder (1L<<10) +#define CWEventMask (1L<<11) +#define CWDontPropagate (1L<<12) +#define CWColormap (1L<<13) +#define CWCursor (1L<<14) + +/* ConfigureWindow structure */ + +#define CWX (1<<0) +#define CWY (1<<1) +#define CWWidth (1<<2) +#define CWHeight (1<<3) +#define CWBorderWidth (1<<4) +#define CWSibling (1<<5) +#define CWStackMode (1<<6) + + +/* Bit Gravity */ + +#define ForgetGravity 0 +#define NorthWestGravity 1 +#define NorthGravity 2 +#define NorthEastGravity 3 +#define WestGravity 4 +#define CenterGravity 5 +#define EastGravity 6 +#define SouthWestGravity 7 +#define SouthGravity 8 +#define SouthEastGravity 9 +#define StaticGravity 10 + +/* Window gravity + bit gravity above */ + +#define UnmapGravity 0 + +/* Used in CreateWindow for backing-store hint */ + +#define NotUseful 0 +#define WhenMapped 1 +#define Always 2 + +/* Used in GetWindowAttributes reply */ + +#define IsUnmapped 0 +#define IsUnviewable 1 +#define IsViewable 2 + +/* Used in ChangeSaveSet */ + +#define SetModeInsert 0 +#define SetModeDelete 1 + +/* Used in ChangeCloseDownMode */ + +#define DestroyAll 0 +#define RetainPermanent 1 +#define RetainTemporary 2 + +/* Window stacking method (in configureWindow) */ + +#define Above 0 +#define Below 1 +#define TopIf 2 +#define BottomIf 3 +#define Opposite 4 + +/* Circulation direction */ + +#define RaiseLowest 0 +#define LowerHighest 1 + +/* Property modes */ + +#define PropModeReplace 0 +#define PropModePrepend 1 +#define PropModeAppend 2 + +/***************************************************************** + * GRAPHICS DEFINITIONS + *****************************************************************/ + +/* graphics functions, as in GC.alu */ + +#define GXclear 0x0 /* 0 */ +#define GXand 0x1 /* src AND dst */ +#define GXandReverse 0x2 /* src AND NOT dst */ +#define GXcopy 0x3 /* src */ +#define GXandInverted 0x4 /* NOT src AND dst */ +#define GXnoop 0x5 /* dst */ +#define GXxor 0x6 /* src XOR dst */ +#define GXor 0x7 /* src OR dst */ +#define GXnor 0x8 /* NOT src AND NOT dst */ +#define GXequiv 0x9 /* NOT src XOR dst */ +#define GXinvert 0xa /* NOT dst */ +#define GXorReverse 0xb /* src OR NOT dst */ +#define GXcopyInverted 0xc /* NOT src */ +#define GXorInverted 0xd /* NOT src OR dst */ +#define GXnand 0xe /* NOT src OR NOT dst */ +#define GXset 0xf /* 1 */ + +/* LineStyle */ + +#define LineSolid 0 +#define LineOnOffDash 1 +#define LineDoubleDash 2 + +/* capStyle */ + +#define CapNotLast 0 +#define CapButt 1 +#define CapRound 2 +#define CapProjecting 3 + +/* joinStyle */ + +#define JoinMiter 0 +#define JoinRound 1 +#define JoinBevel 2 + +/* fillStyle */ + +#define FillSolid 0 +#define FillTiled 1 +#define FillStippled 2 +#define FillOpaqueStippled 3 + +/* fillRule */ + +#define EvenOddRule 0 +#define WindingRule 1 + +/* subwindow mode */ + +#define ClipByChildren 0 +#define IncludeInferiors 1 + +/* SetClipRectangles ordering */ + +#define Unsorted 0 +#define YSorted 1 +#define YXSorted 2 +#define YXBanded 3 + +/* CoordinateMode for drawing routines */ + +#define CoordModeOrigin 0 /* relative to the origin */ +#define CoordModePrevious 1 /* relative to previous point */ + +/* Polygon shapes */ + +#define Complex 0 /* paths may intersect */ +#define Nonconvex 1 /* no paths intersect, but not convex */ +#define Convex 2 /* wholly convex */ + +/* Arc modes for PolyFillArc */ + +#define ArcChord 0 /* join endpoints of arc */ +#define ArcPieSlice 1 /* join endpoints to center of arc */ + +/* GC components: masks used in CreateGC, CopyGC, ChangeGC, OR'ed into + GC.stateChanges */ + +#define GCFunction (1L<<0) +#define GCPlaneMask (1L<<1) +#define GCForeground (1L<<2) +#define GCBackground (1L<<3) +#define GCLineWidth (1L<<4) +#define GCLineStyle (1L<<5) +#define GCCapStyle (1L<<6) +#define GCJoinStyle (1L<<7) +#define GCFillStyle (1L<<8) +#define GCFillRule (1L<<9) +#define GCTile (1L<<10) +#define GCStipple (1L<<11) +#define GCTileStipXOrigin (1L<<12) +#define GCTileStipYOrigin (1L<<13) +#define GCFont (1L<<14) +#define GCSubwindowMode (1L<<15) +#define GCGraphicsExposures (1L<<16) +#define GCClipXOrigin (1L<<17) +#define GCClipYOrigin (1L<<18) +#define GCClipMask (1L<<19) +#define GCDashOffset (1L<<20) +#define GCDashList (1L<<21) +#define GCArcMode (1L<<22) + +#define GCLastBit 22 +/***************************************************************** + * FONTS + *****************************************************************/ + +/* used in QueryFont -- draw direction */ + +#define FontLeftToRight 0 +#define FontRightToLeft 1 + +#define FontChange 255 + +/***************************************************************** + * IMAGING + *****************************************************************/ + +/* ImageFormat -- PutImage, GetImage */ + +#define XYBitmap 0 /* depth 1, XYFormat */ +#define XYPixmap 1 /* depth == drawable depth */ +#define ZPixmap 2 /* depth == drawable depth */ + +/***************************************************************** + * COLOR MAP STUFF + *****************************************************************/ + +/* For CreateColormap */ + +#define AllocNone 0 /* create map with no entries */ +#define AllocAll 1 /* allocate entire map writeable */ + + +/* Flags used in StoreNamedColor, StoreColors */ + +#define DoRed (1<<0) +#define DoGreen (1<<1) +#define DoBlue (1<<2) + +/***************************************************************** + * CURSOR STUFF + *****************************************************************/ + +/* QueryBestSize Class */ + +#define CursorShape 0 /* largest size that can be displayed */ +#define TileShape 1 /* size tiled fastest */ +#define StippleShape 2 /* size stippled fastest */ + +/***************************************************************** + * KEYBOARD/POINTER STUFF + *****************************************************************/ + +#define AutoRepeatModeOff 0 +#define AutoRepeatModeOn 1 +#define AutoRepeatModeDefault 2 + +#define LedModeOff 0 +#define LedModeOn 1 + +/* masks for ChangeKeyboardControl */ + +#define KBKeyClickPercent (1L<<0) +#define KBBellPercent (1L<<1) +#define KBBellPitch (1L<<2) +#define KBBellDuration (1L<<3) +#define KBLed (1L<<4) +#define KBLedMode (1L<<5) +#define KBKey (1L<<6) +#define KBAutoRepeatMode (1L<<7) + +#define MappingSuccess 0 +#define MappingBusy 1 +#define MappingFailed 2 + +#define MappingModifier 0 +#define MappingKeyboard 1 +#define MappingPointer 2 + +/***************************************************************** + * SCREEN SAVER STUFF + *****************************************************************/ + +#define DontPreferBlanking 0 +#define PreferBlanking 1 +#define DefaultBlanking 2 + +#define DisableScreenSaver 0 +#define DisableScreenInterval 0 + +#define DontAllowExposures 0 +#define AllowExposures 1 +#define DefaultExposures 2 + +/* for ForceScreenSaver */ + +#define ScreenSaverReset 0 +#define ScreenSaverActive 1 + +/***************************************************************** + * HOSTS AND CONNECTIONS + *****************************************************************/ + +/* for ChangeHosts */ + +#define HostInsert 0 +#define HostDelete 1 + +/* for ChangeAccessControl */ + +#define EnableAccess 1 +#define DisableAccess 0 + +/* Display classes used in opening the connection + * Note that the statically allocated ones are even numbered and the + * dynamically changeable ones are odd numbered */ + +#define StaticGray 0 +#define GrayScale 1 +#define StaticColor 2 +#define PseudoColor 3 +#define TrueColor 4 +#define DirectColor 5 + + +/* Byte order used in imageByteOrder and bitmapBitOrder */ + +#define LSBFirst 0 +#define MSBFirst 1 + +#endif /* X_H */ diff --git a/engine/qux/Xmd.h b/engine/qux/Xmd.h new file mode 100644 index 000000000..377b9bcd6 --- /dev/null +++ b/engine/qux/Xmd.h @@ -0,0 +1,205 @@ +/* $XFree86: xc/include/Xmd.h,v 3.16 2002/05/31 18:45:39 dawes Exp $ */ +/*********************************************************** + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ +#ifndef XMD_H +#define XMD_H 1 +/* $Xorg: Xmd.h,v 1.4 2001/02/09 02:03:22 xorgcvs Exp $ */ +/* + * Xmd.h: MACHINE DEPENDENT DECLARATIONS. + */ + +/* + * Special per-machine configuration flags. + */ +#ifdef CRAY +#define WORD64 /* 64-bit architecture */ +#endif +#if defined(__alpha) || defined(__alpha__) || \ + defined(__ia64__) || defined(ia64) || \ + defined(__sparc64__) || \ + defined(__s390x__) || \ + (defined(__hppa__) && defined(__LP64__)) || \ + defined(__x86_64__) || defined(x86_64) +#define LONG64 /* 32/64-bit architecture */ +#endif +#ifdef __sgi +#if (_MIPS_SZLONG == 64) +#define LONG64 +#endif +#endif + +/* + * Stuff to handle large architecture machines; the constants were generated + * on a 32-bit machine and must coorespond to the protocol. + */ +#ifdef WORD64 +#define MUSTCOPY +#endif /* WORD64 */ + + +/* + * Definition of macro used to set constants for size of network structures; + * machines with preprocessors that can't handle all of the sz_ symbols + * can define this macro to be sizeof(x) if and only if their compiler doesn't + * pad out structures (esp. the xTextElt structure which contains only two + * one-byte fields). Network structures should always define sz_symbols. + * + * The sz_ prefix is used instead of something more descriptive so that the + * symbols are no more than 32 characters long (which causes problems for some + * compilers and preprocessors). + * + * The extra indirection in the __STDC__ case is to get macro arguments to + * expand correctly before the concatenation, rather than afterward. + */ +#if ((defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus)) && !defined(UNIXCPP)) || defined(ANSICPP) +#define _SIZEOF(x) sz_##x +#define SIZEOF(x) _SIZEOF(x) +#else +#define SIZEOF(x) sz_/**/x +#endif /* if ANSI C compiler else not */ + +/* + * Bitfield suffixes for the protocol structure elements, if you + * need them. Note that bitfields are not guarranteed to be signed + * (or even unsigned) according to ANSI C. + */ +#ifdef WORD64 +typedef long INT64; +typedef unsigned long CARD64; +#define B32 :32 +#define B16 :16 +#ifdef UNSIGNEDBITFIELDS +typedef unsigned int INT32; +typedef unsigned int INT16; +#else +#ifdef __STDC__ +typedef signed int INT32; +typedef signed int INT16; +#else +typedef int INT32; +typedef int INT16; +#endif +#endif +#else +#define B32 +#define B16 +#ifdef LONG64 +typedef long INT64; +typedef int INT32; +#else +typedef long INT32; +#endif +typedef short INT16; +#endif + +#if defined(__STDC__) || defined(sgi) || defined(AIXV3) +typedef signed char INT8; +#else +typedef char INT8; +#endif + +#ifdef LONG64 +typedef unsigned long CARD64; +typedef unsigned int CARD32; +#else +typedef unsigned long CARD32; +#endif +typedef unsigned short CARD16; +typedef unsigned char CARD8; + +typedef CARD32 BITS32; +typedef CARD16 BITS16; + +#ifndef I_NEED_OS2_H +typedef CARD8 BYTE; +typedef CARD8 BOOL; +#else +#define BYTE CARD8 +#define BOOL CARD8 +#endif + +/* + * definitions for sign-extending bitfields on 64-bit architectures + */ +#if defined(WORD64) && defined(UNSIGNEDBITFIELDS) +#define cvtINT8toInt(val) (((val) & 0x00000080) ? ((val) | 0xffffffffffffff00) : (val)) +#define cvtINT16toInt(val) (((val) & 0x00008000) ? ((val) | 0xffffffffffff0000) : (val)) +#define cvtINT32toInt(val) (((val) & 0x80000000) ? ((val) | 0xffffffff00000000) : (val)) +#define cvtINT8toShort(val) cvtINT8toInt(val) +#define cvtINT16toShort(val) cvtINT16toInt(val) +#define cvtINT32toShort(val) cvtINT32toInt(val) +#define cvtINT8toLong(val) cvtINT8toInt(val) +#define cvtINT16toLong(val) cvtINT16toInt(val) +#define cvtINT32toLong(val) cvtINT32toInt(val) +#else +#define cvtINT8toInt(val) (val) +#define cvtINT16toInt(val) (val) +#define cvtINT32toInt(val) (val) +#define cvtINT8toShort(val) (val) +#define cvtINT16toShort(val) (val) +#define cvtINT32toShort(val) (val) +#define cvtINT8toLong(val) (val) +#define cvtINT16toLong(val) (val) +#define cvtINT32toLong(val) (val) +#endif /* WORD64 and UNSIGNEDBITFIELDS */ + + + +#ifdef MUSTCOPY +/* + * This macro must not cast or else pointers will get aligned and be wrong + */ +#define NEXTPTR(p,t) (((char *) p) + SIZEOF(t)) +#else /* else not MUSTCOPY, this is used for 32-bit machines */ +/* + * this version should leave result of type (t *), but that should only be + * used when not in MUSTCOPY + */ +#define NEXTPTR(p,t) (((t *)(p)) + 1) +#endif /* MUSTCOPY - used machines whose C structs don't line up with proto */ + +#endif /* XMD_H */ diff --git a/engine/qux/Xproto.h b/engine/qux/Xproto.h new file mode 100644 index 000000000..25371c3cc --- /dev/null +++ b/engine/qux/Xproto.h @@ -0,0 +1,2132 @@ +//the only changes in this file for qux support are with header file locations. + + +/* + * $Xorg: Xproto.h,v 1.4 2001/02/09 02:03:23 xorgcvs Exp $ + */ + +/* Definitions for the X window system used by server and c bindings */ + +/* + * This packet-construction scheme makes the following assumptions: + * + * 1. The compiler is able + * to generate code which addresses one- and two-byte quantities. + * In the worst case, this would be done with bit-fields. If bit-fields + * are used it may be necessary to reorder the request fields in this file, + * depending on the order in which the machine assigns bit fields to + * machine words. There may also be a problem with sign extension, + * as K+R specify that bitfields are always unsigned. + * + * 2. 2- and 4-byte fields in packet structures must be ordered by hand + * such that they are naturally-aligned, so that no compiler will ever + * insert padding bytes. + * + * 3. All packets are hand-padded to a multiple of 4 bytes, for + * the same reason. + */ + +#ifndef XPROTO_H +#define XPROTO_H + +/*********************************************************** + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +#include "Xmd.h" +#include "Xprotostr.h" + +/* + * Define constants for the sizes of the network packets. The sz_ prefix is + * used instead of something more descriptive so that the symbols are no more + * than 32 characters in length (which causes problems for some compilers). + */ +#define sz_xSegment 8 +#define sz_xPoint 4 +#define sz_xRectangle 8 +#define sz_xArc 12 +#define sz_xConnClientPrefix 12 +#define sz_xConnSetupPrefix 8 +#define sz_xConnSetup 32 +#define sz_xPixmapFormat 8 +#define sz_xDepth 8 +#define sz_xVisualType 24 +#define sz_xWindowRoot 40 +#define sz_xTimecoord 8 +#define sz_xHostEntry 4 +#define sz_xCharInfo 12 +#define sz_xFontProp 8 +#define sz_xTextElt 2 +#define sz_xColorItem 12 +#define sz_xrgb 8 +#define sz_xGenericReply 32 +#define sz_xGetWindowAttributesReply 44 +#define sz_xGetGeometryReply 32 +#define sz_xQueryTreeReply 32 +#define sz_xInternAtomReply 32 +#define sz_xGetAtomNameReply 32 +#define sz_xGetPropertyReply 32 +#define sz_xListPropertiesReply 32 +#define sz_xGetSelectionOwnerReply 32 +#define sz_xGrabPointerReply 32 +#define sz_xQueryPointerReply 32 +#define sz_xGetMotionEventsReply 32 +#define sz_xTranslateCoordsReply 32 +#define sz_xGetInputFocusReply 32 +#define sz_xQueryKeymapReply 40 +#define sz_xQueryFontReply 60 +#define sz_xQueryTextExtentsReply 32 +#define sz_xListFontsReply 32 +#define sz_xGetFontPathReply 32 +#define sz_xGetImageReply 32 +#define sz_xListInstalledColormapsReply 32 +#define sz_xAllocColorReply 32 +#define sz_xAllocNamedColorReply 32 +#define sz_xAllocColorCellsReply 32 +#define sz_xAllocColorPlanesReply 32 +#define sz_xQueryColorsReply 32 +#define sz_xLookupColorReply 32 +#define sz_xQueryBestSizeReply 32 +#define sz_xQueryExtensionReply 32 +#define sz_xListExtensionsReply 32 +#define sz_xSetMappingReply 32 +#define sz_xGetKeyboardControlReply 52 +#define sz_xGetPointerControlReply 32 +#define sz_xGetScreenSaverReply 32 +#define sz_xListHostsReply 32 +#define sz_xSetModifierMappingReply 32 +#define sz_xError 32 +#define sz_xEvent 32 +#define sz_xKeymapEvent 32 +#define sz_xReq 4 +#define sz_xResourceReq 8 +#define sz_xCreateWindowReq 32 +#define sz_xChangeWindowAttributesReq 12 +#define sz_xChangeSaveSetReq 8 +#define sz_xReparentWindowReq 16 +#define sz_xConfigureWindowReq 12 +#define sz_xCirculateWindowReq 8 +#define sz_xInternAtomReq 8 +#define sz_xChangePropertyReq 24 +#define sz_xDeletePropertyReq 12 +#define sz_xGetPropertyReq 24 +#define sz_xSetSelectionOwnerReq 16 +#define sz_xConvertSelectionReq 24 +#define sz_xSendEventReq 44 +#define sz_xGrabPointerReq 24 +#define sz_xGrabButtonReq 24 +#define sz_xUngrabButtonReq 12 +#define sz_xChangeActivePointerGrabReq 16 +#define sz_xGrabKeyboardReq 16 +#define sz_xGrabKeyReq 16 +#define sz_xUngrabKeyReq 12 +#define sz_xAllowEventsReq 8 +#define sz_xGetMotionEventsReq 16 +#define sz_xTranslateCoordsReq 16 +#define sz_xWarpPointerReq 24 +#define sz_xSetInputFocusReq 12 +#define sz_xOpenFontReq 12 +#define sz_xQueryTextExtentsReq 8 +#define sz_xListFontsReq 8 +#define sz_xSetFontPathReq 8 +#define sz_xCreatePixmapReq 16 +#define sz_xCreateGCReq 16 +#define sz_xChangeGCReq 12 +#define sz_xCopyGCReq 16 +#define sz_xSetDashesReq 12 +#define sz_xSetClipRectanglesReq 12 +#define sz_xCopyAreaReq 28 +#define sz_xCopyPlaneReq 32 +#define sz_xPolyPointReq 12 +#define sz_xPolySegmentReq 12 +#define sz_xFillPolyReq 16 +#define sz_xPutImageReq 24 +#define sz_xGetImageReq 20 +#define sz_xPolyTextReq 16 +#define sz_xImageTextReq 16 +#define sz_xCreateColormapReq 16 +#define sz_xCopyColormapAndFreeReq 12 +#define sz_xAllocColorReq 16 +#define sz_xAllocNamedColorReq 12 +#define sz_xAllocColorCellsReq 12 +#define sz_xAllocColorPlanesReq 16 +#define sz_xFreeColorsReq 12 +#define sz_xStoreColorsReq 8 +#define sz_xStoreNamedColorReq 16 +#define sz_xQueryColorsReq 8 +#define sz_xLookupColorReq 12 +#define sz_xCreateCursorReq 32 +#define sz_xCreateGlyphCursorReq 32 +#define sz_xRecolorCursorReq 20 +#define sz_xQueryBestSizeReq 12 +#define sz_xQueryExtensionReq 8 +#define sz_xChangeKeyboardControlReq 8 +#define sz_xBellReq 4 +#define sz_xChangePointerControlReq 12 +#define sz_xSetScreenSaverReq 12 +#define sz_xChangeHostsReq 8 +#define sz_xListHostsReq 4 +#define sz_xChangeModeReq 4 +#define sz_xRotatePropertiesReq 12 +#define sz_xReply 32 +#define sz_xGrabKeyboardReply 32 +#define sz_xListFontsWithInfoReply 60 +#define sz_xSetPointerMappingReply 32 +#define sz_xGetKeyboardMappingReply 32 +#define sz_xGetPointerMappingReply 32 +#define sz_xGetModifierMappingReply 32 +#define sz_xListFontsWithInfoReq 8 +#define sz_xPolyLineReq 12 +#define sz_xPolyArcReq 12 +#define sz_xPolyRectangleReq 12 +#define sz_xPolyFillRectangleReq 12 +#define sz_xPolyFillArcReq 12 +#define sz_xPolyText8Req 16 +#define sz_xPolyText16Req 16 +#define sz_xImageText8Req 16 +#define sz_xImageText16Req 16 +#define sz_xSetPointerMappingReq 4 +#define sz_xForceScreenSaverReq 4 +#define sz_xSetCloseDownModeReq 4 +#define sz_xClearAreaReq 16 +#define sz_xSetAccessControlReq 4 +#define sz_xGetKeyboardMappingReq 8 +#define sz_xSetModifierMappingReq 4 +#define sz_xPropIconSize 24 +#define sz_xChangeKeyboardMappingReq 8 + + +/* For the purpose of the structure definitions in this file, +we must redefine the following types in terms of Xmd.h's types, which may +include bit fields. All of these are #undef'd at the end of this file, +restoring the definitions in X.h. */ + +#define Window CARD32 +#define Drawable CARD32 +#define Font CARD32 +#define Pixmap CARD32 +#define Cursor CARD32 +#define Colormap CARD32 +#define GContext CARD32 +#define Atom CARD32 +#define VisualID CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 + +#define X_TCP_PORT 6000 /* add display number */ + +#define xTrue 1 +#define xFalse 0 + + +typedef CARD16 KeyButMask; + +/***************** + connection setup structure. This is followed by + numRoots xWindowRoot structs. +*****************/ + +typedef struct { + CARD8 byteOrder; + BYTE pad; + CARD16 majorVersion B16, minorVersion B16; + CARD16 nbytesAuthProto B16; /* Authorization protocol */ + CARD16 nbytesAuthString B16; /* Authorization string */ + CARD16 pad2 B16; +} xConnClientPrefix; + +typedef struct { + CARD8 success; + BYTE lengthReason; /*num bytes in string following if failure */ + CARD16 majorVersion B16, + minorVersion B16; + CARD16 length B16; /* 1/4 additional bytes in setup info */ +} xConnSetupPrefix; + + +typedef struct { + CARD32 release B32; + CARD32 ridBase B32, + ridMask B32; + CARD32 motionBufferSize B32; + CARD16 nbytesVendor B16; /* number of bytes in vendor string */ + CARD16 maxRequestSize B16; + CARD8 numRoots; /* number of roots structs to follow */ + CARD8 numFormats; /* number of pixmap formats */ + CARD8 imageByteOrder; /* LSBFirst, MSBFirst */ + CARD8 bitmapBitOrder; /* LeastSignificant, MostSign...*/ + CARD8 bitmapScanlineUnit, /* 8, 16, 32 */ + bitmapScanlinePad; /* 8, 16, 32 */ + KeyCode minKeyCode, maxKeyCode; + CARD32 pad2 B32; +} xConnSetup; + +typedef struct { + CARD8 depth; + CARD8 bitsPerPixel; + CARD8 scanLinePad; + CARD8 pad1; + CARD32 pad2 B32; +} xPixmapFormat; + +/* window root */ + +typedef struct { + CARD8 depth; + CARD8 pad1; + CARD16 nVisuals B16; /* number of xVisualType structures following */ + CARD32 pad2 B32; + } xDepth; + +typedef struct { + VisualID visualID B32; +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 bitsPerRGB; + CARD16 colormapEntries B16; + CARD32 redMask B32, greenMask B32, blueMask B32; + CARD32 pad B32; + } xVisualType; + +typedef struct { + Window windowId B32; + Colormap defaultColormap B32; + CARD32 whitePixel B32, blackPixel B32; + CARD32 currentInputMask B32; + CARD16 pixWidth B16, pixHeight B16; + CARD16 mmWidth B16, mmHeight B16; + CARD16 minInstalledMaps B16, maxInstalledMaps B16; + VisualID rootVisualID B32; + CARD8 backingStore; + BOOL saveUnders; + CARD8 rootDepth; + CARD8 nDepths; /* number of xDepth structures following */ +} xWindowRoot; + + +/***************************************************************** + * Structure Defns + * Structures needed for replies + *****************************************************************/ + +/* Used in GetMotionEvents */ + +typedef struct { + CARD32 time B32; + INT16 x B16, y B16; +} xTimecoord; + +typedef struct { + CARD8 family; + BYTE pad; + CARD16 length B16; +} xHostEntry; + +typedef struct { + INT16 leftSideBearing B16, + rightSideBearing B16, + characterWidth B16, + ascent B16, + descent B16; + CARD16 attributes B16; +} xCharInfo; + +typedef struct { + Atom name B32; + CARD32 value B32; +} xFontProp; + +/* + * non-aligned big-endian font ID follows this struct + */ +typedef struct { /* followed by string */ + CARD8 len; /* number of *characters* in string, or FontChange (255) + for font change, or 0 if just delta given */ + INT8 delta; +} xTextElt; + + +typedef struct { + CARD32 pixel B32; + CARD16 red B16, green B16, blue B16; + CARD8 flags; /* DoRed, DoGreen, DoBlue booleans */ + CARD8 pad; +} xColorItem; + + +typedef struct { + CARD16 red B16, green B16, blue B16, pad B16; +} xrgb; + +typedef CARD8 KEYCODE; + + +/***************** + * XRep: + * meant to be 32 byte quantity + *****************/ + +/* GenericReply is the common format of all replies. The "data" items + are specific to each individual reply type. */ + +typedef struct { + BYTE type; /* X_Reply */ + BYTE data1; /* depends on reply type */ + CARD16 sequenceNumber B16; /* of last request received by server */ + CARD32 length B32; /* 4 byte quantities beyond size of GenericReply */ + CARD32 data00 B32; + CARD32 data01 B32; + CARD32 data02 B32; + CARD32 data03 B32; + CARD32 data04 B32; + CARD32 data05 B32; + } xGenericReply; + +/* Individual reply formats. */ + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 backingStore; + CARD16 sequenceNumber B16; + CARD32 length B32; /* NOT 0; this is an extra-large reply */ + VisualID visualID B32; +#if defined(__cplusplus) || defined(c_plusplus) + CARD16 c_class B16; +#else + CARD16 class B16; +#endif + CARD8 bitGravity; + CARD8 winGravity; + CARD32 backingBitPlanes B32; + CARD32 backingPixel B32; + BOOL saveUnder; + BOOL mapInstalled; + CARD8 mapState; + BOOL override; + Colormap colormap B32; + CARD32 allEventMasks B32; + CARD32 yourEventMask B32; + CARD16 doNotPropagateMask B16; + CARD16 pad B16; + } xGetWindowAttributesReply; + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 depth; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + Window root B32; + INT16 x B16, y B16; + CARD16 width B16, height B16; + CARD16 borderWidth B16; + CARD16 pad1 B16; + CARD32 pad2 B32; + CARD32 pad3 B32; + } xGetGeometryReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + Window root B32, parent B32; + CARD16 nChildren B16; + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xQueryTreeReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + Atom atom B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + } xInternAtomReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* of additional bytes */ + CARD16 nameLength B16; /* # of characters in name */ + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xGetAtomNameReply; + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 format; + CARD16 sequenceNumber B16; + CARD32 length B32; /* of additional bytes */ + Atom propertyType B32; + CARD32 bytesAfter B32; + CARD32 nItems B32; /* # of 8, 16, or 32-bit entities in reply */ + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + } xGetPropertyReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nProperties B16; + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xListPropertiesReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + Window owner B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + } xGetSelectionOwnerReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE status; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + } xGrabPointerReply; + +typedef xGrabPointerReply xGrabKeyboardReply; + +typedef struct { + BYTE type; /* X_Reply */ + BOOL sameScreen; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + Window root B32, child B32; + INT16 rootX B16, rootY B16, winX B16, winY B16; + CARD16 mask B16; + CARD16 pad1 B16; + CARD32 pad B32; + } xQueryPointerReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 nEvents B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + } xGetMotionEventsReply; + +typedef struct { + BYTE type; /* X_Reply */ + BOOL sameScreen; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + Window child B32; + INT16 dstX B16, dstY B16; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xTranslateCoordsReply; + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 revertTo; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + Window focus B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xGetInputFocusReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 2, NOT 0; this is an extra-large reply */ + BYTE map[32]; + } xQueryKeymapReply; + +/* Warning: this MUST match (up to component renaming) xListFontsWithInfoReply */ +typedef struct _xQueryFontReply { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* definitely > 0, even if "nCharInfos" is 0 */ + xCharInfo minBounds; +#ifndef WORD64 + CARD32 walign1 B32; +#endif + xCharInfo maxBounds; +#ifndef WORD64 + CARD32 walign2 B32; +#endif + CARD16 minCharOrByte2 B16, maxCharOrByte2 B16; + CARD16 defaultChar B16; + CARD16 nFontProps B16; /* followed by this many xFontProp structures */ + CARD8 drawDirection; + CARD8 minByte1, maxByte1; + BOOL allCharsExist; + INT16 fontAscent B16, fontDescent B16; + CARD32 nCharInfos B32; /* followed by this many xCharInfo structures */ +} xQueryFontReply; + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 drawDirection; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + INT16 fontAscent B16, fontDescent B16; + INT16 overallAscent B16, overallDescent B16; + INT32 overallWidth B32, overallLeft B32, overallRight B32; + CARD32 pad B32; + } xQueryTextExtentsReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nFonts B16; + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xListFontsReply; + +/* Warning: this MUST match (up to component renaming) xQueryFontReply */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 nameLength; /* 0 indicates end-of-reply-sequence */ + CARD16 sequenceNumber B16; + CARD32 length B32; /* definitely > 0, even if "nameLength" is 0 */ + xCharInfo minBounds; +#ifndef WORD64 + CARD32 walign1 B32; +#endif + xCharInfo maxBounds; +#ifndef WORD64 + CARD32 walign2 B32; +#endif + CARD16 minCharOrByte2 B16, maxCharOrByte2 B16; + CARD16 defaultChar B16; + CARD16 nFontProps B16; /* followed by this many xFontProp structures */ + CARD8 drawDirection; + CARD8 minByte1, maxByte1; + BOOL allCharsExist; + INT16 fontAscent B16, fontDescent B16; + CARD32 nReplies B32; /* hint as to how many more replies might be coming */ +} xListFontsWithInfoReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nPaths B16; + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xGetFontPathReply; + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 depth; + CARD16 sequenceNumber B16; + CARD32 length B32; + VisualID visual B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xGetImageReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nColormaps B16; + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xListInstalledColormapsReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + CARD16 red B16, green B16, blue B16; + CARD16 pad2 B16; + CARD32 pixel B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xAllocColorReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + CARD32 pixel B32; + CARD16 exactRed B16, exactGreen B16, exactBlue B16; + CARD16 screenRed B16, screenGreen B16, screenBlue B16; + CARD32 pad2 B32; + CARD32 pad3 B32; + } xAllocNamedColorReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nPixels B16, nMasks B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xAllocColorCellsReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nPixels B16; + CARD16 pad2 B16; + CARD32 redMask B32, greenMask B32, blueMask B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + } xAllocColorPlanesReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nColors B16; + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xQueryColorsReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + CARD16 exactRed B16, exactGreen B16, exactBlue B16; + CARD16 screenRed B16, screenGreen B16, screenBlue B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + } xLookupColorReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + CARD16 width B16, height B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xQueryBestSizeReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + BOOL present; + CARD8 major_opcode; + CARD8 first_event; + CARD8 first_error; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xQueryExtensionReply; + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 nExtensions; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xListExtensionsReply; + + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 success; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xSetMappingReply; +typedef xSetMappingReply xSetPointerMappingReply; +typedef xSetMappingReply xSetModifierMappingReply; + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 nElts; /* how many elements does the map have */ + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xGetPointerMappingReply; + +typedef struct { + BYTE type; + CARD8 keySymsPerKeyCode; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; +} xGetKeyboardMappingReply; + +typedef struct { + BYTE type; + CARD8 numKeyPerModifier; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; +} xGetModifierMappingReply; + +typedef struct { + BYTE type; /* X_Reply */ + BOOL globalAutoRepeat; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 5 */ + CARD32 ledMask B32; + CARD8 keyClickPercent, bellPercent; + CARD16 bellPitch B16, bellDuration B16; + CARD16 pad B16; + BYTE map[32]; /* bit masks start here */ + } xGetKeyboardControlReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + CARD16 accelNumerator B16, accelDenominator B16; + CARD16 threshold B16; + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + } xGetPointerControlReply; + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; /* 0 */ + CARD16 timeout B16, interval B16; + BOOL preferBlanking; + BOOL allowExposures; + CARD16 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + } xGetScreenSaverReply; + +typedef struct { + BYTE type; /* X_Reply */ + BOOL enabled; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nHosts B16; + CARD16 pad1 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; + } xListHostsReply; + + + + +/***************************************************************** + * Xerror + * All errors are 32 bytes + *****************************************************************/ + +typedef struct { + BYTE type; /* X_Error */ + BYTE errorCode; + CARD16 sequenceNumber B16; /* the nth request from this client */ + CARD32 resourceID B32; + CARD16 minorCode B16; + CARD8 majorCode; + BYTE pad1; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; + CARD32 pad7 B32; +} xError; + +/***************************************************************** + * xEvent + * All events are 32 bytes + *****************************************************************/ + +typedef struct _xEvent { + union { + struct { + BYTE type; + BYTE detail; + CARD16 sequenceNumber B16; + } u; + struct { + CARD32 pad00 B32; + Time time B32; + Window root B32, event B32, child B32; + INT16 rootX B16, rootY B16, eventX B16, eventY B16; + KeyButMask state B16; + BOOL sameScreen; + BYTE pad1; + } keyButtonPointer; + struct { + CARD32 pad00 B32; + Time time B32; + Window root B32, event B32, child B32; + INT16 rootX B16, rootY B16, eventX B16, eventY B16; + KeyButMask state B16; + BYTE mode; /* really XMode */ + BYTE flags; /* sameScreen and focus booleans, packed together */ +#define ELFlagFocus (1<<0) +#define ELFlagSameScreen (1<<1) + } enterLeave; + struct { + CARD32 pad00 B32; + Window window B32; + BYTE mode; /* really XMode */ + BYTE pad1, pad2, pad3; + } focus; + struct { + CARD32 pad00 B32; + Window window B32; + CARD16 x B16, y B16, width B16, height B16; + CARD16 count B16; + CARD16 pad2 B16; + } expose; + struct { + CARD32 pad00 B32; + Drawable drawable B32; + CARD16 x B16, y B16, width B16, height B16; + CARD16 minorEvent B16; + CARD16 count B16; + BYTE majorEvent; + BYTE pad1, pad2, pad3; + } graphicsExposure; + struct { + CARD32 pad00 B32; + Drawable drawable B32; + CARD16 minorEvent B16; + BYTE majorEvent; + BYTE bpad; + } noExposure; + struct { + CARD32 pad00 B32; + Window window B32; + CARD8 state; + BYTE pad1, pad2, pad3; + } visibility; + struct { + CARD32 pad00 B32; + Window parent B32, window B32; + INT16 x B16, y B16; + CARD16 width B16, height B16, borderWidth B16; + BOOL override; + BYTE bpad; + } createNotify; +/* + * The event feilds in the structures for DestroyNotify, UnmapNotify, + * MapNotify, ReparentNotify, ConfigureNotify, CirclulateNotify, GravityNotify, + * must be at the same offset because server internal code is depending upon + * this to patch up the events before they are delivered. + * Also note that MapRequest, ConfigureRequest and CirculateRequest have + * the same offset for the event window. + */ + struct { + CARD32 pad00 B32; + Window event B32, window B32; + } destroyNotify; + struct { + CARD32 pad00 B32; + Window event B32, window B32; + BOOL fromConfigure; + BYTE pad1, pad2, pad3; + } unmapNotify; + struct { + CARD32 pad00 B32; + Window event B32, window B32; + BOOL override; + BYTE pad1, pad2, pad3; + } mapNotify; + struct { + CARD32 pad00 B32; + Window parent B32, window B32; + } mapRequest; + struct { + CARD32 pad00 B32; + Window event B32, window B32, parent B32; + INT16 x B16, y B16; + BOOL override; + BYTE pad1, pad2, pad3; + } reparent; + struct { + CARD32 pad00 B32; + Window event B32, window B32, aboveSibling B32; + INT16 x B16, y B16; + CARD16 width B16, height B16, borderWidth B16; + BOOL override; + BYTE bpad; + } configureNotify; + struct { + CARD32 pad00 B32; + Window parent B32, window B32, sibling B32; + INT16 x B16, y B16; + CARD16 width B16, height B16, borderWidth B16; + CARD16 valueMask B16; + CARD32 pad1 B32; + } configureRequest; + struct { + CARD32 pad00 B32; + Window event B32, window B32; + INT16 x B16, y B16; + CARD32 pad1 B32, pad2 B32, pad3 B32, pad4 B32; + } gravity; + struct { + CARD32 pad00 B32; + Window window B32; + CARD16 width B16, height B16; + } resizeRequest; + struct { +/* The event field in the circulate record is really the parent when this + is used as a CirculateRequest insteaad of a CircluateNotify */ + CARD32 pad00 B32; + Window event B32, window B32, parent B32; + BYTE place; /* Top or Bottom */ + BYTE pad1, pad2, pad3; + } circulate; + struct { + CARD32 pad00 B32; + Window window B32; + Atom atom B32; + Time time B32; + BYTE state; /* NewValue or Deleted */ + BYTE pad1; + CARD16 pad2 B16; + } property; + struct { + CARD32 pad00 B32; + Time time B32; + Window window B32; + Atom atom B32; + } selectionClear; + struct { + CARD32 pad00 B32; + Time time B32; + Window owner B32, requestor B32; + Atom selection B32, target B32, property B32; + } selectionRequest; + struct { + CARD32 pad00 B32; + Time time B32; + Window requestor B32; + Atom selection B32, target B32, property B32; + } selectionNotify; + struct { + CARD32 pad00 B32; + Window window B32; + Colormap colormap B32; +#if defined(__cplusplus) || defined(c_plusplus) + BOOL c_new; +#else + BOOL new; +#endif + BYTE state; /* Installed or UnInstalled */ + BYTE pad1, pad2; + } colormap; + struct { + CARD32 pad00 B32; + CARD8 request; + KeyCode firstKeyCode; + CARD8 count; + BYTE pad1; + } mappingNotify; + struct { + CARD32 pad00 B32; + Window window B32; + union { + struct { + Atom type B32; + INT32 longs0 B32; + INT32 longs1 B32; + INT32 longs2 B32; + INT32 longs3 B32; + INT32 longs4 B32; + } l; + struct { + Atom type B32; + INT16 shorts0 B16; + INT16 shorts1 B16; + INT16 shorts2 B16; + INT16 shorts3 B16; + INT16 shorts4 B16; + INT16 shorts5 B16; + INT16 shorts6 B16; + INT16 shorts7 B16; + INT16 shorts8 B16; + INT16 shorts9 B16; + } s; + struct { + Atom type B32; + INT8 bytes[20]; + } b; + } u; + } clientMessage; + } u; +} xEvent; + +/* KeymapNotify events are not included in the above union because they + are different from all other events: they do not have a "detail" + or "sequenceNumber", so there is room for a 248-bit key mask. */ + +typedef struct { + BYTE type; + BYTE map[31]; + } xKeymapEvent; + +#define XEventSize (sizeof(xEvent)) + +/* XReply is the union of all the replies above whose "fixed part" +fits in 32 bytes. It does NOT include GetWindowAttributesReply, +QueryFontReply, QueryKeymapReply, or GetKeyboardControlReply +ListFontsWithInfoReply */ + +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; + + + +/***************************************************************** + * REQUESTS + *****************************************************************/ + + +/* Request structure */ + +typedef struct _xReq { + CARD8 reqType; + CARD8 data; /* meaning depends on request type */ + CARD16 length B16; /* length in 4 bytes quantities + of whole request, including this header */ +} xReq; + +/***************************************************************** + * structures that follow request. + *****************************************************************/ + +/* ResourceReq is used for any request which has a resource ID + (or Atom or Time) as its one and only argument. */ + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + CARD32 id B32; /* a Window, Drawable, Font, GContext, Pixmap, etc. */ + } xResourceReq; + +typedef struct { + CARD8 reqType; + CARD8 depth; + CARD16 length B16; + Window wid B32, parent B32; + INT16 x B16, y B16; + CARD16 width B16, height B16, borderWidth B16; +#if defined(__cplusplus) || defined(c_plusplus) + CARD16 c_class B16; +#else + CARD16 class B16; +#endif + VisualID visual B32; + CARD32 mask B32; +} xCreateWindowReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window window B32; + CARD32 valueMask B32; +} xChangeWindowAttributesReq; + +typedef struct { + CARD8 reqType; + BYTE mode; + CARD16 length B16; + Window window B32; +} xChangeSaveSetReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window window B32, parent B32; + INT16 x B16, y B16; +} xReparentWindowReq; + +typedef struct { + CARD8 reqType; + CARD8 pad; + CARD16 length B16; + Window window B32; + CARD16 mask B16; + CARD16 pad2 B16; +} xConfigureWindowReq; + +typedef struct { + CARD8 reqType; + CARD8 direction; + CARD16 length B16; + Window window B32; +} xCirculateWindowReq; + +typedef struct { /* followed by padded string */ + CARD8 reqType; + BOOL onlyIfExists; + CARD16 length B16; + CARD16 nbytes B16; /* number of bytes in string */ + CARD16 pad B16; +} xInternAtomReq; + +typedef struct { + CARD8 reqType; + CARD8 mode; + CARD16 length B16; + Window window B32; + Atom property B32, type B32; + CARD8 format; + BYTE pad[3]; + CARD32 nUnits B32; /* length of stuff following, depends on format */ +} xChangePropertyReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window window B32; + Atom property B32; +} xDeletePropertyReq; + +typedef struct { + CARD8 reqType; +#if defined(__cplusplus) || defined(c_plusplus) + BOOL c_delete; +#else + BOOL delete; +#endif + CARD16 length B16; + Window window B32; + Atom property B32, type B32; + CARD32 longOffset B32; + CARD32 longLength B32; +} xGetPropertyReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window window B32; + Atom selection B32; + Time time B32; +} xSetSelectionOwnerReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window requestor B32; + Atom selection B32, target B32, property B32; + Time time B32; + } xConvertSelectionReq; + +typedef struct { + CARD8 reqType; + BOOL propagate; + CARD16 length B16; + Window destination B32; + CARD32 eventMask B32; +#ifdef WORD64 + /* the structure should have been quad-aligned */ + BYTE eventdata[SIZEOF(xEvent)]; +#else + xEvent event; +#endif /* WORD64 */ +} xSendEventReq; + +typedef struct { + CARD8 reqType; + BOOL ownerEvents; + CARD16 length B16; + Window grabWindow B32; + CARD16 eventMask B16; + BYTE pointerMode, keyboardMode; + Window confineTo B32; + Cursor cursor B32; + Time time B32; +} xGrabPointerReq; + +typedef struct { + CARD8 reqType; + BOOL ownerEvents; + CARD16 length B16; + Window grabWindow B32; + CARD16 eventMask B16; + BYTE pointerMode, keyboardMode; + Window confineTo B32; + Cursor cursor B32; + CARD8 button; + BYTE pad; + CARD16 modifiers B16; +} xGrabButtonReq; + +typedef struct { + CARD8 reqType; + CARD8 button; + CARD16 length B16; + Window grabWindow B32; + CARD16 modifiers B16; + CARD16 pad B16; +} xUngrabButtonReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Cursor cursor B32; + Time time B32; + CARD16 eventMask B16; + CARD16 pad2 B16; +} xChangeActivePointerGrabReq; + +typedef struct { + CARD8 reqType; + BOOL ownerEvents; + CARD16 length B16; + Window grabWindow B32; + Time time B32; + BYTE pointerMode, keyboardMode; + CARD16 pad B16; +} xGrabKeyboardReq; + +typedef struct { + CARD8 reqType; + BOOL ownerEvents; + CARD16 length B16; + Window grabWindow B32; + CARD16 modifiers B16; + CARD8 key; + BYTE pointerMode, keyboardMode; + BYTE pad1, pad2, pad3; +} xGrabKeyReq; + +typedef struct { + CARD8 reqType; + CARD8 key; + CARD16 length B16; + Window grabWindow B32; + CARD16 modifiers B16; + CARD16 pad B16; +} xUngrabKeyReq; + +typedef struct { + CARD8 reqType; + CARD8 mode; + CARD16 length B16; + Time time B32; +} xAllowEventsReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window window B32; + Time start B32, stop B32; +} xGetMotionEventsReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window srcWid B32, dstWid B32; + INT16 srcX B16, srcY B16; +} xTranslateCoordsReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window srcWid B32, dstWid B32; + INT16 srcX B16, srcY B16; + CARD16 srcWidth B16, srcHeight B16; + INT16 dstX B16, dstY B16; +} xWarpPointerReq; + +typedef struct { + CARD8 reqType; + CARD8 revertTo; + CARD16 length B16; + Window focus B32; + Time time B32; +} xSetInputFocusReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Font fid B32; + CARD16 nbytes B16; + BYTE pad1, pad2; /* string follows on word boundary */ +} xOpenFontReq; + +typedef struct { + CARD8 reqType; + BOOL oddLength; + CARD16 length B16; + Font fid B32; + } xQueryTextExtentsReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + CARD16 maxNames B16; + CARD16 nbytes B16; /* followed immediately by string bytes */ +} xListFontsReq; + +typedef xListFontsReq xListFontsWithInfoReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + CARD16 nFonts B16; + BYTE pad1, pad2; /* LISTofSTRING8 follows on word boundary */ +} xSetFontPathReq; + +typedef struct { + CARD8 reqType; + CARD8 depth; + CARD16 length B16; + Pixmap pid B32; + Drawable drawable B32; + CARD16 width B16, height B16; +} xCreatePixmapReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + GContext gc B32; + Drawable drawable B32; + CARD32 mask B32; +} xCreateGCReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + GContext gc B32; + CARD32 mask B32; +} xChangeGCReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + GContext srcGC B32, dstGC B32; + CARD32 mask B32; +} xCopyGCReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + GContext gc B32; + CARD16 dashOffset B16; + CARD16 nDashes B16; /* length LISTofCARD8 of values following */ +} xSetDashesReq; + +typedef struct { + CARD8 reqType; + BYTE ordering; + CARD16 length B16; + GContext gc B32; + INT16 xOrigin B16, yOrigin B16; +} xSetClipRectanglesReq; + +typedef struct { + CARD8 reqType; + BOOL exposures; + CARD16 length B16; + Window window B32; + INT16 x B16, y B16; + CARD16 width B16, height B16; +} xClearAreaReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Drawable srcDrawable B32, dstDrawable B32; + GContext gc B32; + INT16 srcX B16, srcY B16, dstX B16, dstY B16; + CARD16 width B16, height B16; +} xCopyAreaReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Drawable srcDrawable B32, dstDrawable B32; + GContext gc B32; + INT16 srcX B16, srcY B16, dstX B16, dstY B16; + CARD16 width B16, height B16; + CARD32 bitPlane B32; +} xCopyPlaneReq; + +typedef struct { + CARD8 reqType; + BYTE coordMode; + CARD16 length B16; + Drawable drawable B32; + GContext gc B32; +} xPolyPointReq; + +typedef xPolyPointReq xPolyLineReq; /* same request structure */ + +/* The following used for PolySegment, PolyRectangle, PolyArc, PolyFillRectangle, PolyFillArc */ + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Drawable drawable B32; + GContext gc B32; +} xPolySegmentReq; + +typedef xPolySegmentReq xPolyArcReq; +typedef xPolySegmentReq xPolyRectangleReq; +typedef xPolySegmentReq xPolyFillRectangleReq; +typedef xPolySegmentReq xPolyFillArcReq; + +typedef struct _FillPolyReq { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Drawable drawable B32; + GContext gc B32; + BYTE shape; + BYTE coordMode; + CARD16 pad1 B16; +} xFillPolyReq; + + +typedef struct _PutImageReq { + CARD8 reqType; + CARD8 format; + CARD16 length B16; + Drawable drawable B32; + GContext gc B32; + CARD16 width B16, height B16; + INT16 dstX B16, dstY B16; + CARD8 leftPad; + CARD8 depth; + CARD16 pad B16; +} xPutImageReq; + +typedef struct { + CARD8 reqType; + CARD8 format; + CARD16 length B16; + Drawable drawable B32; + INT16 x B16, y B16; + CARD16 width B16, height B16; + CARD32 planeMask B32; +} xGetImageReq; + +/* the folloiwng used by PolyText8 and PolyText16 */ + +typedef struct { + CARD8 reqType; + CARD8 pad; + CARD16 length B16; + Drawable drawable B32; + GContext gc B32; + INT16 x B16, y B16; /* items (xTextElt) start after struct */ +} xPolyTextReq; + +typedef xPolyTextReq xPolyText8Req; +typedef xPolyTextReq xPolyText16Req; + +typedef struct { + CARD8 reqType; + BYTE nChars; + CARD16 length B16; + Drawable drawable B32; + GContext gc B32; + INT16 x B16, y B16; +} xImageTextReq; + +typedef xImageTextReq xImageText8Req; +typedef xImageTextReq xImageText16Req; + +typedef struct { + CARD8 reqType; + BYTE alloc; + CARD16 length B16; + Colormap mid B32; + Window window B32; + VisualID visual B32; +} xCreateColormapReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Colormap mid B32; + Colormap srcCmap B32; +} xCopyColormapAndFreeReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Colormap cmap B32; + CARD16 red B16, green B16, blue B16; + CARD16 pad2 B16; +} xAllocColorReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Colormap cmap B32; + CARD16 nbytes B16; /* followed by structure */ + BYTE pad1, pad2; +} xAllocNamedColorReq; + +typedef struct { + CARD8 reqType; + BOOL contiguous; + CARD16 length B16; + Colormap cmap B32; + CARD16 colors B16, planes B16; +} xAllocColorCellsReq; + +typedef struct { + CARD8 reqType; + BOOL contiguous; + CARD16 length B16; + Colormap cmap B32; + CARD16 colors B16, red B16, green B16, blue B16; +} xAllocColorPlanesReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Colormap cmap B32; + CARD32 planeMask B32; +} xFreeColorsReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Colormap cmap B32; +} xStoreColorsReq; + +typedef struct { + CARD8 reqType; + CARD8 flags; /* DoRed, DoGreen, DoBlue, as in xColorItem */ + CARD16 length B16; + Colormap cmap B32; + CARD32 pixel B32; + CARD16 nbytes B16; /* number of name string bytes following structure */ + BYTE pad1, pad2; + } xStoreNamedColorReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Colormap cmap B32; +} xQueryColorsReq; + +typedef struct { /* followed by string of length len */ + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Colormap cmap B32; + CARD16 nbytes B16; /* number of string bytes following structure*/ + BYTE pad1, pad2; +} xLookupColorReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Cursor cid B32; + Pixmap source B32, mask B32; + CARD16 foreRed B16, foreGreen B16, foreBlue B16; + CARD16 backRed B16, backGreen B16, backBlue B16; + CARD16 x B16, y B16; +} xCreateCursorReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Cursor cid B32; + Font source B32, mask B32; + CARD16 sourceChar B16, maskChar B16; + CARD16 foreRed B16, foreGreen B16, foreBlue B16; + CARD16 backRed B16, backGreen B16, backBlue B16; +} xCreateGlyphCursorReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Cursor cursor B32; + CARD16 foreRed B16, foreGreen B16, foreBlue B16; + CARD16 backRed B16, backGreen B16, backBlue B16; +} xRecolorCursorReq; + +typedef struct { + CARD8 reqType; +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD16 length B16; + Drawable drawable B32; + CARD16 width B16, height B16; +} xQueryBestSizeReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + CARD16 nbytes B16; /* number of string bytes following structure */ + BYTE pad1, pad2; +} xQueryExtensionReq; + +typedef struct { + CARD8 reqType; + CARD8 numKeyPerModifier; + CARD16 length B16; +} xSetModifierMappingReq; + +typedef struct { + CARD8 reqType; + CARD8 nElts; /* how many elements in the map */ + CARD16 length B16; +} xSetPointerMappingReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + KeyCode firstKeyCode; + CARD8 count; + CARD16 pad1 B16; +} xGetKeyboardMappingReq; + +typedef struct { + CARD8 reqType; + CARD8 keyCodes; + CARD16 length B16; + KeyCode firstKeyCode; + CARD8 keySymsPerKeyCode; + CARD16 pad1 B16; +} xChangeKeyboardMappingReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + CARD32 mask B32; +} xChangeKeyboardControlReq; + +typedef struct { + CARD8 reqType; + INT8 percent; /* -100 to 100 */ + CARD16 length B16; +} xBellReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + INT16 accelNum B16, accelDenum B16; + INT16 threshold B16; + BOOL doAccel, doThresh; +} xChangePointerControlReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + INT16 timeout B16, interval B16; + BYTE preferBlank, allowExpose; + CARD16 pad2 B16; +} xSetScreenSaverReq; + +typedef struct { + CARD8 reqType; + BYTE mode; + CARD16 length B16; + CARD8 hostFamily; + BYTE pad; + CARD16 hostLength B16; +} xChangeHostsReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length B16; + } xListHostsReq; + +typedef struct { + CARD8 reqType; + BYTE mode; + CARD16 length B16; + } xChangeModeReq; + +typedef xChangeModeReq xSetAccessControlReq; +typedef xChangeModeReq xSetCloseDownModeReq; +typedef xChangeModeReq xForceScreenSaverReq; + +typedef struct { /* followed by LIST of ATOM */ + CARD8 reqType; + BYTE pad; + CARD16 length B16; + Window window B32; + CARD16 nAtoms B16; + INT16 nPositions B16; + } xRotatePropertiesReq; + + + +/* Reply codes */ + +#define X_Reply 1 /* Normal reply */ +#define X_Error 0 /* Error */ + +/* Request codes */ + +#define X_CreateWindow 1 +#define X_ChangeWindowAttributes 2 +#define X_GetWindowAttributes 3 +#define X_DestroyWindow 4 +#define X_DestroySubwindows 5 +#define X_ChangeSaveSet 6 +#define X_ReparentWindow 7 +#define X_MapWindow 8 +#define X_MapSubwindows 9 +#define X_UnmapWindow 10 +#define X_UnmapSubwindows 11 +#define X_ConfigureWindow 12 +#define X_CirculateWindow 13 +#define X_GetGeometry 14 +#define X_QueryTree 15 +#define X_InternAtom 16 +#define X_GetAtomName 17 +#define X_ChangeProperty 18 +#define X_DeleteProperty 19 +#define X_GetProperty 20 +#define X_ListProperties 21 +#define X_SetSelectionOwner 22 +#define X_GetSelectionOwner 23 +#define X_ConvertSelection 24 +#define X_SendEvent 25 +#define X_GrabPointer 26 +#define X_UngrabPointer 27 +#define X_GrabButton 28 +#define X_UngrabButton 29 +#define X_ChangeActivePointerGrab 30 +#define X_GrabKeyboard 31 +#define X_UngrabKeyboard 32 +#define X_GrabKey 33 +#define X_UngrabKey 34 +#define X_AllowEvents 35 +#define X_GrabServer 36 +#define X_UngrabServer 37 +#define X_QueryPointer 38 +#define X_GetMotionEvents 39 +#define X_TranslateCoords 40 +#define X_WarpPointer 41 +#define X_SetInputFocus 42 +#define X_GetInputFocus 43 +#define X_QueryKeymap 44 +#define X_OpenFont 45 +#define X_CloseFont 46 +#define X_QueryFont 47 +#define X_QueryTextExtents 48 +#define X_ListFonts 49 +#define X_ListFontsWithInfo 50 +#define X_SetFontPath 51 +#define X_GetFontPath 52 +#define X_CreatePixmap 53 +#define X_FreePixmap 54 +#define X_CreateGC 55 +#define X_ChangeGC 56 +#define X_CopyGC 57 +#define X_SetDashes 58 +#define X_SetClipRectangles 59 +#define X_FreeGC 60 +#define X_ClearArea 61 +#define X_CopyArea 62 +#define X_CopyPlane 63 +#define X_PolyPoint 64 +#define X_PolyLine 65 +#define X_PolySegment 66 +#define X_PolyRectangle 67 +#define X_PolyArc 68 +#define X_FillPoly 69 +#define X_PolyFillRectangle 70 +#define X_PolyFillArc 71 +#define X_PutImage 72 +#define X_GetImage 73 +#define X_PolyText8 74 +#define X_PolyText16 75 +#define X_ImageText8 76 +#define X_ImageText16 77 +#define X_CreateColormap 78 +#define X_FreeColormap 79 +#define X_CopyColormapAndFree 80 +#define X_InstallColormap 81 +#define X_UninstallColormap 82 +#define X_ListInstalledColormaps 83 +#define X_AllocColor 84 +#define X_AllocNamedColor 85 +#define X_AllocColorCells 86 +#define X_AllocColorPlanes 87 +#define X_FreeColors 88 +#define X_StoreColors 89 +#define X_StoreNamedColor 90 +#define X_QueryColors 91 +#define X_LookupColor 92 +#define X_CreateCursor 93 +#define X_CreateGlyphCursor 94 +#define X_FreeCursor 95 +#define X_RecolorCursor 96 +#define X_QueryBestSize 97 +#define X_QueryExtension 98 +#define X_ListExtensions 99 +#define X_ChangeKeyboardMapping 100 +#define X_GetKeyboardMapping 101 +#define X_ChangeKeyboardControl 102 +#define X_GetKeyboardControl 103 +#define X_Bell 104 +#define X_ChangePointerControl 105 +#define X_GetPointerControl 106 +#define X_SetScreenSaver 107 +#define X_GetScreenSaver 108 +#define X_ChangeHosts 109 +#define X_ListHosts 110 +#define X_SetAccessControl 111 +#define X_SetCloseDownMode 112 +#define X_KillClient 113 +#define X_RotateProperties 114 +#define X_ForceScreenSaver 115 +#define X_SetPointerMapping 116 +#define X_GetPointerMapping 117 +#define X_SetModifierMapping 118 +#define X_GetModifierMapping 119 +#define X_NoOperation 127 + +/* restore these definitions back to the typedefs in X.h */ +#undef Window +#undef Drawable +#undef Font +#undef Pixmap +#undef Cursor +#undef Colormap +#undef GContext +#undef Atom +#undef VisualID +#undef Time +#undef KeyCode +#undef KeySym + +#endif /* XPROTO_H */ diff --git a/engine/qux/Xprotostr.h b/engine/qux/Xprotostr.h new file mode 100644 index 000000000..f408d4bb4 --- /dev/null +++ b/engine/qux/Xprotostr.h @@ -0,0 +1,80 @@ +//the only changes in this file for qux support are with header file locations. + +/* $Xorg: Xprotostr.h,v 1.4 2001/02/09 02:03:23 xorgcvs Exp $ */ +#ifndef XPROTOSTRUCTS_H +#define XPROTOSTRUCTS_H + +/*********************************************************** + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ +#include "Xmd.h" + +/* Used by PolySegment */ + +typedef struct _xSegment { + INT16 x1 B16, y1 B16, x2 B16, y2 B16; +} xSegment; + +/* POINT */ + +typedef struct _xPoint { + INT16 x B16, y B16; +} xPoint; + +typedef struct _xRectangle { + INT16 x B16, y B16; + CARD16 width B16, height B16; +} xRectangle; + +/* ARC */ + +typedef struct _xArc { + INT16 x B16, y B16; + CARD16 width B16, height B16; + INT16 angle1 B16, angle2 B16; +} xArc; + +#endif /* XPROTOSTRUCTS_H */ diff --git a/engine/qux/bigreqstr.h b/engine/qux/bigreqstr.h new file mode 100644 index 000000000..ab098825e --- /dev/null +++ b/engine/qux/bigreqstr.h @@ -0,0 +1,63 @@ +/* $Xorg: bigreqstr.h,v 1.4 2001/02/09 02:03:24 xorgcvs Exp $ */ +/* + +Copyright 1992, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +#define X_BigReqEnable 0 + +#define XBigReqNumberEvents 0 + +#define XBigReqNumberErrors 0 + +#define XBigReqExtensionName "BIG-REQUESTS" + +typedef struct { + CARD8 reqType; /* always XBigReqCode */ + CARD8 brReqType; /* always X_BigReqEnable */ + CARD16 length B16; +} xBigReqEnableReq; +#define sz_xBigReqEnableReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 max_request_size B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; +} xBigReqEnableReply; +#define sz_xBigReqEnableReply 32 + + +typedef struct { + CARD8 reqType; + CARD8 data; + CARD16 zero B16; + CARD32 length B32; +} xBigReq; diff --git a/engine/qux/keysymdef.h b/engine/qux/keysymdef.h new file mode 100644 index 000000000..728a412ea --- /dev/null +++ b/engine/qux/keysymdef.h @@ -0,0 +1,2016 @@ +/* $Xorg: keysymdef.h,v 1.4 2001/02/09 02:03:23 xorgcvs Exp $ */ + +/*********************************************************** +Copyright 1987, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ +/* $XFree86: xc/include/keysymdef.h,v 1.12 2001/12/14 19:53:26 dawes Exp $ */ + +#define XK_VoidSymbol 0xFFFFFF /* void symbol */ + +#ifdef XK_MISCELLANY +/* + * TTY Functions, cleverly chosen to map to ascii, for convenience of + * programming, but could have been arbitrary (at the cost of lookup + * tables in client code. + */ + +#define XK_BackSpace 0xFF08 /* back space, back char */ +#define XK_Tab 0xFF09 +#define XK_Linefeed 0xFF0A /* Linefeed, LF */ +#define XK_Clear 0xFF0B +#define XK_Return 0xFF0D /* Return, enter */ +#define XK_Pause 0xFF13 /* Pause, hold */ +#define XK_Scroll_Lock 0xFF14 +#define XK_Sys_Req 0xFF15 +#define XK_Escape 0xFF1B +#define XK_Delete 0xFFFF /* Delete, rubout */ + + + +/* International & multi-key character composition */ + +#define XK_Multi_key 0xFF20 /* Multi-key character compose */ +#define XK_Codeinput 0xFF37 +#define XK_SingleCandidate 0xFF3C +#define XK_MultipleCandidate 0xFF3D +#define XK_PreviousCandidate 0xFF3E + +/* Japanese keyboard support */ + +#define XK_Kanji 0xFF21 /* Kanji, Kanji convert */ +#define XK_Muhenkan 0xFF22 /* Cancel Conversion */ +#define XK_Henkan_Mode 0xFF23 /* Start/Stop Conversion */ +#define XK_Henkan 0xFF23 /* Alias for Henkan_Mode */ +#define XK_Romaji 0xFF24 /* to Romaji */ +#define XK_Hiragana 0xFF25 /* to Hiragana */ +#define XK_Katakana 0xFF26 /* to Katakana */ +#define XK_Hiragana_Katakana 0xFF27 /* Hiragana/Katakana toggle */ +#define XK_Zenkaku 0xFF28 /* to Zenkaku */ +#define XK_Hankaku 0xFF29 /* to Hankaku */ +#define XK_Zenkaku_Hankaku 0xFF2A /* Zenkaku/Hankaku toggle */ +#define XK_Touroku 0xFF2B /* Add to Dictionary */ +#define XK_Massyo 0xFF2C /* Delete from Dictionary */ +#define XK_Kana_Lock 0xFF2D /* Kana Lock */ +#define XK_Kana_Shift 0xFF2E /* Kana Shift */ +#define XK_Eisu_Shift 0xFF2F /* Alphanumeric Shift */ +#define XK_Eisu_toggle 0xFF30 /* Alphanumeric toggle */ +#define XK_Kanji_Bangou 0xFF37 /* Codeinput */ +#define XK_Zen_Koho 0xFF3D /* Multiple/All Candidate(s) */ +#define XK_Mae_Koho 0xFF3E /* Previous Candidate */ + +/* 0xFF31 thru 0xFF3F are under XK_KOREAN */ + +/* Cursor control & motion */ + +#define XK_Home 0xFF50 +#define XK_Left 0xFF51 /* Move left, left arrow */ +#define XK_Up 0xFF52 /* Move up, up arrow */ +#define XK_Right 0xFF53 /* Move right, right arrow */ +#define XK_Down 0xFF54 /* Move down, down arrow */ +#define XK_Prior 0xFF55 /* Prior, previous */ +#define XK_Page_Up 0xFF55 +#define XK_Next 0xFF56 /* Next */ +#define XK_Page_Down 0xFF56 +#define XK_End 0xFF57 /* EOL */ +#define XK_Begin 0xFF58 /* BOL */ + + +/* Misc Functions */ + +#define XK_Select 0xFF60 /* Select, mark */ +#define XK_Print 0xFF61 +#define XK_Execute 0xFF62 /* Execute, run, do */ +#define XK_Insert 0xFF63 /* Insert, insert here */ +#define XK_Undo 0xFF65 /* Undo, oops */ +#define XK_Redo 0xFF66 /* redo, again */ +#define XK_Menu 0xFF67 +#define XK_Find 0xFF68 /* Find, search */ +#define XK_Cancel 0xFF69 /* Cancel, stop, abort, exit */ +#define XK_Help 0xFF6A /* Help */ +#define XK_Break 0xFF6B +#define XK_Mode_switch 0xFF7E /* Character set switch */ +#define XK_script_switch 0xFF7E /* Alias for mode_switch */ +#define XK_Num_Lock 0xFF7F + +/* Keypad Functions, keypad numbers cleverly chosen to map to ascii */ + +#define XK_KP_Space 0xFF80 /* space */ +#define XK_KP_Tab 0xFF89 +#define XK_KP_Enter 0xFF8D /* enter */ +#define XK_KP_F1 0xFF91 /* PF1, KP_A, ... */ +#define XK_KP_F2 0xFF92 +#define XK_KP_F3 0xFF93 +#define XK_KP_F4 0xFF94 +#define XK_KP_Home 0xFF95 +#define XK_KP_Left 0xFF96 +#define XK_KP_Up 0xFF97 +#define XK_KP_Right 0xFF98 +#define XK_KP_Down 0xFF99 +#define XK_KP_Prior 0xFF9A +#define XK_KP_Page_Up 0xFF9A +#define XK_KP_Next 0xFF9B +#define XK_KP_Page_Down 0xFF9B +#define XK_KP_End 0xFF9C +#define XK_KP_Begin 0xFF9D +#define XK_KP_Insert 0xFF9E +#define XK_KP_Delete 0xFF9F +#define XK_KP_Equal 0xFFBD /* equals */ +#define XK_KP_Multiply 0xFFAA +#define XK_KP_Add 0xFFAB +#define XK_KP_Separator 0xFFAC /* separator, often comma */ +#define XK_KP_Subtract 0xFFAD +#define XK_KP_Decimal 0xFFAE +#define XK_KP_Divide 0xFFAF + +#define XK_KP_0 0xFFB0 +#define XK_KP_1 0xFFB1 +#define XK_KP_2 0xFFB2 +#define XK_KP_3 0xFFB3 +#define XK_KP_4 0xFFB4 +#define XK_KP_5 0xFFB5 +#define XK_KP_6 0xFFB6 +#define XK_KP_7 0xFFB7 +#define XK_KP_8 0xFFB8 +#define XK_KP_9 0xFFB9 + + + +/* + * Auxilliary Functions; note the duplicate definitions for left and right + * function keys; Sun keyboards and a few other manufactures have such + * function key groups on the left and/or right sides of the keyboard. + * We've not found a keyboard with more than 35 function keys total. + */ + +#define XK_F1 0xFFBE +#define XK_F2 0xFFBF +#define XK_F3 0xFFC0 +#define XK_F4 0xFFC1 +#define XK_F5 0xFFC2 +#define XK_F6 0xFFC3 +#define XK_F7 0xFFC4 +#define XK_F8 0xFFC5 +#define XK_F9 0xFFC6 +#define XK_F10 0xFFC7 +#define XK_F11 0xFFC8 +#define XK_L1 0xFFC8 +#define XK_F12 0xFFC9 +#define XK_L2 0xFFC9 +#define XK_F13 0xFFCA +#define XK_L3 0xFFCA +#define XK_F14 0xFFCB +#define XK_L4 0xFFCB +#define XK_F15 0xFFCC +#define XK_L5 0xFFCC +#define XK_F16 0xFFCD +#define XK_L6 0xFFCD +#define XK_F17 0xFFCE +#define XK_L7 0xFFCE +#define XK_F18 0xFFCF +#define XK_L8 0xFFCF +#define XK_F19 0xFFD0 +#define XK_L9 0xFFD0 +#define XK_F20 0xFFD1 +#define XK_L10 0xFFD1 +#define XK_F21 0xFFD2 +#define XK_R1 0xFFD2 +#define XK_F22 0xFFD3 +#define XK_R2 0xFFD3 +#define XK_F23 0xFFD4 +#define XK_R3 0xFFD4 +#define XK_F24 0xFFD5 +#define XK_R4 0xFFD5 +#define XK_F25 0xFFD6 +#define XK_R5 0xFFD6 +#define XK_F26 0xFFD7 +#define XK_R6 0xFFD7 +#define XK_F27 0xFFD8 +#define XK_R7 0xFFD8 +#define XK_F28 0xFFD9 +#define XK_R8 0xFFD9 +#define XK_F29 0xFFDA +#define XK_R9 0xFFDA +#define XK_F30 0xFFDB +#define XK_R10 0xFFDB +#define XK_F31 0xFFDC +#define XK_R11 0xFFDC +#define XK_F32 0xFFDD +#define XK_R12 0xFFDD +#define XK_F33 0xFFDE +#define XK_R13 0xFFDE +#define XK_F34 0xFFDF +#define XK_R14 0xFFDF +#define XK_F35 0xFFE0 +#define XK_R15 0xFFE0 + +/* Modifiers */ + +#define XK_Shift_L 0xFFE1 /* Left shift */ +#define XK_Shift_R 0xFFE2 /* Right shift */ +#define XK_Control_L 0xFFE3 /* Left control */ +#define XK_Control_R 0xFFE4 /* Right control */ +#define XK_Caps_Lock 0xFFE5 /* Caps lock */ +#define XK_Shift_Lock 0xFFE6 /* Shift lock */ + +#define XK_Meta_L 0xFFE7 /* Left meta */ +#define XK_Meta_R 0xFFE8 /* Right meta */ +#define XK_Alt_L 0xFFE9 /* Left alt */ +#define XK_Alt_R 0xFFEA /* Right alt */ +#define XK_Super_L 0xFFEB /* Left super */ +#define XK_Super_R 0xFFEC /* Right super */ +#define XK_Hyper_L 0xFFED /* Left hyper */ +#define XK_Hyper_R 0xFFEE /* Right hyper */ +#endif /* XK_MISCELLANY */ + +/* + * ISO 9995 Function and Modifier Keys + * Byte 3 = 0xFE + */ + +#ifdef XK_XKB_KEYS +#define XK_ISO_Lock 0xFE01 +#define XK_ISO_Level2_Latch 0xFE02 +#define XK_ISO_Level3_Shift 0xFE03 +#define XK_ISO_Level3_Latch 0xFE04 +#define XK_ISO_Level3_Lock 0xFE05 +#define XK_ISO_Group_Shift 0xFF7E /* Alias for mode_switch */ +#define XK_ISO_Group_Latch 0xFE06 +#define XK_ISO_Group_Lock 0xFE07 +#define XK_ISO_Next_Group 0xFE08 +#define XK_ISO_Next_Group_Lock 0xFE09 +#define XK_ISO_Prev_Group 0xFE0A +#define XK_ISO_Prev_Group_Lock 0xFE0B +#define XK_ISO_First_Group 0xFE0C +#define XK_ISO_First_Group_Lock 0xFE0D +#define XK_ISO_Last_Group 0xFE0E +#define XK_ISO_Last_Group_Lock 0xFE0F + +#define XK_ISO_Left_Tab 0xFE20 +#define XK_ISO_Move_Line_Up 0xFE21 +#define XK_ISO_Move_Line_Down 0xFE22 +#define XK_ISO_Partial_Line_Up 0xFE23 +#define XK_ISO_Partial_Line_Down 0xFE24 +#define XK_ISO_Partial_Space_Left 0xFE25 +#define XK_ISO_Partial_Space_Right 0xFE26 +#define XK_ISO_Set_Margin_Left 0xFE27 +#define XK_ISO_Set_Margin_Right 0xFE28 +#define XK_ISO_Release_Margin_Left 0xFE29 +#define XK_ISO_Release_Margin_Right 0xFE2A +#define XK_ISO_Release_Both_Margins 0xFE2B +#define XK_ISO_Fast_Cursor_Left 0xFE2C +#define XK_ISO_Fast_Cursor_Right 0xFE2D +#define XK_ISO_Fast_Cursor_Up 0xFE2E +#define XK_ISO_Fast_Cursor_Down 0xFE2F +#define XK_ISO_Continuous_Underline 0xFE30 +#define XK_ISO_Discontinuous_Underline 0xFE31 +#define XK_ISO_Emphasize 0xFE32 +#define XK_ISO_Center_Object 0xFE33 +#define XK_ISO_Enter 0xFE34 + +#define XK_dead_grave 0xFE50 +#define XK_dead_acute 0xFE51 +#define XK_dead_circumflex 0xFE52 +#define XK_dead_tilde 0xFE53 +#define XK_dead_macron 0xFE54 +#define XK_dead_breve 0xFE55 +#define XK_dead_abovedot 0xFE56 +#define XK_dead_diaeresis 0xFE57 +#define XK_dead_abovering 0xFE58 +#define XK_dead_doubleacute 0xFE59 +#define XK_dead_caron 0xFE5A +#define XK_dead_cedilla 0xFE5B +#define XK_dead_ogonek 0xFE5C +#define XK_dead_iota 0xFE5D +#define XK_dead_voiced_sound 0xFE5E +#define XK_dead_semivoiced_sound 0xFE5F +#define XK_dead_belowdot 0xFE60 +#define XK_dead_hook 0xFE61 +#define XK_dead_horn 0xFE62 + +#define XK_First_Virtual_Screen 0xFED0 +#define XK_Prev_Virtual_Screen 0xFED1 +#define XK_Next_Virtual_Screen 0xFED2 +#define XK_Last_Virtual_Screen 0xFED4 +#define XK_Terminate_Server 0xFED5 + +#define XK_AccessX_Enable 0xFE70 +#define XK_AccessX_Feedback_Enable 0xFE71 +#define XK_RepeatKeys_Enable 0xFE72 +#define XK_SlowKeys_Enable 0xFE73 +#define XK_BounceKeys_Enable 0xFE74 +#define XK_StickyKeys_Enable 0xFE75 +#define XK_MouseKeys_Enable 0xFE76 +#define XK_MouseKeys_Accel_Enable 0xFE77 +#define XK_Overlay1_Enable 0xFE78 +#define XK_Overlay2_Enable 0xFE79 +#define XK_AudibleBell_Enable 0xFE7A + +#define XK_Pointer_Left 0xFEE0 +#define XK_Pointer_Right 0xFEE1 +#define XK_Pointer_Up 0xFEE2 +#define XK_Pointer_Down 0xFEE3 +#define XK_Pointer_UpLeft 0xFEE4 +#define XK_Pointer_UpRight 0xFEE5 +#define XK_Pointer_DownLeft 0xFEE6 +#define XK_Pointer_DownRight 0xFEE7 +#define XK_Pointer_Button_Dflt 0xFEE8 +#define XK_Pointer_Button1 0xFEE9 +#define XK_Pointer_Button2 0xFEEA +#define XK_Pointer_Button3 0xFEEB +#define XK_Pointer_Button4 0xFEEC +#define XK_Pointer_Button5 0xFEED +#define XK_Pointer_DblClick_Dflt 0xFEEE +#define XK_Pointer_DblClick1 0xFEEF +#define XK_Pointer_DblClick2 0xFEF0 +#define XK_Pointer_DblClick3 0xFEF1 +#define XK_Pointer_DblClick4 0xFEF2 +#define XK_Pointer_DblClick5 0xFEF3 +#define XK_Pointer_Drag_Dflt 0xFEF4 +#define XK_Pointer_Drag1 0xFEF5 +#define XK_Pointer_Drag2 0xFEF6 +#define XK_Pointer_Drag3 0xFEF7 +#define XK_Pointer_Drag4 0xFEF8 +#define XK_Pointer_Drag5 0xFEFD + +#define XK_Pointer_EnableKeys 0xFEF9 +#define XK_Pointer_Accelerate 0xFEFA +#define XK_Pointer_DfltBtnNext 0xFEFB +#define XK_Pointer_DfltBtnPrev 0xFEFC + +#endif + +/* + * 3270 Terminal Keys + * Byte 3 = 0xFD + */ + +#ifdef XK_3270 +#define XK_3270_Duplicate 0xFD01 +#define XK_3270_FieldMark 0xFD02 +#define XK_3270_Right2 0xFD03 +#define XK_3270_Left2 0xFD04 +#define XK_3270_BackTab 0xFD05 +#define XK_3270_EraseEOF 0xFD06 +#define XK_3270_EraseInput 0xFD07 +#define XK_3270_Reset 0xFD08 +#define XK_3270_Quit 0xFD09 +#define XK_3270_PA1 0xFD0A +#define XK_3270_PA2 0xFD0B +#define XK_3270_PA3 0xFD0C +#define XK_3270_Test 0xFD0D +#define XK_3270_Attn 0xFD0E +#define XK_3270_CursorBlink 0xFD0F +#define XK_3270_AltCursor 0xFD10 +#define XK_3270_KeyClick 0xFD11 +#define XK_3270_Jump 0xFD12 +#define XK_3270_Ident 0xFD13 +#define XK_3270_Rule 0xFD14 +#define XK_3270_Copy 0xFD15 +#define XK_3270_Play 0xFD16 +#define XK_3270_Setup 0xFD17 +#define XK_3270_Record 0xFD18 +#define XK_3270_ChangeScreen 0xFD19 +#define XK_3270_DeleteWord 0xFD1A +#define XK_3270_ExSelect 0xFD1B +#define XK_3270_CursorSelect 0xFD1C +#define XK_3270_PrintScreen 0xFD1D +#define XK_3270_Enter 0xFD1E +#endif + +/* + * Latin 1 + * Byte 3 = 0 + */ +#ifdef XK_LATIN1 +#define XK_space 0x020 +#define XK_exclam 0x021 +#define XK_quotedbl 0x022 +#define XK_numbersign 0x023 +#define XK_dollar 0x024 +#define XK_percent 0x025 +#define XK_ampersand 0x026 +#define XK_apostrophe 0x027 +#define XK_quoteright 0x027 /* deprecated */ +#define XK_parenleft 0x028 +#define XK_parenright 0x029 +#define XK_asterisk 0x02a +#define XK_plus 0x02b +#define XK_comma 0x02c +#define XK_minus 0x02d +#define XK_period 0x02e +#define XK_slash 0x02f +#define XK_0 0x030 +#define XK_1 0x031 +#define XK_2 0x032 +#define XK_3 0x033 +#define XK_4 0x034 +#define XK_5 0x035 +#define XK_6 0x036 +#define XK_7 0x037 +#define XK_8 0x038 +#define XK_9 0x039 +#define XK_colon 0x03a +#define XK_semicolon 0x03b +#define XK_less 0x03c +#define XK_equal 0x03d +#define XK_greater 0x03e +#define XK_question 0x03f +#define XK_at 0x040 +#define XK_A 0x041 +#define XK_B 0x042 +#define XK_C 0x043 +#define XK_D 0x044 +#define XK_E 0x045 +#define XK_F 0x046 +#define XK_G 0x047 +#define XK_H 0x048 +#define XK_I 0x049 +#define XK_J 0x04a +#define XK_K 0x04b +#define XK_L 0x04c +#define XK_M 0x04d +#define XK_N 0x04e +#define XK_O 0x04f +#define XK_P 0x050 +#define XK_Q 0x051 +#define XK_R 0x052 +#define XK_S 0x053 +#define XK_T 0x054 +#define XK_U 0x055 +#define XK_V 0x056 +#define XK_W 0x057 +#define XK_X 0x058 +#define XK_Y 0x059 +#define XK_Z 0x05a +#define XK_bracketleft 0x05b +#define XK_backslash 0x05c +#define XK_bracketright 0x05d +#define XK_asciicircum 0x05e +#define XK_underscore 0x05f +#define XK_grave 0x060 +#define XK_quoteleft 0x060 /* deprecated */ +#define XK_a 0x061 +#define XK_b 0x062 +#define XK_c 0x063 +#define XK_d 0x064 +#define XK_e 0x065 +#define XK_f 0x066 +#define XK_g 0x067 +#define XK_h 0x068 +#define XK_i 0x069 +#define XK_j 0x06a +#define XK_k 0x06b +#define XK_l 0x06c +#define XK_m 0x06d +#define XK_n 0x06e +#define XK_o 0x06f +#define XK_p 0x070 +#define XK_q 0x071 +#define XK_r 0x072 +#define XK_s 0x073 +#define XK_t 0x074 +#define XK_u 0x075 +#define XK_v 0x076 +#define XK_w 0x077 +#define XK_x 0x078 +#define XK_y 0x079 +#define XK_z 0x07a +#define XK_braceleft 0x07b +#define XK_bar 0x07c +#define XK_braceright 0x07d +#define XK_asciitilde 0x07e + +#define XK_nobreakspace 0x0a0 +#define XK_exclamdown 0x0a1 +#define XK_cent 0x0a2 +#define XK_sterling 0x0a3 +#define XK_currency 0x0a4 +#define XK_yen 0x0a5 +#define XK_brokenbar 0x0a6 +#define XK_section 0x0a7 +#define XK_diaeresis 0x0a8 +#define XK_copyright 0x0a9 +#define XK_ordfeminine 0x0aa +#define XK_guillemotleft 0x0ab /* left angle quotation mark */ +#define XK_notsign 0x0ac +#define XK_hyphen 0x0ad +#define XK_registered 0x0ae +#define XK_macron 0x0af +#define XK_degree 0x0b0 +#define XK_plusminus 0x0b1 +#define XK_twosuperior 0x0b2 +#define XK_threesuperior 0x0b3 +#define XK_acute 0x0b4 +#define XK_mu 0x0b5 +#define XK_paragraph 0x0b6 +#define XK_periodcentered 0x0b7 +#define XK_cedilla 0x0b8 +#define XK_onesuperior 0x0b9 +#define XK_masculine 0x0ba +#define XK_guillemotright 0x0bb /* right angle quotation mark */ +#define XK_onequarter 0x0bc +#define XK_onehalf 0x0bd +#define XK_threequarters 0x0be +#define XK_questiondown 0x0bf +#define XK_Agrave 0x0c0 +#define XK_Aacute 0x0c1 +#define XK_Acircumflex 0x0c2 +#define XK_Atilde 0x0c3 +#define XK_Adiaeresis 0x0c4 +#define XK_Aring 0x0c5 +#define XK_AE 0x0c6 +#define XK_Ccedilla 0x0c7 +#define XK_Egrave 0x0c8 +#define XK_Eacute 0x0c9 +#define XK_Ecircumflex 0x0ca +#define XK_Ediaeresis 0x0cb +#define XK_Igrave 0x0cc +#define XK_Iacute 0x0cd +#define XK_Icircumflex 0x0ce +#define XK_Idiaeresis 0x0cf +#define XK_ETH 0x0d0 +#define XK_Eth 0x0d0 /* deprecated */ +#define XK_Ntilde 0x0d1 +#define XK_Ograve 0x0d2 +#define XK_Oacute 0x0d3 +#define XK_Ocircumflex 0x0d4 +#define XK_Otilde 0x0d5 +#define XK_Odiaeresis 0x0d6 +#define XK_multiply 0x0d7 +#define XK_Ooblique 0x0d8 +#define XK_Oslash XK_Ooblique +#define XK_Ugrave 0x0d9 +#define XK_Uacute 0x0da +#define XK_Ucircumflex 0x0db +#define XK_Udiaeresis 0x0dc +#define XK_Yacute 0x0dd +#define XK_THORN 0x0de +#define XK_Thorn 0x0de /* deprecated */ +#define XK_ssharp 0x0df +#define XK_agrave 0x0e0 +#define XK_aacute 0x0e1 +#define XK_acircumflex 0x0e2 +#define XK_atilde 0x0e3 +#define XK_adiaeresis 0x0e4 +#define XK_aring 0x0e5 +#define XK_ae 0x0e6 +#define XK_ccedilla 0x0e7 +#define XK_egrave 0x0e8 +#define XK_eacute 0x0e9 +#define XK_ecircumflex 0x0ea +#define XK_ediaeresis 0x0eb +#define XK_igrave 0x0ec +#define XK_iacute 0x0ed +#define XK_icircumflex 0x0ee +#define XK_idiaeresis 0x0ef +#define XK_eth 0x0f0 +#define XK_ntilde 0x0f1 +#define XK_ograve 0x0f2 +#define XK_oacute 0x0f3 +#define XK_ocircumflex 0x0f4 +#define XK_otilde 0x0f5 +#define XK_odiaeresis 0x0f6 +#define XK_division 0x0f7 +#define XK_oslash 0x0f8 +#define XK_ooblique XK_oslash +#define XK_ugrave 0x0f9 +#define XK_uacute 0x0fa +#define XK_ucircumflex 0x0fb +#define XK_udiaeresis 0x0fc +#define XK_yacute 0x0fd +#define XK_thorn 0x0fe +#define XK_ydiaeresis 0x0ff +#endif /* XK_LATIN1 */ + +/* + * Latin 2 + * Byte 3 = 1 + */ + +#ifdef XK_LATIN2 +#define XK_Aogonek 0x1a1 +#define XK_breve 0x1a2 +#define XK_Lstroke 0x1a3 +#define XK_Lcaron 0x1a5 +#define XK_Sacute 0x1a6 +#define XK_Scaron 0x1a9 +#define XK_Scedilla 0x1aa +#define XK_Tcaron 0x1ab +#define XK_Zacute 0x1ac +#define XK_Zcaron 0x1ae +#define XK_Zabovedot 0x1af +#define XK_aogonek 0x1b1 +#define XK_ogonek 0x1b2 +#define XK_lstroke 0x1b3 +#define XK_lcaron 0x1b5 +#define XK_sacute 0x1b6 +#define XK_caron 0x1b7 +#define XK_scaron 0x1b9 +#define XK_scedilla 0x1ba +#define XK_tcaron 0x1bb +#define XK_zacute 0x1bc +#define XK_doubleacute 0x1bd +#define XK_zcaron 0x1be +#define XK_zabovedot 0x1bf +#define XK_Racute 0x1c0 +#define XK_Abreve 0x1c3 +#define XK_Lacute 0x1c5 +#define XK_Cacute 0x1c6 +#define XK_Ccaron 0x1c8 +#define XK_Eogonek 0x1ca +#define XK_Ecaron 0x1cc +#define XK_Dcaron 0x1cf +#define XK_Dstroke 0x1d0 +#define XK_Nacute 0x1d1 +#define XK_Ncaron 0x1d2 +#define XK_Odoubleacute 0x1d5 +#define XK_Rcaron 0x1d8 +#define XK_Uring 0x1d9 +#define XK_Udoubleacute 0x1db +#define XK_Tcedilla 0x1de +#define XK_racute 0x1e0 +#define XK_abreve 0x1e3 +#define XK_lacute 0x1e5 +#define XK_cacute 0x1e6 +#define XK_ccaron 0x1e8 +#define XK_eogonek 0x1ea +#define XK_ecaron 0x1ec +#define XK_dcaron 0x1ef +#define XK_dstroke 0x1f0 +#define XK_nacute 0x1f1 +#define XK_ncaron 0x1f2 +#define XK_odoubleacute 0x1f5 +#define XK_udoubleacute 0x1fb +#define XK_rcaron 0x1f8 +#define XK_uring 0x1f9 +#define XK_tcedilla 0x1fe +#define XK_abovedot 0x1ff +#endif /* XK_LATIN2 */ + +/* + * Latin 3 + * Byte 3 = 2 + */ + +#ifdef XK_LATIN3 +#define XK_Hstroke 0x2a1 +#define XK_Hcircumflex 0x2a6 +#define XK_Iabovedot 0x2a9 +#define XK_Gbreve 0x2ab +#define XK_Jcircumflex 0x2ac +#define XK_hstroke 0x2b1 +#define XK_hcircumflex 0x2b6 +#define XK_idotless 0x2b9 +#define XK_gbreve 0x2bb +#define XK_jcircumflex 0x2bc +#define XK_Cabovedot 0x2c5 +#define XK_Ccircumflex 0x2c6 +#define XK_Gabovedot 0x2d5 +#define XK_Gcircumflex 0x2d8 +#define XK_Ubreve 0x2dd +#define XK_Scircumflex 0x2de +#define XK_cabovedot 0x2e5 +#define XK_ccircumflex 0x2e6 +#define XK_gabovedot 0x2f5 +#define XK_gcircumflex 0x2f8 +#define XK_ubreve 0x2fd +#define XK_scircumflex 0x2fe +#endif /* XK_LATIN3 */ + + +/* + * Latin 4 + * Byte 3 = 3 + */ + +#ifdef XK_LATIN4 +#define XK_kra 0x3a2 +#define XK_kappa 0x3a2 /* deprecated */ +#define XK_Rcedilla 0x3a3 +#define XK_Itilde 0x3a5 +#define XK_Lcedilla 0x3a6 +#define XK_Emacron 0x3aa +#define XK_Gcedilla 0x3ab +#define XK_Tslash 0x3ac +#define XK_rcedilla 0x3b3 +#define XK_itilde 0x3b5 +#define XK_lcedilla 0x3b6 +#define XK_emacron 0x3ba +#define XK_gcedilla 0x3bb +#define XK_tslash 0x3bc +#define XK_ENG 0x3bd +#define XK_eng 0x3bf +#define XK_Amacron 0x3c0 +#define XK_Iogonek 0x3c7 +#define XK_Eabovedot 0x3cc +#define XK_Imacron 0x3cf +#define XK_Ncedilla 0x3d1 +#define XK_Omacron 0x3d2 +#define XK_Kcedilla 0x3d3 +#define XK_Uogonek 0x3d9 +#define XK_Utilde 0x3dd +#define XK_Umacron 0x3de +#define XK_amacron 0x3e0 +#define XK_iogonek 0x3e7 +#define XK_eabovedot 0x3ec +#define XK_imacron 0x3ef +#define XK_ncedilla 0x3f1 +#define XK_omacron 0x3f2 +#define XK_kcedilla 0x3f3 +#define XK_uogonek 0x3f9 +#define XK_utilde 0x3fd +#define XK_umacron 0x3fe +#endif /* XK_LATIN4 */ + +/* + * Latin-8 + * Byte 3 = 18 + */ +#ifdef XK_LATIN8 +#define XK_Babovedot 0x12a1 +#define XK_babovedot 0x12a2 +#define XK_Dabovedot 0x12a6 +#define XK_Wgrave 0x12a8 +#define XK_Wacute 0x12aa +#define XK_dabovedot 0x12ab +#define XK_Ygrave 0x12ac +#define XK_Fabovedot 0x12b0 +#define XK_fabovedot 0x12b1 +#define XK_Mabovedot 0x12b4 +#define XK_mabovedot 0x12b5 +#define XK_Pabovedot 0x12b7 +#define XK_wgrave 0x12b8 +#define XK_pabovedot 0x12b9 +#define XK_wacute 0x12ba +#define XK_Sabovedot 0x12bb +#define XK_ygrave 0x12bc +#define XK_Wdiaeresis 0x12bd +#define XK_wdiaeresis 0x12be +#define XK_sabovedot 0x12bf +#define XK_Wcircumflex 0x12d0 +#define XK_Tabovedot 0x12d7 +#define XK_Ycircumflex 0x12de +#define XK_wcircumflex 0x12f0 +#define XK_tabovedot 0x12f7 +#define XK_ycircumflex 0x12fe +#endif /* XK_LATIN8 */ + +/* + * Latin-9 (a.k.a. Latin-0) + * Byte 3 = 19 + */ + +#ifdef XK_LATIN9 +#define XK_OE 0x13bc +#define XK_oe 0x13bd +#define XK_Ydiaeresis 0x13be +#endif /* XK_LATIN9 */ + +/* + * Katakana + * Byte 3 = 4 + */ + +#ifdef XK_KATAKANA +#define XK_overline 0x47e +#define XK_kana_fullstop 0x4a1 +#define XK_kana_openingbracket 0x4a2 +#define XK_kana_closingbracket 0x4a3 +#define XK_kana_comma 0x4a4 +#define XK_kana_conjunctive 0x4a5 +#define XK_kana_middledot 0x4a5 /* deprecated */ +#define XK_kana_WO 0x4a6 +#define XK_kana_a 0x4a7 +#define XK_kana_i 0x4a8 +#define XK_kana_u 0x4a9 +#define XK_kana_e 0x4aa +#define XK_kana_o 0x4ab +#define XK_kana_ya 0x4ac +#define XK_kana_yu 0x4ad +#define XK_kana_yo 0x4ae +#define XK_kana_tsu 0x4af +#define XK_kana_tu 0x4af /* deprecated */ +#define XK_prolongedsound 0x4b0 +#define XK_kana_A 0x4b1 +#define XK_kana_I 0x4b2 +#define XK_kana_U 0x4b3 +#define XK_kana_E 0x4b4 +#define XK_kana_O 0x4b5 +#define XK_kana_KA 0x4b6 +#define XK_kana_KI 0x4b7 +#define XK_kana_KU 0x4b8 +#define XK_kana_KE 0x4b9 +#define XK_kana_KO 0x4ba +#define XK_kana_SA 0x4bb +#define XK_kana_SHI 0x4bc +#define XK_kana_SU 0x4bd +#define XK_kana_SE 0x4be +#define XK_kana_SO 0x4bf +#define XK_kana_TA 0x4c0 +#define XK_kana_CHI 0x4c1 +#define XK_kana_TI 0x4c1 /* deprecated */ +#define XK_kana_TSU 0x4c2 +#define XK_kana_TU 0x4c2 /* deprecated */ +#define XK_kana_TE 0x4c3 +#define XK_kana_TO 0x4c4 +#define XK_kana_NA 0x4c5 +#define XK_kana_NI 0x4c6 +#define XK_kana_NU 0x4c7 +#define XK_kana_NE 0x4c8 +#define XK_kana_NO 0x4c9 +#define XK_kana_HA 0x4ca +#define XK_kana_HI 0x4cb +#define XK_kana_FU 0x4cc +#define XK_kana_HU 0x4cc /* deprecated */ +#define XK_kana_HE 0x4cd +#define XK_kana_HO 0x4ce +#define XK_kana_MA 0x4cf +#define XK_kana_MI 0x4d0 +#define XK_kana_MU 0x4d1 +#define XK_kana_ME 0x4d2 +#define XK_kana_MO 0x4d3 +#define XK_kana_YA 0x4d4 +#define XK_kana_YU 0x4d5 +#define XK_kana_YO 0x4d6 +#define XK_kana_RA 0x4d7 +#define XK_kana_RI 0x4d8 +#define XK_kana_RU 0x4d9 +#define XK_kana_RE 0x4da +#define XK_kana_RO 0x4db +#define XK_kana_WA 0x4dc +#define XK_kana_N 0x4dd +#define XK_voicedsound 0x4de +#define XK_semivoicedsound 0x4df +#define XK_kana_switch 0xFF7E /* Alias for mode_switch */ +#endif /* XK_KATAKANA */ + +/* + * Arabic + * Byte 3 = 5 + */ + +#ifdef XK_ARABIC +#define XK_Farsi_0 0x590 +#define XK_Farsi_1 0x591 +#define XK_Farsi_2 0x592 +#define XK_Farsi_3 0x593 +#define XK_Farsi_4 0x594 +#define XK_Farsi_5 0x595 +#define XK_Farsi_6 0x596 +#define XK_Farsi_7 0x597 +#define XK_Farsi_8 0x598 +#define XK_Farsi_9 0x599 +#define XK_Arabic_percent 0x5a5 +#define XK_Arabic_superscript_alef 0x5a6 +#define XK_Arabic_tteh 0x5a7 +#define XK_Arabic_peh 0x5a8 +#define XK_Arabic_tcheh 0x5a9 +#define XK_Arabic_ddal 0x5aa +#define XK_Arabic_rreh 0x5ab +#define XK_Arabic_comma 0x5ac +#define XK_Arabic_fullstop 0x5ae +#define XK_Arabic_0 0x5b0 +#define XK_Arabic_1 0x5b1 +#define XK_Arabic_2 0x5b2 +#define XK_Arabic_3 0x5b3 +#define XK_Arabic_4 0x5b4 +#define XK_Arabic_5 0x5b5 +#define XK_Arabic_6 0x5b6 +#define XK_Arabic_7 0x5b7 +#define XK_Arabic_8 0x5b8 +#define XK_Arabic_9 0x5b9 +#define XK_Arabic_semicolon 0x5bb +#define XK_Arabic_question_mark 0x5bf +#define XK_Arabic_hamza 0x5c1 +#define XK_Arabic_maddaonalef 0x5c2 +#define XK_Arabic_hamzaonalef 0x5c3 +#define XK_Arabic_hamzaonwaw 0x5c4 +#define XK_Arabic_hamzaunderalef 0x5c5 +#define XK_Arabic_hamzaonyeh 0x5c6 +#define XK_Arabic_alef 0x5c7 +#define XK_Arabic_beh 0x5c8 +#define XK_Arabic_tehmarbuta 0x5c9 +#define XK_Arabic_teh 0x5ca +#define XK_Arabic_theh 0x5cb +#define XK_Arabic_jeem 0x5cc +#define XK_Arabic_hah 0x5cd +#define XK_Arabic_khah 0x5ce +#define XK_Arabic_dal 0x5cf +#define XK_Arabic_thal 0x5d0 +#define XK_Arabic_ra 0x5d1 +#define XK_Arabic_zain 0x5d2 +#define XK_Arabic_seen 0x5d3 +#define XK_Arabic_sheen 0x5d4 +#define XK_Arabic_sad 0x5d5 +#define XK_Arabic_dad 0x5d6 +#define XK_Arabic_tah 0x5d7 +#define XK_Arabic_zah 0x5d8 +#define XK_Arabic_ain 0x5d9 +#define XK_Arabic_ghain 0x5da +#define XK_Arabic_tatweel 0x5e0 +#define XK_Arabic_feh 0x5e1 +#define XK_Arabic_qaf 0x5e2 +#define XK_Arabic_kaf 0x5e3 +#define XK_Arabic_lam 0x5e4 +#define XK_Arabic_meem 0x5e5 +#define XK_Arabic_noon 0x5e6 +#define XK_Arabic_ha 0x5e7 +#define XK_Arabic_heh 0x5e7 /* deprecated */ +#define XK_Arabic_waw 0x5e8 +#define XK_Arabic_alefmaksura 0x5e9 +#define XK_Arabic_yeh 0x5ea +#define XK_Arabic_fathatan 0x5eb +#define XK_Arabic_dammatan 0x5ec +#define XK_Arabic_kasratan 0x5ed +#define XK_Arabic_fatha 0x5ee +#define XK_Arabic_damma 0x5ef +#define XK_Arabic_kasra 0x5f0 +#define XK_Arabic_shadda 0x5f1 +#define XK_Arabic_sukun 0x5f2 +#define XK_Arabic_madda_above 0x5f3 +#define XK_Arabic_hamza_above 0x5f4 +#define XK_Arabic_hamza_below 0x5f5 +#define XK_Arabic_jeh 0x5f6 +#define XK_Arabic_veh 0x5f7 +#define XK_Arabic_keheh 0x5f8 +#define XK_Arabic_gaf 0x5f9 +#define XK_Arabic_noon_ghunna 0x5fa +#define XK_Arabic_heh_doachashmee 0x5fb +#define XK_Farsi_yeh 0x5fc +#define XK_Arabic_farsi_yeh XK_Farsi_yeh +#define XK_Arabic_yeh_baree 0x5fd +#define XK_Arabic_heh_goal 0x5fe +#define XK_Arabic_switch 0xFF7E /* Alias for mode_switch */ +#endif /* XK_ARABIC */ + +/* + * Cyrillic + * Byte 3 = 6 + */ +#ifdef XK_CYRILLIC +#define XK_Cyrillic_GHE_bar 0x680 +#define XK_Cyrillic_ghe_bar 0x690 +#define XK_Cyrillic_ZHE_descender 0x681 +#define XK_Cyrillic_zhe_descender 0x691 +#define XK_Cyrillic_KA_descender 0x682 +#define XK_Cyrillic_ka_descender 0x692 +#define XK_Cyrillic_KA_vertstroke 0x683 +#define XK_Cyrillic_ka_vertstroke 0x693 +#define XK_Cyrillic_EN_descender 0x684 +#define XK_Cyrillic_en_descender 0x694 +#define XK_Cyrillic_U_straight 0x685 +#define XK_Cyrillic_u_straight 0x695 +#define XK_Cyrillic_U_straight_bar 0x686 +#define XK_Cyrillic_u_straight_bar 0x696 +#define XK_Cyrillic_HA_descender 0x687 +#define XK_Cyrillic_ha_descender 0x697 +#define XK_Cyrillic_CHE_descender 0x688 +#define XK_Cyrillic_che_descender 0x698 +#define XK_Cyrillic_CHE_vertstroke 0x689 +#define XK_Cyrillic_che_vertstroke 0x699 +#define XK_Cyrillic_SHHA 0x68a +#define XK_Cyrillic_shha 0x69a + +#define XK_Cyrillic_SCHWA 0x68c +#define XK_Cyrillic_schwa 0x69c +#define XK_Cyrillic_I_macron 0x68d +#define XK_Cyrillic_i_macron 0x69d +#define XK_Cyrillic_O_bar 0x68e +#define XK_Cyrillic_o_bar 0x69e +#define XK_Cyrillic_U_macron 0x68f +#define XK_Cyrillic_u_macron 0x69f + +#define XK_Serbian_dje 0x6a1 +#define XK_Macedonia_gje 0x6a2 +#define XK_Cyrillic_io 0x6a3 +#define XK_Ukrainian_ie 0x6a4 +#define XK_Ukranian_je 0x6a4 /* deprecated */ +#define XK_Macedonia_dse 0x6a5 +#define XK_Ukrainian_i 0x6a6 +#define XK_Ukranian_i 0x6a6 /* deprecated */ +#define XK_Ukrainian_yi 0x6a7 +#define XK_Ukranian_yi 0x6a7 /* deprecated */ +#define XK_Cyrillic_je 0x6a8 +#define XK_Serbian_je 0x6a8 /* deprecated */ +#define XK_Cyrillic_lje 0x6a9 +#define XK_Serbian_lje 0x6a9 /* deprecated */ +#define XK_Cyrillic_nje 0x6aa +#define XK_Serbian_nje 0x6aa /* deprecated */ +#define XK_Serbian_tshe 0x6ab +#define XK_Macedonia_kje 0x6ac +#define XK_Ukrainian_ghe_with_upturn 0x6ad +#define XK_Byelorussian_shortu 0x6ae +#define XK_Cyrillic_dzhe 0x6af +#define XK_Serbian_dze 0x6af /* deprecated */ +#define XK_numerosign 0x6b0 +#define XK_Serbian_DJE 0x6b1 +#define XK_Macedonia_GJE 0x6b2 +#define XK_Cyrillic_IO 0x6b3 +#define XK_Ukrainian_IE 0x6b4 +#define XK_Ukranian_JE 0x6b4 /* deprecated */ +#define XK_Macedonia_DSE 0x6b5 +#define XK_Ukrainian_I 0x6b6 +#define XK_Ukranian_I 0x6b6 /* deprecated */ +#define XK_Ukrainian_YI 0x6b7 +#define XK_Ukranian_YI 0x6b7 /* deprecated */ +#define XK_Cyrillic_JE 0x6b8 +#define XK_Serbian_JE 0x6b8 /* deprecated */ +#define XK_Cyrillic_LJE 0x6b9 +#define XK_Serbian_LJE 0x6b9 /* deprecated */ +#define XK_Cyrillic_NJE 0x6ba +#define XK_Serbian_NJE 0x6ba /* deprecated */ +#define XK_Serbian_TSHE 0x6bb +#define XK_Macedonia_KJE 0x6bc +#define XK_Ukrainian_GHE_WITH_UPTURN 0x6bd +#define XK_Byelorussian_SHORTU 0x6be +#define XK_Cyrillic_DZHE 0x6bf +#define XK_Serbian_DZE 0x6bf /* deprecated */ +#define XK_Cyrillic_yu 0x6c0 +#define XK_Cyrillic_a 0x6c1 +#define XK_Cyrillic_be 0x6c2 +#define XK_Cyrillic_tse 0x6c3 +#define XK_Cyrillic_de 0x6c4 +#define XK_Cyrillic_ie 0x6c5 +#define XK_Cyrillic_ef 0x6c6 +#define XK_Cyrillic_ghe 0x6c7 +#define XK_Cyrillic_ha 0x6c8 +#define XK_Cyrillic_i 0x6c9 +#define XK_Cyrillic_shorti 0x6ca +#define XK_Cyrillic_ka 0x6cb +#define XK_Cyrillic_el 0x6cc +#define XK_Cyrillic_em 0x6cd +#define XK_Cyrillic_en 0x6ce +#define XK_Cyrillic_o 0x6cf +#define XK_Cyrillic_pe 0x6d0 +#define XK_Cyrillic_ya 0x6d1 +#define XK_Cyrillic_er 0x6d2 +#define XK_Cyrillic_es 0x6d3 +#define XK_Cyrillic_te 0x6d4 +#define XK_Cyrillic_u 0x6d5 +#define XK_Cyrillic_zhe 0x6d6 +#define XK_Cyrillic_ve 0x6d7 +#define XK_Cyrillic_softsign 0x6d8 +#define XK_Cyrillic_yeru 0x6d9 +#define XK_Cyrillic_ze 0x6da +#define XK_Cyrillic_sha 0x6db +#define XK_Cyrillic_e 0x6dc +#define XK_Cyrillic_shcha 0x6dd +#define XK_Cyrillic_che 0x6de +#define XK_Cyrillic_hardsign 0x6df +#define XK_Cyrillic_YU 0x6e0 +#define XK_Cyrillic_A 0x6e1 +#define XK_Cyrillic_BE 0x6e2 +#define XK_Cyrillic_TSE 0x6e3 +#define XK_Cyrillic_DE 0x6e4 +#define XK_Cyrillic_IE 0x6e5 +#define XK_Cyrillic_EF 0x6e6 +#define XK_Cyrillic_GHE 0x6e7 +#define XK_Cyrillic_HA 0x6e8 +#define XK_Cyrillic_I 0x6e9 +#define XK_Cyrillic_SHORTI 0x6ea +#define XK_Cyrillic_KA 0x6eb +#define XK_Cyrillic_EL 0x6ec +#define XK_Cyrillic_EM 0x6ed +#define XK_Cyrillic_EN 0x6ee +#define XK_Cyrillic_O 0x6ef +#define XK_Cyrillic_PE 0x6f0 +#define XK_Cyrillic_YA 0x6f1 +#define XK_Cyrillic_ER 0x6f2 +#define XK_Cyrillic_ES 0x6f3 +#define XK_Cyrillic_TE 0x6f4 +#define XK_Cyrillic_U 0x6f5 +#define XK_Cyrillic_ZHE 0x6f6 +#define XK_Cyrillic_VE 0x6f7 +#define XK_Cyrillic_SOFTSIGN 0x6f8 +#define XK_Cyrillic_YERU 0x6f9 +#define XK_Cyrillic_ZE 0x6fa +#define XK_Cyrillic_SHA 0x6fb +#define XK_Cyrillic_E 0x6fc +#define XK_Cyrillic_SHCHA 0x6fd +#define XK_Cyrillic_CHE 0x6fe +#define XK_Cyrillic_HARDSIGN 0x6ff +#endif /* XK_CYRILLIC */ + +/* + * Greek + * Byte 3 = 7 + */ + +#ifdef XK_GREEK +#define XK_Greek_ALPHAaccent 0x7a1 +#define XK_Greek_EPSILONaccent 0x7a2 +#define XK_Greek_ETAaccent 0x7a3 +#define XK_Greek_IOTAaccent 0x7a4 +#define XK_Greek_IOTAdieresis 0x7a5 +#define XK_Greek_IOTAdiaeresis XK_Greek_IOTAdieresis /* old typo */ +#define XK_Greek_OMICRONaccent 0x7a7 +#define XK_Greek_UPSILONaccent 0x7a8 +#define XK_Greek_UPSILONdieresis 0x7a9 +#define XK_Greek_OMEGAaccent 0x7ab +#define XK_Greek_accentdieresis 0x7ae +#define XK_Greek_horizbar 0x7af +#define XK_Greek_alphaaccent 0x7b1 +#define XK_Greek_epsilonaccent 0x7b2 +#define XK_Greek_etaaccent 0x7b3 +#define XK_Greek_iotaaccent 0x7b4 +#define XK_Greek_iotadieresis 0x7b5 +#define XK_Greek_iotaaccentdieresis 0x7b6 +#define XK_Greek_omicronaccent 0x7b7 +#define XK_Greek_upsilonaccent 0x7b8 +#define XK_Greek_upsilondieresis 0x7b9 +#define XK_Greek_upsilonaccentdieresis 0x7ba +#define XK_Greek_omegaaccent 0x7bb +#define XK_Greek_ALPHA 0x7c1 +#define XK_Greek_BETA 0x7c2 +#define XK_Greek_GAMMA 0x7c3 +#define XK_Greek_DELTA 0x7c4 +#define XK_Greek_EPSILON 0x7c5 +#define XK_Greek_ZETA 0x7c6 +#define XK_Greek_ETA 0x7c7 +#define XK_Greek_THETA 0x7c8 +#define XK_Greek_IOTA 0x7c9 +#define XK_Greek_KAPPA 0x7ca +#define XK_Greek_LAMDA 0x7cb +#define XK_Greek_LAMBDA 0x7cb +#define XK_Greek_MU 0x7cc +#define XK_Greek_NU 0x7cd +#define XK_Greek_XI 0x7ce +#define XK_Greek_OMICRON 0x7cf +#define XK_Greek_PI 0x7d0 +#define XK_Greek_RHO 0x7d1 +#define XK_Greek_SIGMA 0x7d2 +#define XK_Greek_TAU 0x7d4 +#define XK_Greek_UPSILON 0x7d5 +#define XK_Greek_PHI 0x7d6 +#define XK_Greek_CHI 0x7d7 +#define XK_Greek_PSI 0x7d8 +#define XK_Greek_OMEGA 0x7d9 +#define XK_Greek_alpha 0x7e1 +#define XK_Greek_beta 0x7e2 +#define XK_Greek_gamma 0x7e3 +#define XK_Greek_delta 0x7e4 +#define XK_Greek_epsilon 0x7e5 +#define XK_Greek_zeta 0x7e6 +#define XK_Greek_eta 0x7e7 +#define XK_Greek_theta 0x7e8 +#define XK_Greek_iota 0x7e9 +#define XK_Greek_kappa 0x7ea +#define XK_Greek_lamda 0x7eb +#define XK_Greek_lambda 0x7eb +#define XK_Greek_mu 0x7ec +#define XK_Greek_nu 0x7ed +#define XK_Greek_xi 0x7ee +#define XK_Greek_omicron 0x7ef +#define XK_Greek_pi 0x7f0 +#define XK_Greek_rho 0x7f1 +#define XK_Greek_sigma 0x7f2 +#define XK_Greek_finalsmallsigma 0x7f3 +#define XK_Greek_tau 0x7f4 +#define XK_Greek_upsilon 0x7f5 +#define XK_Greek_phi 0x7f6 +#define XK_Greek_chi 0x7f7 +#define XK_Greek_psi 0x7f8 +#define XK_Greek_omega 0x7f9 +#define XK_Greek_switch 0xFF7E /* Alias for mode_switch */ +#endif /* XK_GREEK */ + +/* + * Technical + * Byte 3 = 8 + */ + +#ifdef XK_TECHNICAL +#define XK_leftradical 0x8a1 +#define XK_topleftradical 0x8a2 +#define XK_horizconnector 0x8a3 +#define XK_topintegral 0x8a4 +#define XK_botintegral 0x8a5 +#define XK_vertconnector 0x8a6 +#define XK_topleftsqbracket 0x8a7 +#define XK_botleftsqbracket 0x8a8 +#define XK_toprightsqbracket 0x8a9 +#define XK_botrightsqbracket 0x8aa +#define XK_topleftparens 0x8ab +#define XK_botleftparens 0x8ac +#define XK_toprightparens 0x8ad +#define XK_botrightparens 0x8ae +#define XK_leftmiddlecurlybrace 0x8af +#define XK_rightmiddlecurlybrace 0x8b0 +#define XK_topleftsummation 0x8b1 +#define XK_botleftsummation 0x8b2 +#define XK_topvertsummationconnector 0x8b3 +#define XK_botvertsummationconnector 0x8b4 +#define XK_toprightsummation 0x8b5 +#define XK_botrightsummation 0x8b6 +#define XK_rightmiddlesummation 0x8b7 +#define XK_lessthanequal 0x8bc +#define XK_notequal 0x8bd +#define XK_greaterthanequal 0x8be +#define XK_integral 0x8bf +#define XK_therefore 0x8c0 +#define XK_variation 0x8c1 +#define XK_infinity 0x8c2 +#define XK_nabla 0x8c5 +#define XK_approximate 0x8c8 +#define XK_similarequal 0x8c9 +#define XK_ifonlyif 0x8cd +#define XK_implies 0x8ce +#define XK_identical 0x8cf +#define XK_radical 0x8d6 +#define XK_includedin 0x8da +#define XK_includes 0x8db +#define XK_intersection 0x8dc +#define XK_union 0x8dd +#define XK_logicaland 0x8de +#define XK_logicalor 0x8df +#define XK_partialderivative 0x8ef +#define XK_function 0x8f6 +#define XK_leftarrow 0x8fb +#define XK_uparrow 0x8fc +#define XK_rightarrow 0x8fd +#define XK_downarrow 0x8fe +#endif /* XK_TECHNICAL */ + +/* + * Special + * Byte 3 = 9 + */ + +#ifdef XK_SPECIAL +#define XK_blank 0x9df +#define XK_soliddiamond 0x9e0 +#define XK_checkerboard 0x9e1 +#define XK_ht 0x9e2 +#define XK_ff 0x9e3 +#define XK_cr 0x9e4 +#define XK_lf 0x9e5 +#define XK_nl 0x9e8 +#define XK_vt 0x9e9 +#define XK_lowrightcorner 0x9ea +#define XK_uprightcorner 0x9eb +#define XK_upleftcorner 0x9ec +#define XK_lowleftcorner 0x9ed +#define XK_crossinglines 0x9ee +#define XK_horizlinescan1 0x9ef +#define XK_horizlinescan3 0x9f0 +#define XK_horizlinescan5 0x9f1 +#define XK_horizlinescan7 0x9f2 +#define XK_horizlinescan9 0x9f3 +#define XK_leftt 0x9f4 +#define XK_rightt 0x9f5 +#define XK_bott 0x9f6 +#define XK_topt 0x9f7 +#define XK_vertbar 0x9f8 +#endif /* XK_SPECIAL */ + +/* + * Publishing + * Byte 3 = a + */ + +#ifdef XK_PUBLISHING +#define XK_emspace 0xaa1 +#define XK_enspace 0xaa2 +#define XK_em3space 0xaa3 +#define XK_em4space 0xaa4 +#define XK_digitspace 0xaa5 +#define XK_punctspace 0xaa6 +#define XK_thinspace 0xaa7 +#define XK_hairspace 0xaa8 +#define XK_emdash 0xaa9 +#define XK_endash 0xaaa +#define XK_signifblank 0xaac +#define XK_ellipsis 0xaae +#define XK_doubbaselinedot 0xaaf +#define XK_onethird 0xab0 +#define XK_twothirds 0xab1 +#define XK_onefifth 0xab2 +#define XK_twofifths 0xab3 +#define XK_threefifths 0xab4 +#define XK_fourfifths 0xab5 +#define XK_onesixth 0xab6 +#define XK_fivesixths 0xab7 +#define XK_careof 0xab8 +#define XK_figdash 0xabb +#define XK_leftanglebracket 0xabc +#define XK_decimalpoint 0xabd +#define XK_rightanglebracket 0xabe +#define XK_marker 0xabf +#define XK_oneeighth 0xac3 +#define XK_threeeighths 0xac4 +#define XK_fiveeighths 0xac5 +#define XK_seveneighths 0xac6 +#define XK_trademark 0xac9 +#define XK_signaturemark 0xaca +#define XK_trademarkincircle 0xacb +#define XK_leftopentriangle 0xacc +#define XK_rightopentriangle 0xacd +#define XK_emopencircle 0xace +#define XK_emopenrectangle 0xacf +#define XK_leftsinglequotemark 0xad0 +#define XK_rightsinglequotemark 0xad1 +#define XK_leftdoublequotemark 0xad2 +#define XK_rightdoublequotemark 0xad3 +#define XK_prescription 0xad4 +#define XK_minutes 0xad6 +#define XK_seconds 0xad7 +#define XK_latincross 0xad9 +#define XK_hexagram 0xada +#define XK_filledrectbullet 0xadb +#define XK_filledlefttribullet 0xadc +#define XK_filledrighttribullet 0xadd +#define XK_emfilledcircle 0xade +#define XK_emfilledrect 0xadf +#define XK_enopencircbullet 0xae0 +#define XK_enopensquarebullet 0xae1 +#define XK_openrectbullet 0xae2 +#define XK_opentribulletup 0xae3 +#define XK_opentribulletdown 0xae4 +#define XK_openstar 0xae5 +#define XK_enfilledcircbullet 0xae6 +#define XK_enfilledsqbullet 0xae7 +#define XK_filledtribulletup 0xae8 +#define XK_filledtribulletdown 0xae9 +#define XK_leftpointer 0xaea +#define XK_rightpointer 0xaeb +#define XK_club 0xaec +#define XK_diamond 0xaed +#define XK_heart 0xaee +#define XK_maltesecross 0xaf0 +#define XK_dagger 0xaf1 +#define XK_doubledagger 0xaf2 +#define XK_checkmark 0xaf3 +#define XK_ballotcross 0xaf4 +#define XK_musicalsharp 0xaf5 +#define XK_musicalflat 0xaf6 +#define XK_malesymbol 0xaf7 +#define XK_femalesymbol 0xaf8 +#define XK_telephone 0xaf9 +#define XK_telephonerecorder 0xafa +#define XK_phonographcopyright 0xafb +#define XK_caret 0xafc +#define XK_singlelowquotemark 0xafd +#define XK_doublelowquotemark 0xafe +#define XK_cursor 0xaff +#endif /* XK_PUBLISHING */ + +/* + * APL + * Byte 3 = b + */ + +#ifdef XK_APL +#define XK_leftcaret 0xba3 +#define XK_rightcaret 0xba6 +#define XK_downcaret 0xba8 +#define XK_upcaret 0xba9 +#define XK_overbar 0xbc0 +#define XK_downtack 0xbc2 +#define XK_upshoe 0xbc3 +#define XK_downstile 0xbc4 +#define XK_underbar 0xbc6 +#define XK_jot 0xbca +#define XK_quad 0xbcc +#define XK_uptack 0xbce +#define XK_circle 0xbcf +#define XK_upstile 0xbd3 +#define XK_downshoe 0xbd6 +#define XK_rightshoe 0xbd8 +#define XK_leftshoe 0xbda +#define XK_lefttack 0xbdc +#define XK_righttack 0xbfc +#endif /* XK_APL */ + +/* + * Hebrew + * Byte 3 = c + */ + +#ifdef XK_HEBREW +#define XK_hebrew_doublelowline 0xcdf +#define XK_hebrew_aleph 0xce0 +#define XK_hebrew_bet 0xce1 +#define XK_hebrew_beth 0xce1 /* deprecated */ +#define XK_hebrew_gimel 0xce2 +#define XK_hebrew_gimmel 0xce2 /* deprecated */ +#define XK_hebrew_dalet 0xce3 +#define XK_hebrew_daleth 0xce3 /* deprecated */ +#define XK_hebrew_he 0xce4 +#define XK_hebrew_waw 0xce5 +#define XK_hebrew_zain 0xce6 +#define XK_hebrew_zayin 0xce6 /* deprecated */ +#define XK_hebrew_chet 0xce7 +#define XK_hebrew_het 0xce7 /* deprecated */ +#define XK_hebrew_tet 0xce8 +#define XK_hebrew_teth 0xce8 /* deprecated */ +#define XK_hebrew_yod 0xce9 +#define XK_hebrew_finalkaph 0xcea +#define XK_hebrew_kaph 0xceb +#define XK_hebrew_lamed 0xcec +#define XK_hebrew_finalmem 0xced +#define XK_hebrew_mem 0xcee +#define XK_hebrew_finalnun 0xcef +#define XK_hebrew_nun 0xcf0 +#define XK_hebrew_samech 0xcf1 +#define XK_hebrew_samekh 0xcf1 /* deprecated */ +#define XK_hebrew_ayin 0xcf2 +#define XK_hebrew_finalpe 0xcf3 +#define XK_hebrew_pe 0xcf4 +#define XK_hebrew_finalzade 0xcf5 +#define XK_hebrew_finalzadi 0xcf5 /* deprecated */ +#define XK_hebrew_zade 0xcf6 +#define XK_hebrew_zadi 0xcf6 /* deprecated */ +#define XK_hebrew_qoph 0xcf7 +#define XK_hebrew_kuf 0xcf7 /* deprecated */ +#define XK_hebrew_resh 0xcf8 +#define XK_hebrew_shin 0xcf9 +#define XK_hebrew_taw 0xcfa +#define XK_hebrew_taf 0xcfa /* deprecated */ +#define XK_Hebrew_switch 0xFF7E /* Alias for mode_switch */ +#endif /* XK_HEBREW */ + +/* + * Thai + * Byte 3 = d + */ + +#ifdef XK_THAI +#define XK_Thai_kokai 0xda1 +#define XK_Thai_khokhai 0xda2 +#define XK_Thai_khokhuat 0xda3 +#define XK_Thai_khokhwai 0xda4 +#define XK_Thai_khokhon 0xda5 +#define XK_Thai_khorakhang 0xda6 +#define XK_Thai_ngongu 0xda7 +#define XK_Thai_chochan 0xda8 +#define XK_Thai_choching 0xda9 +#define XK_Thai_chochang 0xdaa +#define XK_Thai_soso 0xdab +#define XK_Thai_chochoe 0xdac +#define XK_Thai_yoying 0xdad +#define XK_Thai_dochada 0xdae +#define XK_Thai_topatak 0xdaf +#define XK_Thai_thothan 0xdb0 +#define XK_Thai_thonangmontho 0xdb1 +#define XK_Thai_thophuthao 0xdb2 +#define XK_Thai_nonen 0xdb3 +#define XK_Thai_dodek 0xdb4 +#define XK_Thai_totao 0xdb5 +#define XK_Thai_thothung 0xdb6 +#define XK_Thai_thothahan 0xdb7 +#define XK_Thai_thothong 0xdb8 +#define XK_Thai_nonu 0xdb9 +#define XK_Thai_bobaimai 0xdba +#define XK_Thai_popla 0xdbb +#define XK_Thai_phophung 0xdbc +#define XK_Thai_fofa 0xdbd +#define XK_Thai_phophan 0xdbe +#define XK_Thai_fofan 0xdbf +#define XK_Thai_phosamphao 0xdc0 +#define XK_Thai_moma 0xdc1 +#define XK_Thai_yoyak 0xdc2 +#define XK_Thai_rorua 0xdc3 +#define XK_Thai_ru 0xdc4 +#define XK_Thai_loling 0xdc5 +#define XK_Thai_lu 0xdc6 +#define XK_Thai_wowaen 0xdc7 +#define XK_Thai_sosala 0xdc8 +#define XK_Thai_sorusi 0xdc9 +#define XK_Thai_sosua 0xdca +#define XK_Thai_hohip 0xdcb +#define XK_Thai_lochula 0xdcc +#define XK_Thai_oang 0xdcd +#define XK_Thai_honokhuk 0xdce +#define XK_Thai_paiyannoi 0xdcf +#define XK_Thai_saraa 0xdd0 +#define XK_Thai_maihanakat 0xdd1 +#define XK_Thai_saraaa 0xdd2 +#define XK_Thai_saraam 0xdd3 +#define XK_Thai_sarai 0xdd4 +#define XK_Thai_saraii 0xdd5 +#define XK_Thai_saraue 0xdd6 +#define XK_Thai_sarauee 0xdd7 +#define XK_Thai_sarau 0xdd8 +#define XK_Thai_sarauu 0xdd9 +#define XK_Thai_phinthu 0xdda +#define XK_Thai_maihanakat_maitho 0xdde +#define XK_Thai_baht 0xddf +#define XK_Thai_sarae 0xde0 +#define XK_Thai_saraae 0xde1 +#define XK_Thai_sarao 0xde2 +#define XK_Thai_saraaimaimuan 0xde3 +#define XK_Thai_saraaimaimalai 0xde4 +#define XK_Thai_lakkhangyao 0xde5 +#define XK_Thai_maiyamok 0xde6 +#define XK_Thai_maitaikhu 0xde7 +#define XK_Thai_maiek 0xde8 +#define XK_Thai_maitho 0xde9 +#define XK_Thai_maitri 0xdea +#define XK_Thai_maichattawa 0xdeb +#define XK_Thai_thanthakhat 0xdec +#define XK_Thai_nikhahit 0xded +#define XK_Thai_leksun 0xdf0 +#define XK_Thai_leknung 0xdf1 +#define XK_Thai_leksong 0xdf2 +#define XK_Thai_leksam 0xdf3 +#define XK_Thai_leksi 0xdf4 +#define XK_Thai_lekha 0xdf5 +#define XK_Thai_lekhok 0xdf6 +#define XK_Thai_lekchet 0xdf7 +#define XK_Thai_lekpaet 0xdf8 +#define XK_Thai_lekkao 0xdf9 +#endif /* XK_THAI */ + +/* + * Korean + * Byte 3 = e + */ + +#ifdef XK_KOREAN + +#define XK_Hangul 0xff31 /* Hangul start/stop(toggle) */ +#define XK_Hangul_Start 0xff32 /* Hangul start */ +#define XK_Hangul_End 0xff33 /* Hangul end, English start */ +#define XK_Hangul_Hanja 0xff34 /* Start Hangul->Hanja Conversion */ +#define XK_Hangul_Jamo 0xff35 /* Hangul Jamo mode */ +#define XK_Hangul_Romaja 0xff36 /* Hangul Romaja mode */ +#define XK_Hangul_Codeinput 0xff37 /* Hangul code input mode */ +#define XK_Hangul_Jeonja 0xff38 /* Jeonja mode */ +#define XK_Hangul_Banja 0xff39 /* Banja mode */ +#define XK_Hangul_PreHanja 0xff3a /* Pre Hanja conversion */ +#define XK_Hangul_PostHanja 0xff3b /* Post Hanja conversion */ +#define XK_Hangul_SingleCandidate 0xff3c /* Single candidate */ +#define XK_Hangul_MultipleCandidate 0xff3d /* Multiple candidate */ +#define XK_Hangul_PreviousCandidate 0xff3e /* Previous candidate */ +#define XK_Hangul_Special 0xff3f /* Special symbols */ +#define XK_Hangul_switch 0xFF7E /* Alias for mode_switch */ + +/* Hangul Consonant Characters */ +#define XK_Hangul_Kiyeog 0xea1 +#define XK_Hangul_SsangKiyeog 0xea2 +#define XK_Hangul_KiyeogSios 0xea3 +#define XK_Hangul_Nieun 0xea4 +#define XK_Hangul_NieunJieuj 0xea5 +#define XK_Hangul_NieunHieuh 0xea6 +#define XK_Hangul_Dikeud 0xea7 +#define XK_Hangul_SsangDikeud 0xea8 +#define XK_Hangul_Rieul 0xea9 +#define XK_Hangul_RieulKiyeog 0xeaa +#define XK_Hangul_RieulMieum 0xeab +#define XK_Hangul_RieulPieub 0xeac +#define XK_Hangul_RieulSios 0xead +#define XK_Hangul_RieulTieut 0xeae +#define XK_Hangul_RieulPhieuf 0xeaf +#define XK_Hangul_RieulHieuh 0xeb0 +#define XK_Hangul_Mieum 0xeb1 +#define XK_Hangul_Pieub 0xeb2 +#define XK_Hangul_SsangPieub 0xeb3 +#define XK_Hangul_PieubSios 0xeb4 +#define XK_Hangul_Sios 0xeb5 +#define XK_Hangul_SsangSios 0xeb6 +#define XK_Hangul_Ieung 0xeb7 +#define XK_Hangul_Jieuj 0xeb8 +#define XK_Hangul_SsangJieuj 0xeb9 +#define XK_Hangul_Cieuc 0xeba +#define XK_Hangul_Khieuq 0xebb +#define XK_Hangul_Tieut 0xebc +#define XK_Hangul_Phieuf 0xebd +#define XK_Hangul_Hieuh 0xebe + +/* Hangul Vowel Characters */ +#define XK_Hangul_A 0xebf +#define XK_Hangul_AE 0xec0 +#define XK_Hangul_YA 0xec1 +#define XK_Hangul_YAE 0xec2 +#define XK_Hangul_EO 0xec3 +#define XK_Hangul_E 0xec4 +#define XK_Hangul_YEO 0xec5 +#define XK_Hangul_YE 0xec6 +#define XK_Hangul_O 0xec7 +#define XK_Hangul_WA 0xec8 +#define XK_Hangul_WAE 0xec9 +#define XK_Hangul_OE 0xeca +#define XK_Hangul_YO 0xecb +#define XK_Hangul_U 0xecc +#define XK_Hangul_WEO 0xecd +#define XK_Hangul_WE 0xece +#define XK_Hangul_WI 0xecf +#define XK_Hangul_YU 0xed0 +#define XK_Hangul_EU 0xed1 +#define XK_Hangul_YI 0xed2 +#define XK_Hangul_I 0xed3 + +/* Hangul syllable-final (JongSeong) Characters */ +#define XK_Hangul_J_Kiyeog 0xed4 +#define XK_Hangul_J_SsangKiyeog 0xed5 +#define XK_Hangul_J_KiyeogSios 0xed6 +#define XK_Hangul_J_Nieun 0xed7 +#define XK_Hangul_J_NieunJieuj 0xed8 +#define XK_Hangul_J_NieunHieuh 0xed9 +#define XK_Hangul_J_Dikeud 0xeda +#define XK_Hangul_J_Rieul 0xedb +#define XK_Hangul_J_RieulKiyeog 0xedc +#define XK_Hangul_J_RieulMieum 0xedd +#define XK_Hangul_J_RieulPieub 0xede +#define XK_Hangul_J_RieulSios 0xedf +#define XK_Hangul_J_RieulTieut 0xee0 +#define XK_Hangul_J_RieulPhieuf 0xee1 +#define XK_Hangul_J_RieulHieuh 0xee2 +#define XK_Hangul_J_Mieum 0xee3 +#define XK_Hangul_J_Pieub 0xee4 +#define XK_Hangul_J_PieubSios 0xee5 +#define XK_Hangul_J_Sios 0xee6 +#define XK_Hangul_J_SsangSios 0xee7 +#define XK_Hangul_J_Ieung 0xee8 +#define XK_Hangul_J_Jieuj 0xee9 +#define XK_Hangul_J_Cieuc 0xeea +#define XK_Hangul_J_Khieuq 0xeeb +#define XK_Hangul_J_Tieut 0xeec +#define XK_Hangul_J_Phieuf 0xeed +#define XK_Hangul_J_Hieuh 0xeee + +/* Ancient Hangul Consonant Characters */ +#define XK_Hangul_RieulYeorinHieuh 0xeef +#define XK_Hangul_SunkyeongeumMieum 0xef0 +#define XK_Hangul_SunkyeongeumPieub 0xef1 +#define XK_Hangul_PanSios 0xef2 +#define XK_Hangul_KkogjiDalrinIeung 0xef3 +#define XK_Hangul_SunkyeongeumPhieuf 0xef4 +#define XK_Hangul_YeorinHieuh 0xef5 + +/* Ancient Hangul Vowel Characters */ +#define XK_Hangul_AraeA 0xef6 +#define XK_Hangul_AraeAE 0xef7 + +/* Ancient Hangul syllable-final (JongSeong) Characters */ +#define XK_Hangul_J_PanSios 0xef8 +#define XK_Hangul_J_KkogjiDalrinIeung 0xef9 +#define XK_Hangul_J_YeorinHieuh 0xefa + +/* Korean currency symbol */ +#define XK_Korean_Won 0xeff + +#endif /* XK_KOREAN */ + +/* + * Armenian + * Byte 3 = 0x14 + */ + +#ifdef XK_ARMENIAN +#define XK_Armenian_eternity 0x14a1 +#define XK_Armenian_ligature_ew 0x14a2 +#define XK_Armenian_full_stop 0x14a3 +#define XK_Armenian_verjaket 0x14a3 +#define XK_Armenian_parenright 0x14a4 +#define XK_Armenian_parenleft 0x14a5 +#define XK_Armenian_guillemotright 0x14a6 +#define XK_Armenian_guillemotleft 0x14a7 +#define XK_Armenian_em_dash 0x14a8 +#define XK_Armenian_dot 0x14a9 +#define XK_Armenian_mijaket 0x14a9 +#define XK_Armenian_separation_mark 0x14aa +#define XK_Armenian_but 0x14aa +#define XK_Armenian_comma 0x14ab +#define XK_Armenian_en_dash 0x14ac +#define XK_Armenian_hyphen 0x14ad +#define XK_Armenian_yentamna 0x14ad +#define XK_Armenian_ellipsis 0x14ae +#define XK_Armenian_exclam 0x14af +#define XK_Armenian_amanak 0x14af +#define XK_Armenian_accent 0x14b0 +#define XK_Armenian_shesht 0x14b0 +#define XK_Armenian_question 0x14b1 +#define XK_Armenian_paruyk 0x14b1 +#define XK_Armenian_AYB 0x14b2 +#define XK_Armenian_ayb 0x14b3 +#define XK_Armenian_BEN 0x14b4 +#define XK_Armenian_ben 0x14b5 +#define XK_Armenian_GIM 0x14b6 +#define XK_Armenian_gim 0x14b7 +#define XK_Armenian_DA 0x14b8 +#define XK_Armenian_da 0x14b9 +#define XK_Armenian_YECH 0x14ba +#define XK_Armenian_yech 0x14bb +#define XK_Armenian_ZA 0x14bc +#define XK_Armenian_za 0x14bd +#define XK_Armenian_E 0x14be +#define XK_Armenian_e 0x14bf +#define XK_Armenian_AT 0x14c0 +#define XK_Armenian_at 0x14c1 +#define XK_Armenian_TO 0x14c2 +#define XK_Armenian_to 0x14c3 +#define XK_Armenian_ZHE 0x14c4 +#define XK_Armenian_zhe 0x14c5 +#define XK_Armenian_INI 0x14c6 +#define XK_Armenian_ini 0x14c7 +#define XK_Armenian_LYUN 0x14c8 +#define XK_Armenian_lyun 0x14c9 +#define XK_Armenian_KHE 0x14ca +#define XK_Armenian_khe 0x14cb +#define XK_Armenian_TSA 0x14cc +#define XK_Armenian_tsa 0x14cd +#define XK_Armenian_KEN 0x14ce +#define XK_Armenian_ken 0x14cf +#define XK_Armenian_HO 0x14d0 +#define XK_Armenian_ho 0x14d1 +#define XK_Armenian_DZA 0x14d2 +#define XK_Armenian_dza 0x14d3 +#define XK_Armenian_GHAT 0x14d4 +#define XK_Armenian_ghat 0x14d5 +#define XK_Armenian_TCHE 0x14d6 +#define XK_Armenian_tche 0x14d7 +#define XK_Armenian_MEN 0x14d8 +#define XK_Armenian_men 0x14d9 +#define XK_Armenian_HI 0x14da +#define XK_Armenian_hi 0x14db +#define XK_Armenian_NU 0x14dc +#define XK_Armenian_nu 0x14dd +#define XK_Armenian_SHA 0x14de +#define XK_Armenian_sha 0x14df +#define XK_Armenian_VO 0x14e0 +#define XK_Armenian_vo 0x14e1 +#define XK_Armenian_CHA 0x14e2 +#define XK_Armenian_cha 0x14e3 +#define XK_Armenian_PE 0x14e4 +#define XK_Armenian_pe 0x14e5 +#define XK_Armenian_JE 0x14e6 +#define XK_Armenian_je 0x14e7 +#define XK_Armenian_RA 0x14e8 +#define XK_Armenian_ra 0x14e9 +#define XK_Armenian_SE 0x14ea +#define XK_Armenian_se 0x14eb +#define XK_Armenian_VEV 0x14ec +#define XK_Armenian_vev 0x14ed +#define XK_Armenian_TYUN 0x14ee +#define XK_Armenian_tyun 0x14ef +#define XK_Armenian_RE 0x14f0 +#define XK_Armenian_re 0x14f1 +#define XK_Armenian_TSO 0x14f2 +#define XK_Armenian_tso 0x14f3 +#define XK_Armenian_VYUN 0x14f4 +#define XK_Armenian_vyun 0x14f5 +#define XK_Armenian_PYUR 0x14f6 +#define XK_Armenian_pyur 0x14f7 +#define XK_Armenian_KE 0x14f8 +#define XK_Armenian_ke 0x14f9 +#define XK_Armenian_O 0x14fa +#define XK_Armenian_o 0x14fb +#define XK_Armenian_FE 0x14fc +#define XK_Armenian_fe 0x14fd +#define XK_Armenian_apostrophe 0x14fe +#define XK_Armenian_section_sign 0x14ff +#endif /* XK_ARMENIAN */ + +/* + * Georgian + * Byte 3 = 0x15 + */ + +#ifdef XK_GEORGIAN +#define XK_Georgian_an 0x15d0 +#define XK_Georgian_ban 0x15d1 +#define XK_Georgian_gan 0x15d2 +#define XK_Georgian_don 0x15d3 +#define XK_Georgian_en 0x15d4 +#define XK_Georgian_vin 0x15d5 +#define XK_Georgian_zen 0x15d6 +#define XK_Georgian_tan 0x15d7 +#define XK_Georgian_in 0x15d8 +#define XK_Georgian_kan 0x15d9 +#define XK_Georgian_las 0x15da +#define XK_Georgian_man 0x15db +#define XK_Georgian_nar 0x15dc +#define XK_Georgian_on 0x15dd +#define XK_Georgian_par 0x15de +#define XK_Georgian_zhar 0x15df +#define XK_Georgian_rae 0x15e0 +#define XK_Georgian_san 0x15e1 +#define XK_Georgian_tar 0x15e2 +#define XK_Georgian_un 0x15e3 +#define XK_Georgian_phar 0x15e4 +#define XK_Georgian_khar 0x15e5 +#define XK_Georgian_ghan 0x15e6 +#define XK_Georgian_qar 0x15e7 +#define XK_Georgian_shin 0x15e8 +#define XK_Georgian_chin 0x15e9 +#define XK_Georgian_can 0x15ea +#define XK_Georgian_jil 0x15eb +#define XK_Georgian_cil 0x15ec +#define XK_Georgian_char 0x15ed +#define XK_Georgian_xan 0x15ee +#define XK_Georgian_jhan 0x15ef +#define XK_Georgian_hae 0x15f0 +#define XK_Georgian_he 0x15f1 +#define XK_Georgian_hie 0x15f2 +#define XK_Georgian_we 0x15f3 +#define XK_Georgian_har 0x15f4 +#define XK_Georgian_hoe 0x15f5 +#define XK_Georgian_fi 0x15f6 +#endif /* XK_GEORGIAN */ + +/* + * Azeri (and other Turkic or Caucasian languages of ex-USSR) + * Byte 3 = 0x16 + */ + +#ifdef XK_CAUCASUS +/* latin */ +#define XK_Ccedillaabovedot 0x16a2 +#define XK_Xabovedot 0x16a3 +#define XK_Qabovedot 0x16a5 +#define XK_Ibreve 0x16a6 +#define XK_IE 0x16a7 +#define XK_UO 0x16a8 +#define XK_Zstroke 0x16a9 +#define XK_Gcaron 0x16aa +#define XK_Obarred 0x16af +#define XK_ccedillaabovedot 0x16b2 +#define XK_xabovedot 0x16b3 +#define XK_Ocaron 0x16b4 +#define XK_qabovedot 0x16b5 +#define XK_ibreve 0x16b6 +#define XK_ie 0x16b7 +#define XK_uo 0x16b8 +#define XK_zstroke 0x16b9 +#define XK_gcaron 0x16ba +#define XK_ocaron 0x16bd +#define XK_obarred 0x16bf +#define XK_SCHWA 0x16c6 +#define XK_schwa 0x16f6 +/* those are not really Caucasus, but I put them here for now */ +/* For Inupiak */ +#define XK_Lbelowdot 0x16d1 +#define XK_Lstrokebelowdot 0x16d2 +#define XK_lbelowdot 0x16e1 +#define XK_lstrokebelowdot 0x16e2 +/* For Guarani */ +#define XK_Gtilde 0x16d3 +#define XK_gtilde 0x16e3 +#endif /* XK_CAUCASUS */ + +/* + * Vietnamese + * Byte 3 = 0x1e + */ + +#ifdef XK_VIETNAMESE +#define XK_Abelowdot 0x1ea0 +#define XK_abelowdot 0x1ea1 +#define XK_Ahook 0x1ea2 +#define XK_ahook 0x1ea3 +#define XK_Acircumflexacute 0x1ea4 +#define XK_acircumflexacute 0x1ea5 +#define XK_Acircumflexgrave 0x1ea6 +#define XK_acircumflexgrave 0x1ea7 +#define XK_Acircumflexhook 0x1ea8 +#define XK_acircumflexhook 0x1ea9 +#define XK_Acircumflextilde 0x1eaa +#define XK_acircumflextilde 0x1eab +#define XK_Acircumflexbelowdot 0x1eac +#define XK_acircumflexbelowdot 0x1ead +#define XK_Abreveacute 0x1eae +#define XK_abreveacute 0x1eaf +#define XK_Abrevegrave 0x1eb0 +#define XK_abrevegrave 0x1eb1 +#define XK_Abrevehook 0x1eb2 +#define XK_abrevehook 0x1eb3 +#define XK_Abrevetilde 0x1eb4 +#define XK_abrevetilde 0x1eb5 +#define XK_Abrevebelowdot 0x1eb6 +#define XK_abrevebelowdot 0x1eb7 +#define XK_Ebelowdot 0x1eb8 +#define XK_ebelowdot 0x1eb9 +#define XK_Ehook 0x1eba +#define XK_ehook 0x1ebb +#define XK_Etilde 0x1ebc +#define XK_etilde 0x1ebd +#define XK_Ecircumflexacute 0x1ebe +#define XK_ecircumflexacute 0x1ebf +#define XK_Ecircumflexgrave 0x1ec0 +#define XK_ecircumflexgrave 0x1ec1 +#define XK_Ecircumflexhook 0x1ec2 +#define XK_ecircumflexhook 0x1ec3 +#define XK_Ecircumflextilde 0x1ec4 +#define XK_ecircumflextilde 0x1ec5 +#define XK_Ecircumflexbelowdot 0x1ec6 +#define XK_ecircumflexbelowdot 0x1ec7 +#define XK_Ihook 0x1ec8 +#define XK_ihook 0x1ec9 +#define XK_Ibelowdot 0x1eca +#define XK_ibelowdot 0x1ecb +#define XK_Obelowdot 0x1ecc +#define XK_obelowdot 0x1ecd +#define XK_Ohook 0x1ece +#define XK_ohook 0x1ecf +#define XK_Ocircumflexacute 0x1ed0 +#define XK_ocircumflexacute 0x1ed1 +#define XK_Ocircumflexgrave 0x1ed2 +#define XK_ocircumflexgrave 0x1ed3 +#define XK_Ocircumflexhook 0x1ed4 +#define XK_ocircumflexhook 0x1ed5 +#define XK_Ocircumflextilde 0x1ed6 +#define XK_ocircumflextilde 0x1ed7 +#define XK_Ocircumflexbelowdot 0x1ed8 +#define XK_ocircumflexbelowdot 0x1ed9 +#define XK_Ohornacute 0x1eda +#define XK_ohornacute 0x1edb +#define XK_Ohorngrave 0x1edc +#define XK_ohorngrave 0x1edd +#define XK_Ohornhook 0x1ede +#define XK_ohornhook 0x1edf +#define XK_Ohorntilde 0x1ee0 +#define XK_ohorntilde 0x1ee1 +#define XK_Ohornbelowdot 0x1ee2 +#define XK_ohornbelowdot 0x1ee3 +#define XK_Ubelowdot 0x1ee4 +#define XK_ubelowdot 0x1ee5 +#define XK_Uhook 0x1ee6 +#define XK_uhook 0x1ee7 +#define XK_Uhornacute 0x1ee8 +#define XK_uhornacute 0x1ee9 +#define XK_Uhorngrave 0x1eea +#define XK_uhorngrave 0x1eeb +#define XK_Uhornhook 0x1eec +#define XK_uhornhook 0x1eed +#define XK_Uhorntilde 0x1eee +#define XK_uhorntilde 0x1eef +#define XK_Uhornbelowdot 0x1ef0 +#define XK_uhornbelowdot 0x1ef1 +#define XK_Ybelowdot 0x1ef4 +#define XK_ybelowdot 0x1ef5 +#define XK_Yhook 0x1ef6 +#define XK_yhook 0x1ef7 +#define XK_Ytilde 0x1ef8 +#define XK_ytilde 0x1ef9 +#define XK_Ohorn 0x1efa /* U+01a0 */ +#define XK_ohorn 0x1efb /* U+01a1 */ +#define XK_Uhorn 0x1efc /* U+01af */ +#define XK_uhorn 0x1efd /* U+01b0 */ + +#define XK_combining_tilde 0x1e9f /* U+0303 */ +#define XK_combining_grave 0x1ef2 /* U+0300 */ +#define XK_combining_acute 0x1ef3 /* U+0301 */ +#define XK_combining_hook 0x1efe /* U+0309 */ +#define XK_combining_belowdot 0x1eff /* U+0323 */ +#endif /* XK_VIETNAMESE */ + +#ifdef XK_CURRENCY +#define XK_EcuSign 0x20a0 +#define XK_ColonSign 0x20a1 +#define XK_CruzeiroSign 0x20a2 +#define XK_FFrancSign 0x20a3 +#define XK_LiraSign 0x20a4 +#define XK_MillSign 0x20a5 +#define XK_NairaSign 0x20a6 +#define XK_PesetaSign 0x20a7 +#define XK_RupeeSign 0x20a8 +#define XK_WonSign 0x20a9 +#define XK_NewSheqelSign 0x20aa +#define XK_DongSign 0x20ab +#define XK_EuroSign 0x20ac +#endif diff --git a/engine/qux/m_x.c b/engine/qux/m_x.c new file mode 100644 index 000000000..5907ef942 --- /dev/null +++ b/engine/qux/m_x.c @@ -0,0 +1,1833 @@ +//network interface + +#include "bothdefs.h" + +#ifndef NOMEDIA + +#include "qux.h" + +#ifdef _WIN32 +#define EWOULDBLOCK WSAEWOULDBLOCK +#define EMSGSIZE WSAEMSGSIZE +#define ECONNRESET WSAECONNRESET +#define ECONNABORTED WSAECONNABORTED +#define ECONNREFUSED WSAECONNREFUSED +#define EADDRNOTAVAIL WSAEADDRNOTAVAIL + +#define qerrno WSAGetLastError() +#else + + +#define qerrno errno + +#define MSG_PARTIAL 0 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define closesocket close +#define ioctlsocket ioctl +#endif + +#undef malloc +#undef free + +#define free BZ_Free +#define malloc BZ_Malloc +#define realloc BZ_Realloc + +static xclient_t *xclients; +static int xlistensocket=-1; + +xwindow_t *xfocusedwindow; + +qboolean xrefreshed; + +xclient_t *xgrabbedclient; //clients can ask the server to ignore other clients + +#define MAXREQUESTSIZE 65535 + + +void X_SendData(xclient_t *cl, void *data, int datalen) +{ +#ifdef MULTITHREADWIN32 + if (cl->threadhandle) + EnterCriticalSection(&cl->delecatesection); +#endif + + if (cl->outbufferlen + datalen > cl->outbuffermaxlen) + { //extend buffer size + cl->outbuffermaxlen = cl->outbufferlen + datalen + 1024; + cl->outbuffer = realloc(cl->outbuffer, cl->outbuffermaxlen); + } + + memcpy(cl->outbuffer+cl->outbufferlen, data, datalen); + cl->outbufferlen += datalen; + +#ifdef MULTITHREADWIN32 + if (cl->threadhandle) + LeaveCriticalSection(&cl->delecatesection); +#endif +} + +void X_SendNotification(xEvent *data) +{ + xclient_t *cl; + for (cl = xclients; cl; cl = cl->nextclient) + { + if (cl->stillinitialising) + continue; + if (cl->tobedropped) + continue; + if (cl->outbufferlen > MAXREQUESTSIZE*4) + continue; + + data->u.u.sequenceNumber = cl->requestnum; + X_SendData(cl, data, sizeof(xEvent)); + } +} + + +qboolean X_NotifcationMaskPresent(xwindow_t *window, int mask, xclient_t *notfor) +{ + xnotificationmask_t *nm; + nm = window->notificationmask; + + if (mask == SubstructureNotifyMask || mask == SubstructureRedirectMask) + { + window = window->parent; +// for(;window;window=window->parent) + { + for (nm = window->notificationmask; nm; nm = nm->next) + { + if (nm->mask & mask) + if (nm->client != notfor) + return true; + } + } + } + + else + { + for (nm = window->notificationmask; nm; nm = nm->next) + { + if (nm->mask & mask) + if (nm->client != notfor) + return true; + } + } + + return false; +} + +int X_SendNotificationMasked(xEvent *data, xwindow_t *window, unsigned int mask) +{ + int count=0; + xclient_t *cl; + xnotificationmask_t *nm; + + xwindow_t *child = window; + + if (mask == SubstructureNotifyMask || mask == SubstructureRedirectMask) + { + for (cl = xclients; cl; cl = cl->nextclient) + { + //don't send to if... + if (cl->stillinitialising) + continue; + if (cl->tobedropped) + continue; + if (cl->outbufferlen > MAXREQUESTSIZE*4) + { + cl->tobedropped = true; + continue; + } + window = child->parent; + +// for (window = child; window; window = window->parent) + { + for (nm = window->notificationmask; nm; nm = nm->next) + { + if (nm->client != cl) + continue; + if (!(nm->mask & mask)) + continue; + + data->u.reparent.event = window->res.id; //so the request/notification/whatever knows who asked for it. + + data->u.u.sequenceNumber = cl->requestnum; + X_SendData(cl, data, sizeof(xEvent)); + count++; + break; + } +// if (nm) +// break; + } + } + } + else + { + for (nm = window->notificationmask; nm; nm = nm->next) + { + if (!(nm->mask & mask)) + continue; + cl = nm->client; + + if (cl->stillinitialising) + continue; + if (cl->tobedropped) + continue; + if (cl->outbufferlen > MAXREQUESTSIZE*4) + { + cl->tobedropped = true; + continue; + } + + data->u.u.sequenceNumber = cl->requestnum; + X_SendData(cl, data, sizeof(xEvent)); + count++; + } + } + return count; +} + +int X_SendInputNotification(xEvent *data, xwindow_t *window, unsigned int mask) +{ + int count=0; + xclient_t *cl; + xnotificationmask_t *nm; + + xwindow_t *child = window; + xwindow_t *focus; + + //we go all the way to the root if needed. + + for (cl = xclients; cl; cl = cl->nextclient) + { + //don't send to if... + if (cl->stillinitialising) + continue; + if (cl->tobedropped) + continue; + if (cl->outbufferlen > MAXREQUESTSIZE*4) + { + cl->tobedropped = true; + continue; + } + window = child->parent; + + for (window = child; window; window = window->parent) + { + for (nm = window->notificationmask; nm; nm = nm->next) + { + if (nm->client != cl) + continue; + if (!(nm->mask & mask)) + continue; + + Con_Printf("Sending input %i\n", data->u.u.type); + + if (data->u.u.type == FocusIn || data->u.u.type == FocusOut) + { + data->u.u.sequenceNumber = cl->requestnum; + X_SendData(cl, data, sizeof(xEvent)); + count++; + break; + } + + data->u.keyButtonPointer.event = window->res.id; //so the request/notification/whatever knows who asked for it. + data->u.keyButtonPointer.eventX = data->u.keyButtonPointer.rootX; + data->u.keyButtonPointer.eventY = data->u.keyButtonPointer.rootY; + for (window = window; window; window = window->parent) //adjust event's xpos/ypos + { + data->u.keyButtonPointer.eventX -= window->xpos; + data->u.keyButtonPointer.eventY -= window->ypos; + } + + if (data->u.u.type == EnterNotify || data->u.u.type == LeaveNotify) + { + data->u.enterLeave.flags &= ~ELFlagFocus; + + focus = xfocusedwindow; + while(focus) + { + if (focus->res.id == data->u.enterLeave.event) + { + data->u.enterLeave.flags |= ELFlagFocus; + break; + } + focus = focus->parent; + } + } + + data->u.u.sequenceNumber = cl->requestnum; + if (data->u.keyButtonPointer.event == data->u.keyButtonPointer.child) + { + data->u.keyButtonPointer.child = None; + X_SendData(cl, data, sizeof(xEvent)); + data->u.keyButtonPointer.child = data->u.keyButtonPointer.event; + } + else + X_SendData(cl, data, sizeof(xEvent)); + count++; + break; + } + if (nm || (window->donotpropagate & mask)) + break; + } + } + return count; +} + +void X_SendError(xclient_t *cl, int errorcode, int assocresource, int major, int minor) +{ + xError err; + err.type = X_Error; + err.errorCode = errorcode; + err.sequenceNumber = cl->requestnum; /* the nth request from this client */ + err.resourceID = assocresource; + err.minorCode = minor; + err.majorCode = major; + err.pad1 = 0; + err.pad3 = 0; + err.pad4 = 0; + err.pad5 = 0; + err.pad6 = 0; + err.pad7 = 0; + + X_SendData(cl, &err, sizeof(err)); +} + +int X_NewRIDBase(void) +{ + xclient_t *cl; + int ridbase = 0x200000; + while(ridbase) //it'll wrap at some point... + { + for (cl = xclients; cl; cl = cl->nextclient) + { + if (cl->ridbase == ridbase) //someone has this range... + { + ridbase+=0x200000; + break; + } + } + if (!cl) + return ridbase; + } + + //err... bugger... that could be problematic... + //try again, but start allocating half quantities and hope a client drops soon... + + ridbase = 0x200000; + while(ridbase) + { + for (cl = xclients; cl; cl = cl->nextclient) + { + if (cl->ridbase == ridbase) //someone has this range... + { + ridbase+=0x100000; + break;; + } + } + if (!cl) + return ridbase; + } + + if (ridbase) + return ridbase; + + return 0; +} + +void X_SendIntialResponse(xclient_t *cl) +{ + int rid; + char buffer[8192]; + xConnSetupPrefix *prefix; + xConnSetup *setup; + char *vendor; + xPixmapFormat *pixmapformats; + xnotificationmask_t *nm; + + xWindowRoot *root; + xDepth *depth; + xVisualType *visualtype; + + rid = X_NewRIDBase(); + cl->ridbase = rid; + + if (!rid) + { + prefix = (xConnSetupPrefix *)buffer; + prefix->success = 0; + prefix->lengthReason = 22; + prefix->majorVersion = 11; //protocol version. + prefix->minorVersion = 0; + prefix->length = (prefix->lengthReason/4+3)&~3; + strcpy((char *)(prefix+1), "No free resource range"); + X_SendData(cl, prefix, sizeof(prefix)+(prefix->length+1)*4); + cl->tobedropped = true; + } + else + { + prefix = (xConnSetupPrefix *)buffer; + prefix->success = 1; + prefix->lengthReason = 0; + prefix->majorVersion = 11; //protocol version. + prefix->minorVersion = 0; + + setup = (xConnSetup *)(prefix+1); + setup->release = build_number(); //our version number + setup->ridBase = rid; + setup->ridMask = 0x1fffff; + setup->motionBufferSize = 1; + setup->maxRequestSize = MAXREQUESTSIZE; + setup->numRoots = 1; //we only have one display. so only one root window please. + setup->imageByteOrder = LSBFirst; /* LSBFirst, MSBFirst */ + setup->bitmapBitOrder = LSBFirst; /* LeastSignificant, MostSign...*/ + setup->bitmapScanlineUnit = 32, /* 8, 16, 32 */ + setup->bitmapScanlinePad = 32; /* 8, 16, 32 */ + setup->minKeyCode = 1; + setup->maxKeyCode = 255; + + vendor = (char *)(setup+1); + strcpy(vendor, "FTE QuakeWorld X"); + setup->nbytesVendor = (strlen(vendor)+3)&~3; + + pixmapformats = (xPixmapFormat *)(vendor + setup->nbytesVendor); + setup->numFormats = 0; + + /* pixmapformats[setup->numFormats].depth = 16; + pixmapformats[setup->numFormats].bitsPerPixel = 16; + pixmapformats[setup->numFormats].scanLinePad = 16; + pixmapformats[setup->numFormats].pad1=0; + pixmapformats[setup->numFormats].pad2=0; + setup->numFormats++;*/ + + pixmapformats[setup->numFormats].depth = 24; + pixmapformats[setup->numFormats].bitsPerPixel = 32; + pixmapformats[setup->numFormats].scanLinePad = 32; + pixmapformats[setup->numFormats].pad1=0; + pixmapformats[setup->numFormats].pad2=0; + setup->numFormats++; + + root = (xWindowRoot *)(pixmapformats + setup->numFormats); + root->windowId = rootwindow->res.id; + root->defaultColormap = 32; + root->whitePixel = 0xffffff; + root->blackPixel = 0; + root->currentInputMask = 0; + for (nm = rootwindow->notificationmask; nm; nm = nm->next) + root->currentInputMask |= nm->mask; + root->pixWidth = rootwindow->width; + root->pixHeight = rootwindow->height; + root->mmWidth = rootwindow->width/3; + root->mmHeight = rootwindow->height/3; + root->minInstalledMaps = 1; + root->maxInstalledMaps = 1; + root->rootVisualID = 0x22; + root->backingStore = 0; + root->saveUnders = false; + root->rootDepth = 24; + root->nDepths = 0; + + depth = (xDepth*)(root + 1); + depth->depth = 24; + depth->pad1 = 0; + depth->nVisuals = 1; + depth->pad2 = 0; + root->nDepths++; + + visualtype = (xVisualType*)(depth+1); + visualtype->visualID = root->rootVisualID; + visualtype->class = TrueColor; + visualtype->bitsPerRGB = 24; + visualtype->colormapEntries = 256; + visualtype->redMask = 0x0000ff; + visualtype->greenMask = 0x00ff00; + visualtype->blueMask = 0xff0000; + visualtype->pad = 0; + + visualtype++; + prefix->length = ((char *)visualtype - (char *)setup)/4; + + X_SendData(cl, prefix, (char *)visualtype - (char *)prefix); + } +} + + + + + + +qboolean XWindows_TendToClient(xclient_t *cl) //true says drop +{ + int err; + int len; + unsigned int inlen; + char *input; + + if (!xgrabbedclient || xgrabbedclient == cl) //someone grabbed the server + if (cl->outbufferlen < 256 && !cl->tobedropped) //don't accept new messages if we still have a lot to write. + { +#ifdef MULTITHREADWIN32 + if (!cl->threadhandle) +#endif + { + if (cl->inbuffermaxlen - cl->inbufferlen < 1000) //do we need to expand this message? + { + char *newbuffer; + cl->inbuffermaxlen += 1000; + newbuffer = malloc(cl->inbuffermaxlen); + if (cl->inbuffer) + { + memcpy(newbuffer, cl->inbuffer, cl->inbufferlen); + free(cl->inbuffer); + } + cl->inbuffer = newbuffer; + } + len = cl->inbuffermaxlen - cl->inbufferlen; +Con_Printf("recving\n"); + len = recv(cl->socket, cl->inbuffer + cl->inbufferlen, len, 0); +Con_Printf("recved %i\n", len); + if (len == 0) //connection was closed. bummer. + { +Con_Printf("Closed\n"); + return true; + } + if (len > 0) + { + cl->inbufferlen += len; + } + else + { + err = qerrno; + if (err != EWOULDBLOCK) + { + Con_Printf("X read error %i\n", err); + cl->tobedropped = true; + } + } + } +#ifdef MULTITHREADWIN32 + else + EnterCriticalSection(&cl->delecatesection); +#endif + +// if (len > 0) //the correct version + if (cl->inbufferlen > 0) //temp + { + input = cl->inbuffer; +nextmessage: + inlen = cl->inbufferlen - (input - cl->inbuffer); + if (cl->stillinitialising) + { + if (inlen >= sizeof(xConnClientPrefix)) + { + xConnClientPrefix *prefix = (xConnClientPrefix *)input; + input += sizeof(xConnClientPrefix); + cl->stillinitialising = false; + if (prefix->byteOrder != 'l') //egad no. horrible. + { +#ifdef MULTITHREADWIN32 + LeaveCriticalSection(&cl->delecatesection); +#endif + return true; + } + if (prefix->majorVersion != 11) //x11 only. Sorry. + { +#ifdef MULTITHREADWIN32 + LeaveCriticalSection(&cl->delecatesection); +#endif + return true; + } + if (prefix->minorVersion != 0) //we don't know of any variations. + { +#ifdef MULTITHREADWIN32 + LeaveCriticalSection(&cl->delecatesection); +#endif + return true; + } + if (prefix->nbytesAuthProto != 0) //we can't handle this + { +#ifdef MULTITHREADWIN32 + LeaveCriticalSection(&cl->delecatesection); +#endif + return true; + } + if (prefix->nbytesAuthString != 0) //we can't handle this + { +#ifdef MULTITHREADWIN32 + LeaveCriticalSection(&cl->delecatesection); +#endif + return true; + } + X_SendIntialResponse(cl); + goto nextmessage; + } + } + else if (inlen >= sizeof(xReq)) + { + int rlen; + xReq *req; + req = (xReq *)input; + + rlen = req->length; + if (!rlen && inlen >= sizeof(xReq)+sizeof(CARD32)) //BIG-REQUESTS says that if the length of a request is 0, then there's an extra 32bit int with the correct length imediatly after the 0. + rlen = *(CARD32 *)(req+1); + if (rlen && inlen >= rlen*4) + { + cl->requestnum++; + + if (req->reqType < 0 || req->reqType >= 256 || !XRequests[req->reqType]) + { + // Con_Printf("X request %i, len %i - NOT SUPPORTED\n", req->reqType, rlen*4); + + //this is a minimal implementation... + X_SendError(cl, BadImplementation, 0, req->reqType, 0); +// cl->tobedropped = true; + } + else + { +// Con_Printf("X request %i, len %i\n", req->reqType, rlen*4); + +//Con_Printf("Request %i\n", req->reqType); +// Z_CheckSentinals(); + if (!req->length) + { + int rt, data; + + rt = req->reqType; //save these off + data = req->data; + + req = (xReq *)((char *)req+sizeof(CARD32)); //adjust correctly. + + req->reqType = rt; //and restore them into the space taken by the longer size. + req->data = data; + req->length = 0; //Don't rely on this. This isn't really needed. + + XRequests[req->reqType](cl, req); + } + else + XRequests[req->reqType](cl, req); +// Z_CheckSentinals(); +//Con_Printf("Done request\n"); + } + + input += rlen*4; + + goto nextmessage; + } + } + + len = input - cl->inbuffer; + memmove(cl->inbuffer, input, cl->inbufferlen - len); + cl->inbufferlen -= len; + } +#ifdef MULTITHREADWIN32 + if (cl->threadhandle) + LeaveCriticalSection(&cl->delecatesection); +#endif + } + + if (cl->outbufferlen) //still send if grabbed. don't let things build up this side. + { +#ifdef MULTITHREADWIN32 + if (!cl->threadhandle) +#endif + { + len = cl->outbufferlen; + if (len > 8000) + len = 8000; + len = send(cl->socket, cl->outbuffer, len, 0); + if (len>0) + { + memmove(cl->outbuffer, cl->outbuffer+len, cl->outbufferlen - len); + cl->outbufferlen -= len; + } + if (len == 0) + cl->tobedropped = true; + if (len < 0) + { + err = qerrno; + if (err != EWOULDBLOCK) + { + Con_Printf("X send error %i\n", err); + cl->tobedropped = true; + } + } + } + } + else if ((!xgrabbedclient || xgrabbedclient == cl) && cl->tobedropped) + return true; //grabbed servers do not allow altering state if a client drops + return false; +} + +#ifdef MULTITHREAD + +#ifdef _WIN32 +DWORD WINAPI X_RunClient(void *parm) +#else +void X_RunClient(void *parm) +#endif +{ + char buffer[8192*64]; + int read, len, err; + xclient_t *cl = parm; + + while(cl->threadhandle) + { + if (cl->tobedropped) + { //don't bother reading more. + read = 0; + } + else + { + read = recv(cl->socket, buffer, sizeof(buffer), 0); + if (read<0 && !cl->outbufferlen) + { + if (qerrno != EWOULDBLOCK) + cl->tobedropped = true; + else + { + Sleep(1); + continue; + } + } + } + +#ifdef MULTITHREADWIN32 + EnterCriticalSection(&cl->delecatesection); +#endif + + if (read > 0) + { + if (cl->inbuffermaxlen < cl->inbufferlen+read) //expand in buffer + { + cl->inbuffermaxlen = cl->inbufferlen+read + 1000; //add breathing room. + cl->inbuffer = realloc(cl->inbuffer, cl->inbuffermaxlen); + } + memcpy(cl->inbuffer+cl->inbufferlen, buffer, read); + cl->inbufferlen += read; + } + else if (!read) //no more socket. + cl->tobedropped = true; + else + { //error of some sort + err = qerrno; + if (err != EWOULDBLOCK) + cl->tobedropped = true; + } + + if (cl->outbufferlen) + { + len = cl->outbufferlen; + if (len > 8000) + len = 8000; + len = send(cl->socket, cl->outbuffer, len, 0); //move out of critical section? + if (len>0) + { + memmove(cl->outbuffer, cl->outbuffer+len, cl->outbufferlen - len); + cl->outbufferlen -= len; + } + if (len == 0) + { + cl->tobedropped = true; + cl->outbufferlen=0; + } + if (len < 0) + { + err = qerrno; + if (err != EWOULDBLOCK) + { + cl->tobedropped = true; + cl->outbufferlen=0; + } + } + } + +#ifdef MULTITHREADWIN32 + LeaveCriticalSection(&cl->delecatesection); +#endif + } + + DeleteCriticalSection (&cl->delecatesection); + + closesocket(cl->socket); + if (cl->inbuffer) + free(cl->inbuffer); + if (cl->outbuffer) + free(cl->outbuffer); + free(cl); + +#ifdef MULTITHREADWIN32 + return 0; +#endif +} + +#endif + +void XWindows_TendToClients(void) +{ + struct sockaddr_in address; + int addrlen; + xclient_t *cl, *prev=NULL; + int newclient; + unsigned int _true = 1; + + if (xlistensocket != -1) + { + addrlen = sizeof(address); + newclient = accept(xlistensocket, (struct sockaddr *)&address, &addrlen); + if (newclient != -1) + { + cl = malloc(sizeof(xclient_t)); + memset(cl, 0, sizeof(xclient_t)); + cl->socket = newclient; + cl->nextclient = xclients; + cl->stillinitialising = 1; + xclients = cl; + + +#ifdef MULTITHREADWIN32 + InitializeCriticalSection (&cl->delecatesection); + {int tid; + cl->threadhandle = CreateThread(NULL, 0, X_RunClient, cl, 0, &tid); + } + + if (!cl->threadhandle) + DeleteCriticalSection (&cl->delecatesection); +#else + if (ioctlsocket(cl->socket, FIONBIO, &_true) == -1) + Sys_Error("Nonblocking failed\n"); +#endif + } + } + + for (cl = xclients; cl; cl = cl->nextclient) + { + if (XWindows_TendToClient(cl)) + { + if (prev) + { + prev->nextclient = cl->nextclient; + } + else + xclients = cl->nextclient; + + XS_DestroyResourcesOfClient(cl); + +#ifdef MULTITHREADWIN32 + if (cl->threadhandle) + { + cl->threadhandle = NULL; + break; + } +#endif + closesocket(cl->socket); + if (cl->inbuffer) + free(cl->inbuffer); + if (cl->outbuffer) + free(cl->outbuffer); + free(cl); + break; + } + + prev = cl; + } +} + +void XWindows_Startup(void) //initialise the server socket and do any initial setup as required. +{ + struct sockaddr_in address; + unsigned long _true = true; + + int port = 6000; + + port += atoi(Cmd_Argv(1)); + + if (xlistensocket == -1) + { + if ((xlistensocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) + { + Con_Printf("Failed to create socket\n"); + return; + } + if (ioctlsocket (xlistensocket, FIONBIO, &_true) == -1) + { + closesocket(xlistensocket); + Con_Printf("Failed to create socket\n"); + xlistensocket = -1; + return; + } + + address.sin_family = AF_INET; + address.sin_addr.s_addr = INADDR_ANY; + + if (port == PORT_ANY) + address.sin_port = 0; + else + address.sin_port = htons((short)port); + + if( bind (xlistensocket, (void *)&address, sizeof(address)) == -1) + { + Con_Printf("Couldn't bind socket to port %i\n", port); + closesocket(xlistensocket); + xlistensocket = -1; + return; + } + if( listen (xlistensocket, 3) == -1) + { + Con_Printf("Couldn't listen on port %i\n", port); + closesocket(xlistensocket); + xlistensocket = -1; + return; + } + + X_InitRequests(); + XS_CreateInitialResources(); + } + + //quakie stuph + key_dest = key_menu; + m_state = m_xwindows; + m_entersound = true; +} + +extern int x_windowwithfocus; +extern int x_windowwithcursor; +void XWindows_RefreshWindow(xwindow_t *wnd) +{ + xwindow_t *p; + short xpos; + short ypos; + unsigned int *out, *in; + + int x, y; + int maxx, maxy; + + if (wnd->inputonly) //no thanks. + return; + + xpos = 0; + ypos = 0; + for (p = wnd->parent; p; p = p->parent) + { + xpos += p->xpos; + ypos += p->ypos; + } + + y = ypos + wnd->ypos; + maxy = y + wnd->height; + if (y < ypos+wnd->ypos) + { + y = ypos+wnd->ypos; + } + if (y < 0) + y = 0; + if (maxy >= xscreenheight) + maxy = xscreenheight-1; + + if (!wnd->mapped)//&&rand()&1) + { //unmapped windows are invisible. + return; + } + + + { + if (wnd->buffer)// && x_windowwithfocus != wnd->res.id) + { + for (; y < maxy; y++) + { + x = xpos + wnd->xpos; + maxx = x + wnd->width; + if (x < xpos+wnd->xpos) + { + x = xpos+wnd->xpos; + } + if (x < 0) + x = 0; + if (maxx > xscreenwidth) + maxx = xscreenwidth; + + out = (unsigned int *)xscreen + (x+(y*xscreenwidth)); + in = (unsigned int *)wnd->buffer + (x-xpos-wnd->xpos) + (y-ypos-wnd->ypos)*wnd->width; + + for (; x < maxx; x++) + { + *out++ = *in++; + } + } + } + else + { + + + for (; y < maxy; y++) + { + x = xpos + wnd->xpos; + maxx = x + wnd->width; + if (x < xpos+wnd->xpos) + { + x = xpos+wnd->xpos; + } + if (x < 0) + { + x = 0; + } + if (maxx > xscreenwidth) + maxx = xscreenwidth; + + out = (unsigned int *)xscreen + (x+(y*xscreenwidth)); + + for (; x < maxx; x++) + { + *out++ = wnd->backpixel; + } + } + } + } + + wnd = wnd->child; + while(wnd) + { + XWindows_RefreshWindow(wnd); + wnd = wnd->sibling; + } +} +/* +void XWindows_DrawWindowTree(xwindow_t *wnd, short xofs, short yofs) +{ + int x, y; + int maxx, maxy; + unsigned int *out; + + if (wnd->res.owner) + { + y = yofs + wnd->ypos; + maxy = y + wnd->width; + if (y < 0) + { + y = 0; + } + if (maxy >= xscreenheight) + maxy = xscreenheight-1; + for (y = 0; y < wnd->height; y++) + { + x = xofs + wnd->xpos; + maxx = x + wnd->height; + if (x < 0) + { + x = 0; + } + if (maxx >= xscreenwidth) + maxx = xscreenwidth-1; + + out = (unsigned int *)xscreen + (x+(y*xscreenwidth)); + + for (; x < maxx; x++) + { + *out = rand(); + out++; + } + } + } + + xofs += wnd->xpos; + yofs += wnd->ypos; + + wnd = wnd->child; + while(wnd) + { + XWindows_DrawWindowTree(wnd, xofs, yofs); + wnd = wnd->sibling; + } +} +*/ + +//quakie functions +void XWindows_Init(void) +{ + Cmd_AddCommand("x", XWindows_Startup); +} + +int x_mousex; +int x_mousey; +int x_windowwithcursor; +int x_windowwithfocus; + +int mousestate; + +void X_EvalutateCursorOwner(int movemode) +{ + xEvent ev; + xwindow_t *cursorowner, *wnd, *use; + int mx, my; + int wcx; + int wcy; + + extern xwindow_t *xpgrabbedwindow, *xpconfinewindow; + + { + extern int mousecursor_x, mousecursor_y; + mx = mousecursor_x * ((float)rootwindow->width/vid.width); + my = mousecursor_y * ((float)rootwindow->height/vid.height); + } + if (mx >= xscreenwidth) + mx = xscreenwidth-1; + if (my >= xscreenheight) + my = xscreenheight-1; + if (mx < 0) + mx = 0; + if (my < 0) + my = 0; + + if (xpconfinewindow) //don't leave me! + { + cursorowner = xpconfinewindow; + + wcx = 0; wcy = 0; + + for (wnd = cursorowner; wnd; wnd = wnd->parent) + { + wcx += wnd->xpos; + wcy += wnd->ypos; + } + + if (movemode == NotifyNormal) + movemode = NotifyWhileGrabbed; + } + else + { + cursorowner = rootwindow; + wcx = 0; wcy = 0; + while(1) + { + use = NULL; + //find the last window that contains the pointer (lower windows come first) + for (wnd = cursorowner->child; wnd; wnd = wnd->sibling) + { + if (/*!wnd->inputonly && */wnd->mapped) + if (wcx+wnd->xpos <= mx && wcx+wnd->xpos+wnd->width >= mx) + { + if (wcy+wnd->ypos <= my && wcy+wnd->ypos+wnd->height >= my) + { + use = wnd; + } + } + } + wnd = use; + + if (wnd) + { + cursorowner = wnd; + wcx += wnd->xpos; + wcy += wnd->ypos; + continue; + } + break; + } + } + + if (mx != x_mousex || my != x_mousey || x_windowwithcursor != cursorowner->res.id) + { + extern qboolean keydown[256]; + +// Con_Printf("move %i %i\n", mx, my); + + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.keyButtonPointer.time = Sys_DoubleTime()*1000; + ev.u.keyButtonPointer.root = rootwindow->res.id; + ev.u.keyButtonPointer.child = None; + ev.u.keyButtonPointer.rootX = mx; + ev.u.keyButtonPointer.rootY = my; + ev.u.keyButtonPointer.state = mousestate; + if (cursorowner->res.id != x_windowwithcursor) //changed window + { + xwindow_t *a,*b; + int d1,d2; + + if (XS_GetResource(x_windowwithcursor, &wnd) != x_window) + wnd = rootwindow; + + x_windowwithcursor = cursorowner->res.id; + + //count how deep the windows are + for (a = wnd,d1=0; a; a = a->parent) + d1++; + for (b = cursorowner,d2=0; b; b = b->parent) + d2++; + + a = wnd; + b = cursorowner; + + if (d1>d2) + { + while(d1>d2) //a is too deep + { + a = a->parent; + d1--; + } + } + else + { + while(d2>d1) + { + b = b->parent; + d2--; + } + } + while(a != b) //find the common ancestor. + { + a = a->parent; + b = b->parent; + } + + ev.u.enterLeave.mode = movemode; + ev.u.enterLeave.flags = ELFlagSameScreen; /* sameScreen and focus booleans, packed together */ + + //the cursor moved from a to b via: +// if (!a) //changed screen... +// { +// } else + if (a != wnd && b != cursorowner) + { //changed via a common root, indirectly. + +//o LeaveNotify with detail Nonlinear is generated on A. + + ev.u.u.type = LeaveNotify; + ev.u.u.detail = NotifyNonlinear; + ev.u.keyButtonPointer.child = wnd->res.id; + X_SendInputNotification(&ev, wnd, LeaveWindowMask); + +//o LeaveNotify with detail NonlinearVirtual is generated +// on each window between A and C exclusive (in that +// order). + + for (a = wnd->parent; a != b; a = a->parent) + { + ev.u.u.type = LeaveNotify; + ev.u.u.detail = NotifyNonlinearVirtual; + ev.u.keyButtonPointer.child = a->res.id; + X_SendInputNotification(&ev, a, LeaveWindowMask); + } + +//o EnterNotify with detail NonlinearVirtual is generated +// on each window between C and B exclusive (in that +// order). + + for (; b != cursorowner; ) + { + for (a = cursorowner; ; a = a->parent) //we need to go through the children. + { + if (a->parent == b) + { + b = a; + break; + } + } + if (b == cursorowner) + break; + + ev.u.u.type = EnterNotify; + ev.u.u.detail = NotifyNonlinearVirtual; + ev.u.keyButtonPointer.child = a->res.id; + X_SendInputNotification(&ev, a, EnterWindowMask); + } + +//o EnterNotify with detail Nonlinear is generated on B. + + ev.u.u.type = EnterNotify; + ev.u.u.detail = NotifyNonlinear; + ev.u.keyButtonPointer.child = cursorowner->res.id; + X_SendInputNotification(&ev, cursorowner, EnterWindowMask); + } + else if (a == wnd) + { //b is a child of a + +//o LeaveNotify with detail Inferior is generated on A. + + ev.u.u.type = LeaveNotify; + ev.u.u.detail = NotifyInferior; + ev.u.keyButtonPointer.child = wnd->res.id; + X_SendInputNotification(&ev, wnd, LeaveWindowMask); + +//o EnterNotify with detail Virtual is generated on each +// window between A and B exclusive (in that order). + + if (wnd != cursorowner) + for (b = wnd; ; ) + { + for (a = cursorowner; ; a = a->parent) //we need to go through the children. + { + if (a->parent == b) + { + b = a; + break; + } + } + if (b == cursorowner) + break; + + ev.u.u.type = EnterNotify; + ev.u.u.detail = NotifyVirtual; + ev.u.keyButtonPointer.child = b->res.id; + X_SendInputNotification(&ev, b, EnterWindowMask); + } + +//o EnterNotify with detail Ancestor is generated on B. + + ev.u.u.type = EnterNotify; + ev.u.u.detail = NotifyAncestor; + ev.u.keyButtonPointer.child = cursorowner->res.id; + X_SendInputNotification(&ev, cursorowner, EnterWindowMask); + } + else// if (b == cursorowner) + { //a is a child of b + +//o LeaveNotify with detail Ancestor is generated on A. + + ev.u.u.type = LeaveNotify; + ev.u.u.detail = NotifyAncestor; + ev.u.keyButtonPointer.child = wnd->res.id; + X_SendInputNotification(&ev, wnd, LeaveWindowMask); + +//o LeaveNotify with detail Virtual is generated on each +// window between A and B exclusive (in that order). + + for (b = wnd; ; ) + { + b = b->parent; + if (b == cursorowner) + break; + + ev.u.u.type = LeaveNotify; + ev.u.u.detail = NotifyVirtual; + ev.u.keyButtonPointer.child = b->res.id; + X_SendInputNotification(&ev, b, LeaveWindowMask); + } + + +//o EnterNotify with detail Inferior is generated on B. + + ev.u.u.type = EnterNotify; + ev.u.u.detail = NotifyInferior; + ev.u.keyButtonPointer.child = cursorowner->res.id; + X_SendInputNotification(&ev, cursorowner, EnterWindowMask); + } + + { + char title[1024]; + Atom type; + int extrabytes; + int format; + while(cursorowner) + { + title[XS_GetProperty(cursorowner, 39, &type, title, sizeof(title), 0, &extrabytes, &format)] = '\0'; + if (*title) + break; + cursorowner = cursorowner->parent; + } + Con_Printf("Entered \"%s\"\n", title); + } + } + + { //same window + ev.u.keyButtonPointer.child = x_windowwithcursor; + + if (XS_GetResource(x_windowwithcursor, &wnd) == x_window) + { //cursor still in the same child. + int mask = PointerMotionMask; + if (mousestate) + mask |= ButtonMotionMask; + if (mousestate & Button1Mask) + mask |= Button1MotionMask; + if (mousestate & Button2Mask) + mask |= Button2MotionMask; + if (mousestate & Button3Mask) + mask |= Button3MotionMask; + if (mousestate & Button4Mask) + mask |= Button4MotionMask; + if (mousestate & Button5Mask) + mask |= Button5MotionMask; + ev.u.u.type = MotionNotify; + X_SendInputNotification(&ev, wnd, mask); + } + } + + x_mousex = mx; + x_mousey = my; + } +} + +void X_EvalutateFocus(int movemode) +{ + xEvent ev; + xwindow_t *fo, *po, *wnd; + + if (XS_GetResource(x_windowwithcursor, &po) != x_window) + po = rootwindow; + +// xfocusedwindow = NULL; + + + if (!xfocusedwindow) + { + if (XS_GetResource(x_windowwithcursor, &fo) != x_window) + fo = rootwindow; + } + else + { + fo = xfocusedwindow; + } + + if (x_windowwithfocus != fo->res.id) + { + extern qboolean keydown[256]; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.focus.mode = movemode; + { + xwindow_t *a,*b; + int d1,d2; + + if (XS_GetResource(x_windowwithfocus, &wnd) != x_window) + wnd = rootwindow; + + x_windowwithfocus = fo->res.id; + + //count how deep the windows are + for (a = wnd,d1=0; a; a = a->parent) + d1++; + for (b = fo,d2=0; b; b = b->parent) + d2++; + + a = wnd; + b = fo; + + if (d1>d2) + { + while(d1>d2) //a is too deep + { + a = a->parent; + d1--; + } + } + else + { + while(d2>d1) + { + b = b->parent; + d2--; + } + } + while(a != b) //find the common ancestor. + { + a = a->parent; + b = b->parent; + } + + ev.u.enterLeave.mode = movemode; + ev.u.enterLeave.flags = ELFlagSameScreen; /* sameScreen and focus booleans, packed together */ + + //the cursor moved from a to b via: +// if (!a) //changed screen... +// { +// } else + if (a != wnd && b != fo) + { //changed via a common root, indirectly. + +//When the focus moves from window A to window B, window C is +//their least common ancestor, and the pointer is in window P: + +//o If P is an inferior of A, FocusOut with detail Pointer +// is generated on each window from P up to but not +// including A (in order). + + //FIXME + +//o FocusOut with detail Nonlinear is generated on A. + + ev.u.u.type = FocusOut; + ev.u.u.detail = NotifyNonlinear; + ev.u.focus.window = wnd->res.id; + X_SendInputNotification(&ev, wnd, FocusChangeMask); + + + + +//o FocusOut with detail NonlinearVirtual is generated on +// each window between A and C exclusive (in order). + + for (a = wnd->parent; a != b; a = a->parent) + { + ev.u.u.type = FocusOut; + ev.u.u.detail = NotifyNonlinearVirtual; + ev.u.focus.window = a->res.id; + X_SendInputNotification(&ev, a, FocusChangeMask); + } + +//o FocusIn with detail NonlinearVirtual is generated on +// each window between C and B exclusive (in order). + + for (; b != fo; ) + { + ev.u.u.type = FocusIn; + ev.u.u.detail = NotifyNonlinearVirtual; + ev.u.focus.window = a->res.id; + X_SendInputNotification(&ev, a, FocusChangeMask); + + for (a = fo; ; a = a->parent) //we need to go through the children. + { + if (a->parent == b) + { + b = a; + break; + } + } + } + +//o FocusIn with detail Nonlinear is generated on B. + + ev.u.u.type = FocusIn; + ev.u.u.detail = NotifyNonlinear; + ev.u.focus.window = fo->res.id; + X_SendInputNotification(&ev, fo, FocusChangeMask); + +//o If P is an inferior of B, FocusIn with detail Pointer +// is generated on each window below B down to and includ- +// ing P (in order). + + + //FIXME: + + } + else if (a == wnd) + { //b is a child of a + +//When the focus moves from window A to window B, B is an +//inferior of A, and the pointer is in window P: + +//o If P is an inferior of A but P is not an inferior of B +// or an ancestor of B, FocusOut with detail Pointer is +// generated on each window from P up to but not including +// A (in order). + + //FIXME + +//o FocusOut with detail Inferior is generated on A. + + ev.u.u.type = FocusOut; + ev.u.u.detail = NotifyInferior; + ev.u.focus.window = wnd->res.id; + X_SendInputNotification(&ev, wnd, FocusChangeMask); + +//o FocusIn with detail Virtual is generated on each window +// between A and B exclusive (in order). + + if (wnd != fo) + for (b = wnd; ; ) + { + for (a = fo; ; a = a->parent) //we need to go through the children. + { + if (a->parent == b) + { + b = a; + break; + } + } + if (b == fo) + break; + + ev.u.u.type = FocusIn; + ev.u.u.detail = NotifyVirtual; + ev.u.focus.window = b->res.id; + X_SendInputNotification(&ev, b, FocusChangeMask); + } + +//o FocusIn with detail Ancestor is generated on B. + + ev.u.u.type = FocusIn; + ev.u.u.detail = NotifyAncestor; + ev.u.focus.window = fo->res.id; + X_SendInputNotification(&ev, fo, FocusChangeMask); + } + else// if (b == cursorowner) + { //a is a child of b + +//When the focus moves from window A to window B, A is an +//inferior of B, and the pointer is in window P: + +//o FocusOut with detail Ancestor is generated on A. + + ev.u.u.type = FocusOut; + ev.u.u.detail = NotifyAncestor; + ev.u.focus.window = wnd->res.id; + X_SendInputNotification(&ev, wnd, FocusChangeMask); + +//o FocusOut with detail Virtual is generated on each win- +// dow between A and B exclusive (in order). + + for (b = wnd; ; ) + { + b = b->parent; + if (b == fo) + break; + + ev.u.u.type = FocusOut; + ev.u.u.detail = NotifyVirtual; + ev.u.focus.window = a->res.id; + X_SendInputNotification(&ev, a, FocusChangeMask); + } + + +//o FocusIn with detail Inferior is generated on B. + + ev.u.u.type = FocusIn; + ev.u.u.detail = NotifyInferior; + ev.u.focus.window = fo->res.id; + X_SendInputNotification(&ev, fo, FocusChangeMask); + +//o If P is an inferior of B but P is not A or an inferior +// of A or an ancestor of A, FocusIn with detail Pointer +// is generated on each window below B down to and includ- +// ing P (in order). + + //FIXME: code missing + } + } + } +} + +void XWindows_Draw(void) +{ + { + X_EvalutateCursorOwner(NotifyNormal); + } + + XWindows_TendToClients(); + +/* if (rand()&15 == 15) + xrefreshed = true;*/ + +// memset(xscreen, 0, xscreenwidth*4*xscreenheight); + + XWindows_TendToClients(); + +// XW_ExposeWindow(rootwindow, 0, 0, rootwindow->width, rootwindow->height); + +// XWindows_DrawWindowTree(rootwindow, 0, 0); + if (xrefreshed) + { + XWindows_RefreshWindow(rootwindow); + xrefreshed = false; +// Con_Printf("updated screen\n"); + } + + { + unsigned int *out = (unsigned int *)xscreen + (x_mousex+(x_mousey*xscreenwidth)); + *out = rand(); +// out[64] = rand(); + } + + XWindows_TendToClients(); + Media_ShowFrame(xscreen, xscreenwidth, xscreenheight, NULL); + + Con_DrawNotify(); + + XWindows_TendToClients(); +} + +void XWindows_Key(int key) +{ + extern qboolean keydown[256]; + if (key == 'q' || (key == K_BACKSPACE && keydown[K_CTRL] && keydown[K_ALT])) //kill off the server + { + m_state = m_none; + key_dest = key_game; + + closesocket(xlistensocket); + xlistensocket = -1; + } + + + + { + xEvent ev; + xwindow_t *wnd; + + X_EvalutateCursorOwner(NotifyNormal); + + X_EvalutateFocus(NotifyNormal); + + if (key >= K_MOUSE1 && key <= K_MOUSE5) + { + ev.u.u.type = ButtonPress; + switch(key) + { + case K_MOUSE1: + ev.u.u.detail = 1; + mousestate |= Button1Mask; + break; + + case K_MOUSE3: + ev.u.u.detail = 2; + mousestate |= Button2Mask; + break; + + case K_MOUSE2: + ev.u.u.detail = 3; + mousestate |= Button3Mask; + break; + + case K_MOUSE4: + ev.u.u.detail = 4; + mousestate |= Button4Mask; + break; + + default: + ev.u.u.detail = 5; + mousestate |= Button5Mask; + break; + } + ev.u.keyButtonPointer.state = mousestate; + ev.u.keyButtonPointer.child = x_windowwithcursor; + } + else + { + ev.u.u.type = KeyPress; + ev.u.u.detail = key; + ev.u.keyButtonPointer.state = 0; + ev.u.keyButtonPointer.child = x_windowwithfocus; + } + ev.u.u.sequenceNumber = 0; + ev.u.keyButtonPointer.time = Sys_DoubleTime()*1000; + ev.u.keyButtonPointer.rootX = x_mousex; + ev.u.keyButtonPointer.rootY = x_mousey; + ev.u.keyButtonPointer.sameScreen= true; + ev.u.keyButtonPointer.pad1 = 0; + +// Con_Printf("key %i, %i %i\n", key, x_mousex, x_mousey); + + if (xpointergrabclient) + { + ev.u.keyButtonPointer.event = ev.u.keyButtonPointer.child; + ev.u.keyButtonPointer.eventX = ev.u.keyButtonPointer.rootX; + ev.u.keyButtonPointer.eventY = ev.u.keyButtonPointer.rootY; + if (XS_GetResource(x_windowwithcursor, &wnd) == x_window) + { + ev.u.u.sequenceNumber = xpointergrabclient->requestnum; + while(wnd) + { + ev.u.keyButtonPointer.eventX -= wnd->xpos; + ev.u.keyButtonPointer.eventY -= wnd->ypos; + wnd = wnd->parent; + } + X_SendData(xpointergrabclient, &ev, sizeof(ev)); + } + } + else if (XS_GetResource(ev.u.keyButtonPointer.child, &wnd) == x_window) + X_SendInputNotification(&ev, wnd, (ev.u.u.type==ButtonPress)?ButtonPressMask:KeyPressMask); + } +} +void XWindows_Keyup(int key) +{ + { + xEvent ev; + xwindow_t *wnd; + + X_EvalutateCursorOwner(NotifyNormal); + + X_EvalutateFocus(NotifyNormal); + + if (key >= K_MOUSE1 && key <= K_MOUSE5) + { + ev.u.u.type = ButtonRelease; + ev.u.keyButtonPointer.state = mousestate; + switch(key) + { + case K_MOUSE1: + ev.u.u.detail = 1; + mousestate &= ~Button1Mask; + break; + + case K_MOUSE3: + ev.u.u.detail = 2; + mousestate &= ~Button2Mask; + break; + + case K_MOUSE2: + ev.u.u.detail = 3; + mousestate &= ~Button3Mask; + break; + + case K_MOUSE4: + ev.u.u.detail = 4; + mousestate &= ~Button4Mask; + break; + + default: + ev.u.u.detail = 5; + mousestate &= ~Button5Mask; + break; + } + ev.u.keyButtonPointer.state = mousestate; + ev.u.keyButtonPointer.child = x_windowwithcursor; + } + else + { + ev.u.u.type = KeyRelease; + ev.u.u.detail = key; + ev.u.keyButtonPointer.child = x_windowwithfocus; + } + ev.u.u.sequenceNumber = 0; + ev.u.keyButtonPointer.time = Sys_DoubleTime()*1000; + ev.u.keyButtonPointer.rootX = x_mousex; + ev.u.keyButtonPointer.rootY = x_mousey; + ev.u.keyButtonPointer.state = 0; + ev.u.keyButtonPointer.sameScreen= true; + ev.u.keyButtonPointer.pad1 = 0; + +// Con_Printf("keyup %i, %i %i\n", key, x_mousex, x_mousey); + + if (xpointergrabclient) + { + ev.u.keyButtonPointer.event = ev.u.keyButtonPointer.child; + ev.u.keyButtonPointer.eventX = ev.u.keyButtonPointer.rootX; + ev.u.keyButtonPointer.eventY = ev.u.keyButtonPointer.rootY; + if (XS_GetResource(x_windowwithcursor, &wnd) == x_window) + { + ev.u.u.sequenceNumber = xpointergrabclient->requestnum; + while(wnd) + { + ev.u.keyButtonPointer.eventX -= wnd->xpos; + ev.u.keyButtonPointer.eventY -= wnd->ypos; + wnd = wnd->parent; + } + X_SendData(xpointergrabclient, &ev, sizeof(ev)); + } + } + else if (XS_GetResource(ev.u.keyButtonPointer.child, &wnd) == x_window) + { + X_SendInputNotification(&ev, wnd, (ev.u.u.type==ButtonRelease)?ButtonReleaseMask:KeyReleaseMask); + } + } +} + +#else +//quakie functions +void XWindows_Init(void){} +void XWindows_Draw(void){} +void XWindows_Key(int key){} +void XWindows_Keyup(int key){} +#endif diff --git a/engine/qux/qux.h b/engine/qux/qux.h new file mode 100644 index 000000000..aec98bdc3 --- /dev/null +++ b/engine/qux/qux.h @@ -0,0 +1,171 @@ +#include "quakedef.h" + +#ifdef _WIN32 //for multithreaded reading +#define BOOL WINDOWSSUCKS_BOOL +#define INT32 WINDOWSSUCKS_INT32 +#include "winquake.h" +#undef BOOL +#undef INT32 + +#define MULTITHREADWIN32 +#endif + +#ifdef MULTITHREADWIN32 +#define MULTITHREAD +#endif + +#include "Xproto.h" +#include "X.h" + +#include "bigreqstr.h" + +#define XK_MISCELLANY +#define XK_LATIN1 +#include "keysymdef.h" + +typedef struct xclient_s { + int socket; + int inbufferlen; + int outbufferlen; + int inbuffermaxlen; + int outbuffermaxlen; + char *outbuffer; + char *inbuffer; + qboolean tobedropped; //dropped when no more to send. + qboolean stillinitialising; + unsigned int requestnum; + unsigned int ridbase; + struct xclient_s *nextclient; + +#ifdef MULTITHREADWIN32 + HANDLE threadhandle; + CRITICAL_SECTION delecatesection; +#endif +} xclient_t; + +extern xclient_t *xgrabbedclient; //stops reading other clients +extern xclient_t *xpointergrabclient; + +typedef struct xproperty_s { + Atom atomid; + Atom type; + int datalen; + struct xproperty_s *next; + int format; + char data[1]; +} xproperty_t; + +typedef struct xnotificationmask_s { + xclient_t *client; + unsigned int mask; + struct xnotificationmask_s *next; +} xnotificationmask_t; + +typedef struct xresource_s { + enum {x_none, x_window, x_gcontext, x_pixmap, x_atom} restype; + int id; + xclient_t *owner; + + struct xresource_s *next, *prev; +} xresource_t; +typedef struct xpixmap_s { + xresource_t res; + + int references; + qboolean linked; + + int width; + int height; + int depth; + + qbyte *data; +} xpixmap_t; +typedef struct xatom_s { + xresource_t res; + char atomname[1]; + int selectionownerwindowid; + xclient_t *selectionownerclient; +} xatom_t; +typedef struct xwindow_s { + xresource_t res; + + int xpos; + int ypos; + int width; + int height; + char *buffer; + int bg; + struct xwindow_s *parent; + struct xwindow_s *child; + struct xwindow_s *sibling; + + xpixmap_t *backpixmap; + unsigned int backpixel; + unsigned int borderpixel; + int bitgravity, wingravity; + unsigned int donotpropagate; + int colormap; + + qboolean mapped; + qboolean overrideredirect; + + qboolean inputonly; + + int depth; + + xproperty_t *properties; + xnotificationmask_t *notificationmask; +} xwindow_t; + +typedef struct xgcontext_s +{ + xresource_t res; + int depth; + + int function; + int fgcolour; + int bgcolour; +} xgcontext_t; + +extern xwindow_t *rootwindow; +extern qboolean xrefreshed; //something onscreen changed. + +int XS_GetResource(int id, void **data); +void XS_SetProperty(xwindow_t *wnd, Atom atomid, Atom atomtype, char *data, int datalen, int format); +int XS_GetProperty(xwindow_t *wnd, Atom atomid, Atom *type, char *output, int maxlen, int offset, int *extrabytes, int *format); +void XS_DeleteProperty(xwindow_t *wnd, Atom atomid); +xatom_t *XS_CreateAtom(Atom atomid, char *name, xclient_t *owner); +Atom XS_FindAtom(char *name); +xgcontext_t *XS_CreateGContext(int id, xclient_t *owner, xresource_t *drawable); +int XS_NewResource(void); +xwindow_t *XS_CreateWindow(int wid, xclient_t *owner, xwindow_t *parent, short x, short y, short width, short height); +void XS_SetParent(xwindow_t *wnd, xwindow_t *parent); +xpixmap_t *XS_CreatePixmap(int id, xclient_t *owner, int width, int height, int depth); +void XS_CreateInitialResources(void); +void XS_DestroyResource(xresource_t *res); +void XS_DestroyResourcesOfClient(xclient_t *cl); + + +void XW_ExposeWindow(xwindow_t *root, int x, int y, int width, int height); +void XW_ClearArea(xwindow_t *wnd, int xp, int yp, int width, int height); + + + +typedef void (*XRequest) (xclient_t *cl, xReq *request); +extern XRequest XRequests [256]; + +void X_SendData(xclient_t *cl, void *data, int datalen); +void X_SendNotification(xEvent *data); +int X_SendNotificationMasked(xEvent *data, xwindow_t *window, unsigned int mask); +qboolean X_NotifcationMaskPresent(xwindow_t *window, int mask, xclient_t *notfor); +void X_SendError(xclient_t *cl, int errorcode, int assocresource, int major, int minor); +void X_InitRequests(void); + +void X_EvalutateCursorOwner(int movemode); +void X_EvalutateFocus(int movemode); + + +extern qbyte *xscreen; +extern short xscreenwidth; +extern short xscreenheight; + diff --git a/engine/qux/x_reqs.c b/engine/qux/x_reqs.c new file mode 100644 index 000000000..341e00c68 --- /dev/null +++ b/engine/qux/x_reqs.c @@ -0,0 +1,3256 @@ +#include "bothdefs.h" + +#ifndef NOMEDIA + + +#include "qux.h" +#undef strncpy + +#undef malloc +#undef free + +#define free BZ_Free +#define malloc BZ_Malloc + +XRequest XRequests [256]; + +#ifdef XBigReqExtensionName +int X_BigReqCode; +#endif + +void XR_MapWindow(xclient_t *cl, xReq *request); +void XR_UnmapWindow(xclient_t *cl, xReq *request); + + +#define GXclear 0x0 /* 0 */ +#define GXand 0x1 /* src AND dst */ +#define GXandReverse 0x2 /* src AND NOT dst */ +#define GXcopy 0x3 /* src */ +#define GXandInverted 0x4 /* NOT src AND dst */ +#define GXnoop 0x5 /* dst */ +#define GXxor 0x6 /* src XOR dst */ +#define GXor 0x7 /* src OR dst */ +#define GXnor 0x8 /* NOT src AND NOT dst */ +#define GXequiv 0x9 /* NOT src XOR dst */ +#define GXinvert 0xa /* NOT dst */ +#define GXorReverse 0xb /* src OR NOT dst */ +#define GXcopyInverted 0xc /* NOT src */ +#define GXorInverted 0xd /* NOT src OR dst */ +#define GXnand 0xe /* NOT src OR NOT dst */ +#define GXset 0xf /* 1 */ + +#define GCFunc(src, dst, fnc, out, setval) \ +switch(fnc) \ +{ \ +case GXclear: \ + out = 0; \ + break; \ +case GXand: \ + out = src&dst; \ + break; \ +case GXandReverse: \ + out = src&~dst; \ + break; \ +case GXcopy: \ + out = src; \ + break; \ +case GXandInverted: \ + out = ~src&dst; \ + break; \ +case GXnoop: \ + out = dst; \ + break; \ +case GXxor: \ + out = src^dst; \ + break; \ +case GXor: \ + out = src|dst; \ + break; \ +case GXnor: \ + out = ~src&~dst; \ + break; \ +case GXequiv: \ + out = ~src^dst; \ + break; \ +case GXinvert: \ + out = ~dst; \ + break; \ +case GXorReverse: \ + out = src|~dst; \ + break; \ +case GXcopyInverted: \ + out = ~src; \ + break; \ +case GXorInverted: \ + out = ~src|dst; \ + break; \ +case GXnand: \ + out = ~src|~dst; \ + break; \ +case GXset: \ + out = setval; \ + break; \ +} +void XW_ClearArea(xwindow_t *wnd, int xp, int yp, int width, int height); + +void XR_QueryExtension (xclient_t *cl, xReq *request) +{ + char extname[256]; + xQueryExtensionReply rep; + xQueryExtensionReq *req = (xQueryExtensionReq *)request; + + if (req->nbytes > 250) + req->nbytes = 250; + strncpy(extname, (char *)(req+1), req->nbytes); + extname[req->nbytes] = '\0'; + +#ifdef XBigReqExtensionName + if (X_BigReqCode && !strcmp(extname, XBigReqExtensionName)) + { + rep.major_opcode = X_BigReqCode; + rep.present = true; + rep.first_event = 0; + rep.first_error = 0; + } + else +#endif + if (0) {} //for the else + else + { + Con_Printf("Extension %s not supported\n", extname); + rep.major_opcode = 0; + rep.present = false; + rep.first_event = 0; + rep.first_error = 0; + } + + rep.type = X_Reply; + rep.pad1 = 0; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.pad3 = 0; + rep.pad4 = 0; + rep.pad5 = 0; + rep.pad6 = 0; + rep.pad7 = 0; + + X_SendData(cl, &rep, sizeof(rep)); +} + + +void XW_ExposeWindowRegionInternal(xwindow_t *root, int x, int y, int width, int height) +{ + int nx,ny,nw,nh; + xEvent ev; + if (!root->mapped || root->inputonly) + return; + + + ev.u.u.type = VisibilityNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.visibility.window = root->res.id; + ev.u.visibility.state = VisibilityUnobscured; + ev.u.visibility.pad1 = 0; + ev.u.visibility.pad2 = 0; + ev.u.visibility.pad3 = 0; + + X_SendNotificationMasked(&ev, root, VisibilityChangeMask); + + ev.u.u.type = Expose; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.expose.window = root->res.id; + ev.u.expose.x = x; + ev.u.expose.y = y; + ev.u.expose.width = width; + ev.u.expose.height = height; + ev.u.expose.count = false; //other expose events following (none - rewrite to group these then send all in one go...) + ev.u.expose.pad2 = 0; + + X_SendNotificationMasked(&ev, root, ExposureMask); + + if (root->buffer && root != rootwindow) + { + XW_ClearArea(root, 0, 0, root->width, root->height); +// free(root->buffer); +// root->buffer = NULL; + } + + for (root = root->child; root; root = root->sibling) + { + if (!root->mapped || root->inputonly) + continue; + + //subtract the minpos + nx = x - root->xpos; + nw = width; + ny = y - root->ypos; + nh = height; + + //cap new minpos to the child window. + if (nx < 0) + { + nw += nx; + nx = 0; + } + if (ny < 0) + { + nh += ny; + ny = 0; + } + + //cap new maxpos + if (nx+nw > x + root->width) + nw = x+root->width - nx; + if (ny+nh > y + root->height) + nh = y+root->height - ny; + + if (nw > 0 && nh > 0) //make sure some is valid. + XW_ExposeWindowRegionInternal(root, nx, ny, nw, nh); + } +} + +void XW_ExposeWindow(xwindow_t *root, int x, int y, int width, int height) +{//we have to go back to the root so we know the exact region, and can expose our sibling's windows. + while(root) + { + x += root->xpos; + y += root->ypos; + root = root->parent; + } + + XW_ExposeWindowRegionInternal(rootwindow, x, y, width, height); +} + +void XR_ListExtensions (xclient_t *cl, xReq *request) +{ + char buffer[8192]; + xListExtensionsReply *rep = (xListExtensionsReply *)buffer; + char *out; + + rep->type = X_Reply; + rep->nExtensions = 0; + rep->sequenceNumber = cl->requestnum; + rep->length = 0; + rep->pad2 = 0; + rep->pad3 = 0; + rep->pad4 = 0; + rep->pad5 = 0; + rep->pad6 = 0; + rep->pad7 = 0; + + out = (char *)(rep+1); + +#ifdef XBigReqExtensionName + rep->nExtensions++; + strcpy(out, XBigReqExtensionName); + out+=strlen(out)+1; +#endif + + rep->length = (out-(char *)(rep+1) + 3)/4; + + + X_SendData(cl, rep, sizeof(xListExtensionsReply) + rep->length*4); +} + +void XR_GetAtomName (xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq*)request; + char buffer[8192]; + xGetAtomNameReply *rep = (xGetAtomNameReply*)buffer; + + xatom_t *xa; + + if (XS_GetResource(req->id, &xa) != x_atom) + { + X_SendError(cl, BadAtom, req->id, X_GetAtomName, 0); + return; + } + + rep->type = X_Reply; + rep->pad1 = 0; + rep->sequenceNumber = cl->requestnum; + rep->length = (strlen(xa->atomname)+3)/4; + rep->nameLength = strlen(xa->atomname); + rep->pad2 = 0; + rep->pad3 = 0; + rep->pad4 = 0; + rep->pad5 = 0; + rep->pad6 = 0; + rep->pad7 = 0; + strcpy((char *)(rep+1), xa->atomname); + + X_SendData(cl, rep, sizeof(*rep)+rep->length*4); +} + +void XR_InternAtom (xclient_t *cl, xReq *request) +{ + xInternAtomReq *req = (xInternAtomReq*)request; + xInternAtomReply rep; + char atomname[1024]; + Atom atom; + + if (req->nbytes >= sizeof(atomname)) + { //exceeded that limit then... + X_SendError(cl, BadImplementation, 0, X_InternAtom, 0); + return; + } + + strncpy(atomname, (char *)(req+1), req->nbytes); + atomname[req->nbytes] = '\0'; + + atom = XS_FindAtom(atomname); + if (atom == None && !req->onlyIfExists) + { + atom = XS_NewResource(); + XS_CreateAtom(atom, atomname, NULL); //global atom... + } + + rep.type = X_Reply; + rep.pad1 = 0; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.atom = atom; + rep.pad2 = 0; + rep.pad3 = 0; + rep.pad4 = 0; + rep.pad5 = 0; + rep.pad6 = 0; + + X_SendData(cl, &rep, sizeof(rep)); +} + +void XR_GetProperty (xclient_t *cl, xReq *request) +{ + xGetPropertyReq *req = (xGetPropertyReq*)request; + char buffer[8192]; + xwindow_t *wnd; + int datalen; + int format; + int trailing; + xGetPropertyReply *rep = (xGetPropertyReply*)buffer; + + if (XS_GetResource(req->window, &wnd) != x_window) + { //wait a minute, That's not a window!!! + X_SendError(cl, BadWindow, req->window, X_GetProperty, 0); + return; + } + if (XS_GetResource(req->property, NULL) != x_atom) + { //whoops + X_SendError(cl, BadAtom, req->property, X_GetProperty, 0); + return; + } + + if (req->longLength > sizeof(buffer) - sizeof(req)/4) + req->longLength = sizeof(buffer) - sizeof(req)/4; + datalen = XS_GetProperty(wnd, req->property, &rep->propertyType, (char *)(rep+1), req->longLength*4, req->longOffset*4, &trailing, &format); + + rep->type = X_Reply; + rep->format = format; + rep->sequenceNumber = cl->requestnum; + rep->length = (datalen+3)/4; + //rep->propertyType = None; + rep->bytesAfter = trailing; + if (format) + rep->nItems = datalen / (format/8); + else + rep->nItems = 0; + rep->pad1 = 0; + rep->pad2 = 0; + rep->pad3 = 0; + + X_SendData(cl, rep, rep->length*4 + sizeof(*rep)); + + if (req->delete) + { + xEvent ev; + + XS_DeleteProperty(wnd, req->property); + + ev.u.u.type = PropertyNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.property.window = req->window; + ev.u.property.atom = req->property; + ev.u.property.time = Sys_DoubleTime()*1000; + ev.u.property.state = PropertyDelete; + + ev.u.property.pad1 = 0; + ev.u.property.pad2 = 0; + + X_SendNotificationMasked(&ev, wnd, PropertyChangeMask); + } +} + +void XR_ListProperties(xclient_t *cl, xReq *request) +{ + xproperty_t *xp; + xResourceReq *req = (xResourceReq*)request; + char buffer[65536]; + xwindow_t *wnd; + xListPropertiesReply *rep = (xListPropertiesReply*)buffer; + Atom *out = (Atom *)(rep+1); + + if (XS_GetResource(req->id, &wnd) != x_window) + { //wait a minute, That's not a window!!! + X_SendError(cl, BadWindow, req->id, X_GetProperty, 0); + return; + } + + + rep->type = X_Reply; + rep->sequenceNumber = cl->requestnum; + rep->length = 0; + rep->nProperties = 0; + rep->pad1 = 0; + rep->pad2 = 0; + rep->pad3 = 0; + rep->pad4 = 0; + rep->pad5 = 0; + rep->pad6 = 0; + rep->pad7 = 0; + + for (xp = wnd->properties; xp; xp = xp->next) + { + rep->nProperties++; + *out = xp->atomid; + } + + rep->length = rep->nProperties; + + X_SendData(cl, rep, rep->length*4 + sizeof(*rep)); +} + +void XR_ChangeProperty (xclient_t *cl, xReq *request) +{ + xChangePropertyReq *req = (xChangePropertyReq*)request; + int len; + + xatom_t *atom; + xwindow_t *wnd; + + if (XS_GetResource(req->window, &wnd) != x_window) + { //wait a minute, That's not a window!!! + X_SendError(cl, BadWindow, req->window, X_ChangeProperty, 0); + return; + } + + if (XS_GetResource(req->property, &atom) != x_atom) + { + X_SendError(cl, BadAtom, req->property, X_ChangeProperty, 0); + return; + } + + len = req->nUnits * (req->format/8); + + if (req->mode == PropModeReplace) + XS_SetProperty(wnd, req->property, req->type, (char *)(req+1), len, req->format); + else if (req->mode == PropModePrepend) + { + X_SendError(cl, BadImplementation, req->window, X_ChangeProperty, 0); + return; + } + else if (req->mode == PropModeAppend) + { + char hugebuffer[65536]; + int trailing; + int format, datalen; + Atom proptype; + + + datalen = XS_GetProperty(wnd, req->property, &proptype, hugebuffer, sizeof(hugebuffer), 0, &trailing, &format); + if (datalen+len > sizeof(hugebuffer)) + { + X_SendError(cl, BadImplementation, req->window, X_ChangeProperty, 0); + return; + } + memcpy(hugebuffer + datalen, (char *)(req+1), len); + + XS_SetProperty(wnd, req->property, proptype, hugebuffer, datalen+len, format); + } + + { + xEvent ev; + + ev.u.u.type = PropertyNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.property.window = req->window; + ev.u.property.atom = req->property; + ev.u.property.time = Sys_DoubleTime()*1000; + ev.u.property.state = PropertyNewValue; + + ev.u.property.pad1 = 0; + ev.u.property.pad2 = 0; + + X_SendNotificationMasked(&ev, wnd, PropertyChangeMask); + } +} + +void XR_DeleteProperty(xclient_t *cl, xReq *request) +{ + xDeletePropertyReq *req = (xDeletePropertyReq*)request; + + xwindow_t *wnd; + + if (XS_GetResource(req->window, &wnd) != x_window) + { //wait a minute, That's not a window!!! + X_SendError(cl, BadWindow, req->window, X_DeleteProperty, 0); + return; + } + + if (XS_GetResource(req->property, NULL) != x_atom) + { + X_SendError(cl, BadAtom, req->property, X_DeleteProperty, 0); + return; + } + + XS_DeleteProperty(wnd, req->property); + + { + xEvent ev; + + ev.u.u.type = PropertyNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.property.window = req->window; + ev.u.property.atom = req->property; + ev.u.property.time = Sys_DoubleTime()*1000; + ev.u.property.state = PropertyDelete; + + ev.u.property.pad1 = 0; + ev.u.property.pad2 = 0; + + X_SendNotificationMasked(&ev, wnd, PropertyChangeMask); + } +} + +void XR_GetSelectionOwner (xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq *)request; + xGetSelectionOwnerReply reply; + xatom_t *atom; + + if (XS_GetResource(req->id, &atom) != x_atom) + { + X_SendError(cl, BadAtom, req->id, X_GetSelectionOwner, 0); + return; + } + + if (XS_GetResource(atom->selectionownerwindowid, NULL) != x_window) //make sure the window still exists. + { + atom->selectionownerwindowid = None; + } + + reply.type = X_Reply; + reply.sequenceNumber = cl->requestnum; + reply.length = 0; + reply.owner = atom->selectionownerwindowid; + reply.pad1 = 0; + reply.pad2 = 0; + reply.pad3 = 0; + reply.pad4 = 0; + reply.pad5 = 0; + reply.pad6 = 0; + + X_SendData(cl, &reply, sizeof(reply)); +} +void XR_SetSelectionOwner (xclient_t *cl, xReq *request) +{ + xSetSelectionOwnerReq *req = (xSetSelectionOwnerReq *)request; + xatom_t *atom; + xwindow_t *window; + + if (XS_GetResource(req->selection, &atom) != x_atom) + { + X_SendError(cl, BadAtom, req->selection, X_SetSelectionOwner, 0); + return; + } + + if (XS_GetResource(req->window, &window) != x_window) //make sure the window still exists. + { + X_SendError(cl, BadWindow, req->window, X_SetSelectionOwner, 0); + return; + } + + if (req->window) + { + atom->selectionownerwindowid = req->window; + atom->selectionownerclient = cl; + } + else + { + atom->selectionownerwindowid = None; + atom->selectionownerclient = NULL; + } +} + + + + +extern int x_windowwithcursor; + +void XR_GetInputFocus (xclient_t *cl, xReq *request) +{ + xGetInputFocusReply rep; + extern xwindow_t *xfocusedwindow; + + rep.type = X_Reply; + rep.revertTo = None; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.focus = xfocusedwindow?xfocusedwindow->res.id:None; + rep.pad1 = 0; + rep.pad2 = 0; + rep.pad3 = 0; + rep.pad4 = 0; + rep.pad5 = 0; + + + X_SendData(cl, &rep, sizeof(rep)); +} + +void XR_SetInputFocus (xclient_t *cl, xReq *request) +{ + extern xwindow_t *xfocusedwindow; + xResourceReq *req = (xResourceReq *)request; + xwindow_t *wnd; + + if (XS_GetResource(req->id, &wnd) != x_window) + { + X_SendError(cl, BadDrawable, req->id, X_SetInputFocus, 0); + return; + } + + xfocusedwindow = wnd; + + X_EvalutateFocus(NotifyWhileGrabbed); +} + +void XR_QueryBestSize (xclient_t *cl, xReq *request) +{ + xQueryBestSizeReq *req = (xQueryBestSizeReq *)request; + xQueryBestSizeReply rep; + + if (req->class == CursorShape && req->drawable != rootwindow->res.id) + { + X_SendError(cl, BadDrawable, req->drawable, X_QueryBestSize, req->class); + return; + } + else if (req->class != CursorShape) + { + X_SendError(cl, BadImplementation, req->drawable, X_QueryBestSize, req->class); + return; + } + + rep.type = X_Reply; + rep.pad1 = 0; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.width = req->width; + rep.height = req->height; + rep.pad3 = 0; + rep.pad4 = 0; + rep.pad5 = 0; + rep.pad6 = 0; + rep.pad7 = 0; + + X_SendData(cl, &rep, sizeof(rep)); +} + +void XR_GetGeometry (xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq *)request; + xGetGeometryReply rep; + xresource_t *drawable; + + xwindow_t *wnd; + xpixmap_t *pm; + + rep.type = X_Reply; + rep.depth = 24; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.root = 0; + rep.x = 0; + rep.y = 0; + rep.width = 0; + rep.height = 0; + rep.borderWidth = 0; + rep.pad1 = 0; + rep.pad2 = 0; + rep.pad3 = 0; + + switch(XS_GetResource(req->id, &drawable)) + { + case x_window: + wnd = (xwindow_t*)drawable; + rep.x = wnd->xpos; + rep.y = wnd->ypos; + rep.borderWidth = 0; //fixme + rep.width = wnd->width; + rep.height = wnd->height; + rep.root = rootwindow->res.id; + break; + case x_pixmap: + pm = (xpixmap_t*)drawable; + rep.width = pm->width; + rep.height = pm->height; + break; + default: + X_SendError(cl, BadDrawable, req->id, X_GetGeometry, 0); + return; + } + + + X_SendData(cl, &rep, sizeof(rep)); +} + +void XR_CreateWindow (xclient_t *cl, xReq *request) +{ + xCreateWindowReq *req = (xCreateWindowReq *)request; + xwindow_t *parent; + xwindow_t *wnd; + CARD32 *parameters; + + if (req->class == InputOnly && req->depth != 0) + { + X_SendError(cl, BadMatch, req->wid, X_CreateWindow, 0); + return; + } + if (XS_GetResource(req->wid, &parent) != x_none) + { + X_SendError(cl, BadIDChoice, req->wid, X_CreateWindow, 0); + return; + } + + if (XS_GetResource(req->parent, &parent) != x_window) + { + X_SendError(cl, BadWindow, req->parent, X_CreateWindow, 0); + return; + } + + wnd = XS_CreateWindow(req->wid, cl, parent, req->x, req->y, req->width, req->height); + + if (req->depth != 0) + wnd->depth = req->depth; + else + wnd->depth = parent->depth; + + if (req->class == CopyFromParent) + wnd->inputonly = parent->inputonly; + else + wnd->inputonly = (req->class == InputOnly); + + //FIXME: Depth must be valid + //FIXME: visual id must be valid. + + parameters = (CARD32 *)(req+1); + if (req->mask & CWBackPixmap) + { + wnd->backpixmap = NULL; + if (XS_GetResource(*parameters, &wnd->backpixmap) != x_pixmap) + { + if (*parameters) + X_SendError(cl, BadPixmap, *parameters, X_CreateWindow, 0); + } + else + wnd->backpixmap->references++; + parameters++; + } + if (req->mask & CWBackPixel)// + { + wnd->backpixel = *parameters; + parameters++; + } + if (req->mask & CWBorderPixmap) + parameters+=0; + if (req->mask & CWBorderPixel)// + { + wnd->borderpixel = *parameters; + parameters++; + } + if (req->mask & CWBitGravity)// + { + wnd->bitgravity = *parameters; + parameters++; + } + if (req->mask & CWWinGravity) + wnd->bitgravity = *parameters++; + if (req->mask & CWBackingStore) + parameters++; //ignored + if (req->mask & CWBackingPlanes) + parameters+=0; + if (req->mask & CWBackingPixel) + parameters+=0; + if (req->mask & CWOverrideRedirect) + wnd->overrideredirect = *parameters++; + else + wnd->overrideredirect = false; + if (req->mask & CWSaveUnder) + parameters++; + if (req->mask & CWEventMask)// + { + xnotificationmask_t *nm; + nm = malloc(sizeof(xnotificationmask_t)); + nm->client = cl; + nm->next = NULL; + nm->mask = *parameters; + wnd->notificationmask = nm; + parameters++; + } + if (req->mask & CWDontPropagate) + wnd->donotpropagate = *parameters++; + if (req->mask & CWColormap)// + { + wnd->colormap = *parameters; + parameters++; + } + if (req->mask & CWCursor) + parameters++; + + #define CWBackPixmap (1L<<0) +#define CWBackPixel (1L<<1) +#define CWBorderPixmap (1L<<2) +#define CWBorderPixel (1L<<3) +#define CWBitGravity (1L<<4) +#define CWWinGravity (1L<<5) +#define CWBackingStore (1L<<6) +#define CWBackingPlanes (1L<<7) +#define CWBackingPixel (1L<<8) +#define CWOverrideRedirect (1L<<9) +#define CWSaveUnder (1L<<10) +#define CWEventMask (1L<<11) +#define CWDontPropagate (1L<<12) +#define CWColormap (1L<<13) +#define CWCursor (1L<<14) +/* + CARD8 depth; + Window wid; + Window parent; + INT16 x B16, y B16; + CARD16 width B16, height B16, borderWidth B16; +#if defined(__cplusplus) || defined(c_plusplus) + CARD16 c_class B16; +#else + CARD16 class B16; +#endif + VisualID visual B32; + CARD32 mask B32; +*/ + + if (wnd->inputonly) + return; + + + { + xEvent ev; + + ev.u.u.type = CreateNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.createNotify.parent = wnd->parent->res.id; + ev.u.createNotify.window = wnd->res.id; + ev.u.createNotify.x = wnd->xpos; + ev.u.createNotify.y = wnd->ypos; + ev.u.createNotify.width = wnd->width; + ev.u.createNotify.height = wnd->height; + ev.u.createNotify.borderWidth = req->borderWidth; + ev.u.createNotify.override = wnd->overrideredirect; + ev.u.createNotify.bpad = 0; + + X_SendNotificationMasked (&ev, wnd, SubstructureNotifyMask); + } + +/* { + xEvent ev; + + ev.u.u.type = MapRequest; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.mapRequest.window = wnd->res.id; + ev.u.mapRequest.parent = wnd->parent->res.id; + + X_SendNotificationMasked(&ev, wnd, SubstructureRedirectMask); + }*/ +/* { + xEvent ev; + + ev.u.u.type = GraphicsExpose; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.expose.window = wnd->res.id; + ev.u.expose.x = 0; + ev.u.expose.y = 0; + ev.u.expose.width = wnd->width; + ev.u.expose.height = wnd->height; + ev.u.expose.count = 0; //matching expose events after this one + ev.u.expose.pad2 = 0; + + X_SendNotificationMasked(&ev, wnd, ExposureMask); + }*/ +} + +void XR_ChangeWindowAttributes (xclient_t *cl, xReq *request) +{ + CARD32 *parameters; + xChangeWindowAttributesReq *req = (xChangeWindowAttributesReq *)request; + xwindow_t *wnd; + + if (XS_GetResource(req->window, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->window, X_ChangeWindowAttributes, 0); + return; + } + + parameters = (CARD32 *)(req+1); + + if (req->valueMask & CWBackPixmap) + { + if (wnd->backpixmap) + wnd->backpixmap->references--; + wnd->backpixmap = NULL; + if (XS_GetResource(*parameters, &wnd->backpixmap) != x_pixmap) + { + if (*parameters) + X_SendError(cl, BadPixmap, *parameters, X_ChangeWindowAttributes, 0); + } + else + wnd->backpixmap->references++; + parameters++; + } + + if (req->valueMask & CWBackPixel) + { + if (wnd->backpixmap) + wnd->backpixmap->references--; + wnd->backpixmap = NULL; + wnd->backpixel = *parameters++; + } + + if (req->valueMask & CWBorderPixmap) + { + X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0); +/* wnd->borderpixmap = NULL; + if (XS_GetResource(*parameters, &wnd->borderpixmap) != x_pixmap) + { + if (*parameters) + X_SendError(cl, BadPixmap, *parameters, X_ChangeWindowAttributes, 0); + } + else + wnd->backpixmap->references++; +*/ parameters++; + } + + if (req->valueMask & CWBorderPixel) + wnd->borderpixel = *parameters++; + + if (req->valueMask & CWBitGravity) + { + wnd->bitgravity = *parameters++; + } + + if (req->valueMask & CWWinGravity) + { + wnd->wingravity = *parameters++; + } + + if (req->valueMask & CWBackingStore) + { +// X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0); + parameters++; //ignore + } + + if (req->valueMask & CWBackingPlanes) + { + X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0); + parameters++; + } + + if (req->valueMask & CWBackingPixel) + { + X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0); + parameters++; + } + + if (req->valueMask & CWOverrideRedirect) + { + wnd->overrideredirect = *parameters++; + } + + if (req->valueMask & CWSaveUnder) + { +// X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0); + parameters++; + } + + if (req->valueMask & CWEventMask) + { + xnotificationmask_t *nm; + + if (*parameters & (SubstructureRedirectMask | ResizeRedirectMask)) + { //you're only allowed one client with that one at a time. + for (nm = wnd->notificationmask; nm; nm = nm->next) + { + if (nm->mask & (*parameters)) + if (nm->client != cl) + break; + } + } + else + nm = NULL; + if (nm) //client has this one. + X_SendError(cl, BadAccess, *parameters, X_ChangeWindowAttributes, CWEventMask); + else + { + for (nm = wnd->notificationmask; nm; nm = nm->next) + { + if (nm->client == cl) + break; + } + if (!nm) + { + nm = malloc(sizeof(xnotificationmask_t)); + nm->next = wnd->notificationmask; + wnd->notificationmask = nm; + nm->client = cl; + } + nm->mask = *parameters; + } + parameters++; + } + + if (req->valueMask & CWDontPropagate) + { + wnd->donotpropagate = *parameters++; + } + + if (req->valueMask & CWColormap) + { + X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0); + parameters++; + } + + if (req->valueMask & CWCursor) + { +// X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0); + parameters++; + } + + xrefreshed=true; + + if (req->valueMask > CWCursor) //anything else is an error on some implementation's part. + X_SendError(cl, BadImplementation, 0, X_ChangeWindowAttributes, 0); + + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); +} + +void XR_ConfigureWindow (xclient_t *cl, xReq *request) +{ + int newx, newy, neww, newh, sibid, newbw; + xConfigureWindowReq *req = (xConfigureWindowReq *)request; + xwindow_t *wnd; + + CARD32 *parm; + + if (XS_GetResource(req->window, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->window, X_ConfigureWindow, 0); + return; + } + + if (!wnd->parent) //root window. + { //can't resize this one. + X_SendError(cl, BadWindow, req->window, X_ConfigureWindow, 0); + return; + } + + parm = (CARD32 *)(req+1); + + if (req->mask & CWX) + newx = *parm++; + else + newx=wnd->xpos; + if (req->mask & CWY) + newy = *parm++; + else + newy=wnd->ypos; + + if (req->mask & CWWidth) + neww = *parm++; + else + neww=wnd->width; + + if (wnd->width <= 0) + wnd->width = 1; + + if (req->mask & CWHeight) + newh = *parm++; + else + newh=wnd->height; + + if (req->mask & CWBorderWidth) + newbw = *parm++; + else + newbw = 0; + if (req->mask & CWSibling) + sibid = *parm++; + else + sibid = 0; + if (req->mask & CWStackMode) + *parm++; + + if (!wnd->overrideredirect && X_NotifcationMaskPresent(wnd, SubstructureRedirectMask, cl)) + { + xEvent ev; + + + + ev.u.u.type = ConfigureRequest; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.configureRequest.parent = wnd->parent->res.id; + ev.u.configureRequest.window = wnd->res.id; + ev.u.configureRequest.sibling = wnd->sibling?wnd->sibling->res.id:None; + ev.u.configureRequest.x = newx; + ev.u.configureRequest.y = newy; + ev.u.configureRequest.width = neww; + ev.u.configureRequest.height = newh; + ev.u.configureRequest.borderWidth = newbw; + ev.u.configureRequest.valueMask = req->mask; + ev.u.configureRequest.pad1 = 0; + + X_SendNotificationMasked(&ev, wnd, SubstructureRedirectMask); + } + else + { + xEvent ev; + + /* if (wnd->xpos == newx && wnd->ypos == newy) + { + ev.u.u.type = ResizeRequest; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.resizeRequest.window = wnd->res.id; + ev.u.resizeRequest.width = wnd->width; + ev.u.resizeRequest.height = wnd->height; + + X_SendNotificationMasked(&ev, wnd, StructureNotifyMask); + X_SendNotificationMasked(&ev, wnd, SubstructureNotifyMask); + + return; + }*/ + + wnd->xpos = newx; + wnd->ypos = newy; + + if ((wnd->width != neww || wnd->height != newh) && wnd->buffer) + { + free(wnd->buffer); + wnd->buffer = NULL; + } + wnd->width = neww; + wnd->height = newh; + + if (wnd->mapped) + xrefreshed = true; + + ev.u.u.type = ConfigureNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.configureNotify.event = wnd->res.id; + ev.u.configureNotify.window = wnd->res.id; + ev.u.configureNotify.aboveSibling = None; + ev.u.configureNotify.x = wnd->xpos; + ev.u.configureNotify.y = wnd->ypos; + ev.u.configureNotify.width = wnd->width; + ev.u.configureNotify.height = wnd->height; + ev.u.configureNotify.borderWidth = 0; + ev.u.configureNotify.override = wnd->overrideredirect; + ev.u.configureNotify.bpad = 0; + + X_SendNotificationMasked(&ev, wnd, StructureNotifyMask); + X_SendNotificationMasked(&ev, wnd, SubstructureNotifyMask); + } +} + +void XR_ReparentWindow (xclient_t *cl, xReq *request) +{ + qboolean wasmapped; + xEvent ev; + xReparentWindowReq *req = (xReparentWindowReq *)request; + xwindow_t *wnd, *parent; + + if (XS_GetResource(req->window, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->window, X_ReparentWindow, 0); + return; + } + if (XS_GetResource(req->parent, &parent) != x_window) + { + X_SendError(cl, BadWindow, req->parent, X_ReparentWindow, 0); + return; + } + + if (wnd->mapped) + { + XR_UnmapWindow(cl, request); + wasmapped = true; + } + else + wasmapped = false; + + ev.u.u.type = ReparentNotify; + ev.u.u.detail = 0; + ev.u.reparent.override = wnd->overrideredirect; + ev.u.reparent.window = wnd->res.id; + ev.u.reparent.parent = wnd->res.id; + ev.u.reparent.x = req->x; + ev.u.reparent.y = req->y; + + X_SendNotificationMasked (&ev, wnd, SubstructureNotifyMask); + + XS_SetParent(wnd, parent); + wnd->xpos = req->x; + wnd->ypos = req->y; + + X_SendNotificationMasked (&ev, wnd, SubstructureNotifyMask); //and again, now that we have the new parent. + + ev.u.reparent.event = wnd->res.id; + X_SendNotificationMasked (&ev, wnd, StructureNotifyMask); + + if (wasmapped) + XR_MapWindow(cl, request); +} + +void XR_DestroyWindow (xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq *)request; + xwindow_t *wnd; + + if (XS_GetResource(req->id, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->id, X_DestroyWindow, 0); + return; + } + if (!wnd->res.owner) //root window. + return; + XS_DestroyResource(&wnd->res); +} +void XR_QueryTree (xclient_t *cl, xReq *request) +{ + char buffer[8192]; + xResourceReq *req = (xResourceReq *)request; + xQueryTreeReply *rep = (xQueryTreeReply*)buffer; + + xwindow_t *wnd; + + Window *cwnd; + + + if (XS_GetResource(req->id, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->id, X_DestroyWindow, 0); + return; + } + + //FIXME: be careful of the count of children overflowing buffer. + + rep->type = X_Reply; + rep->pad1 = 0; + rep->sequenceNumber = cl->requestnum; + rep->length = 0; + rep->root = rootwindow->res.id; //we only have one root + if (wnd->parent) + rep->parent = wnd->parent->res.id; + else + rep->parent = 0; + rep->nChildren = 0; + rep->pad2 = 0; + rep->pad3 = 0; + rep->pad4 = 0; + rep->pad5 = 0; + + cwnd = (Window*)(rep+1); + + for (wnd = wnd->child ; wnd ; wnd = wnd->sibling) + { + *cwnd++ = wnd->res.id; + rep->nChildren++; + } + + rep->length = rep->nChildren; + + X_SendData(cl, rep, sizeof(*rep)+rep->length*4); +} + +void XR_GetWindowAttributes (xclient_t *cl, xReq *request) +{ + xnotificationmask_t *nm; + xResourceReq *req = (xResourceReq *)request; + xwindow_t *wnd; + + xGetWindowAttributesReply rep; + + if (XS_GetResource(req->id, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->id, X_GetWindowAttributes, 0); + return; + } + + rep.type = X_Reply; + rep.backingStore = 2; + rep.sequenceNumber = cl->requestnum; + rep.visualID = 0x22; + rep.class = wnd->inputonly; + rep.bitGravity = wnd->bitgravity; + rep.winGravity = wnd->wingravity; + rep.backingBitPlanes = wnd->depth; + rep.backingPixel = wnd->backpixel; + rep.saveUnder = 1; + rep.mapInstalled = !!wnd->buffer; + rep.mapState = wnd->mapped*2; + rep.override = wnd->overrideredirect; + rep.colormap = wnd->colormap; + rep.yourEventMask = 0; + rep.allEventMasks = 0; + for (nm = wnd->notificationmask; nm; nm = nm->next) + { + if (nm->client == cl) + rep.yourEventMask = nm->mask; + rep.allEventMasks |= nm->mask; + } + rep.doNotPropagateMask = wnd->donotpropagate; + rep.pad = 0; + + rep.length = (sizeof(xGetWindowAttributesReply) - sizeof(xGenericReply) + 3)/4; + + X_SendData(cl, &rep, sizeof(xGetWindowAttributesReply)); +} + +void XR_GetKeyboardMapping (xclient_t *cl, xReq *request) +{//fixme: send the XK equivelents. + xGetKeyboardMappingReq *req = (xGetKeyboardMappingReq *)request; + char buffer[8192]; + xGetKeyboardMappingReply *rep = (xGetKeyboardMappingReply *)buffer; + int i; + + rep->type = X_Reply; + rep->keySymsPerKeyCode = 1; + rep->sequenceNumber = cl->requestnum; + rep->length = req->count; + rep->pad2 = 0; + rep->pad3 = 0; + rep->pad4 = 0; + rep->pad5 = 0; + rep->pad6 = 0; + rep->pad7 = 0; + + for (i = 0; i < req->count; i++) + { + switch (req->firstKeyCode+i) + { + case ' ': ((int *)(rep+1))[i] = XK_space; break; + + case K_PGUP: ((int *)(rep+1))[i] = XK_Page_Up; break; + case K_PGDN: ((int *)(rep+1))[i] = XK_Page_Down; break; + case K_HOME: ((int *)(rep+1))[i] = XK_Home; break; + case K_END: ((int *)(rep+1))[i] = XK_End; break; + + case K_LEFTARROW: ((int *)(rep+1))[i] = XK_Left; break; + case K_RIGHTARROW: ((int *)(rep+1))[i] = XK_Right; break; + case K_DOWNARROW: ((int *)(rep+1))[i] = XK_Down; break; + case K_UPARROW: ((int *)(rep+1))[i] = XK_Up; break; + + case K_ENTER: ((int *)(rep+1))[i] = XK_Return; break; + case K_TAB: ((int *)(rep+1))[i] = XK_Tab; break; + case K_ESCAPE: ((int *)(rep+1))[i] = XK_Escape; break; + + case K_F1: ((int *)(rep+1))[i] = XK_F1; break; + case K_F2: ((int *)(rep+1))[i] = XK_F2; break; + case K_F3: ((int *)(rep+1))[i] = XK_F3; break; + case K_F4: ((int *)(rep+1))[i] = XK_F4; break; + case K_F5: ((int *)(rep+1))[i] = XK_F5; break; + case K_F6: ((int *)(rep+1))[i] = XK_F6; break; + case K_F7: ((int *)(rep+1))[i] = XK_F7; break; + case K_F8: ((int *)(rep+1))[i] = XK_F8; break; + case K_F9: ((int *)(rep+1))[i] = XK_F9; break; + case K_F10: ((int *)(rep+1))[i] = XK_F10; break; + case K_F11: ((int *)(rep+1))[i] = XK_F11; break; + case K_F12: ((int *)(rep+1))[i] = XK_F12; break; + + case K_BACKSPACE: ((int *)(rep+1))[i] = XK_BackSpace; break; + case K_DEL: ((int *)(rep+1))[i] = XK_Delete; break; + case K_INS: ((int *)(rep+1))[i] = XK_Insert; break; + case K_PAUSE: ((int *)(rep+1))[i] = XK_Pause; break; + case K_SHIFT: ((int *)(rep+1))[i] = XK_Shift_L; break; + case K_CTRL: ((int *)(rep+1))[i] = XK_Control_L; break; + case K_ALT: ((int *)(rep+1))[i] = XK_Alt_L; break; + + + case K_KP_HOME: ((int *)(rep+1))[i] = XK_Home; break; + case K_KP_UPARROW: ((int *)(rep+1))[i] = XK_Up; break; + + + + case K_KP_PGUP: ((int *)(rep+1))[i] = XK_KP_Page_Up; break; + case K_KP_LEFTARROW: ((int *)(rep+1))[i] = XK_KP_Left; break; + case K_KP_5: ((int *)(rep+1))[i] = XK_KP_Space; break; + case K_KP_RIGHTARROW: ((int *)(rep+1))[i] = XK_KP_Right; break; + case K_KP_END: ((int *)(rep+1))[i] = XK_KP_End; break; + case K_KP_DOWNARROW: ((int *)(rep+1))[i] = XK_KP_Down; break; + case K_KP_PGDN: ((int *)(rep+1))[i] = XK_KP_Page_Down; break; + case K_KP_ENTER: ((int *)(rep+1))[i] = XK_KP_Enter; break; + case K_KP_INS: ((int *)(rep+1))[i] = XK_KP_Insert; break; + case K_KP_DEL: ((int *)(rep+1))[i] = XK_KP_Delete; break; + case K_KP_SLASH: ((int *)(rep+1))[i] = XK_KP_Divide; break; + case K_KP_MINUS: ((int *)(rep+1))[i] = XK_KP_Subtract; break; + case K_KP_PLUS: ((int *)(rep+1))[i] = XK_KP_Add; break; + case K_KP_STAR: ((int *)(rep+1))[i] = XK_KP_Multiply; break; + case K_KP_EQUALS: ((int *)(rep+1))[i] = XK_KP_Enter; break; + + default: + ((int *)(rep+1))[i] = req->firstKeyCode+i; + break; + } + } + + X_SendData(cl, rep, sizeof(*rep)+rep->length*4); +} + +void XR_QueryPointer (xclient_t *cl, xReq *request) +{ + extern int mousecursor_x, mousecursor_y; + xQueryPointerReply rep; + + rep.type = X_Reply; + rep.sameScreen = 1; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.root = rootwindow->res.id; + rep.child = rootwindow->res.id; + rep.rootX = mousecursor_x; + rep.rootY = mousecursor_y; + rep.winX = mousecursor_x; + rep.winY = mousecursor_y; + rep.mask = 0; + rep.pad1 = 0; + rep.pad = 0; + + X_SendData(cl, &rep, sizeof(rep)); +} + +void XR_ChangeGCInternal(unsigned int mask, xgcontext_t *gc, CARD32 *param) +{ + if (mask & GCFunction) + gc->function = *param++; + if (mask & GCPlaneMask) + param++; + if (mask & GCForeground) + gc->fgcolour = *param++; + if (mask & GCBackground) + gc->bgcolour = *param++; + if (mask & GCLineWidth) + param++; + if (mask & GCLineStyle) + param++; + if (mask & GCCapStyle) + param++; + if (mask & GCJoinStyle) + param++; + if (mask & GCFillStyle) + param++; + if (mask & GCFillRule) + param++; + if (mask & GCTile) + param++; + if (mask & GCStipple) + param++; + if (mask & GCTileStipXOrigin) + param++; + if (mask & GCTileStipYOrigin) + param++; + if (mask & GCFont) + param++; + if (mask & GCSubwindowMode) + param++; + if (mask & GCGraphicsExposures) + param++; + if (mask & GCClipXOrigin) + param++; + if (mask & GCClipYOrigin) + param++; + if (mask & GCClipMask) + param++; + if (mask & GCDashOffset) + param++; + if (mask & GCDashList) + param++; + if (mask & GCArcMode) + param++; +} +void XR_ChangeGC(xclient_t *cl, xReq *request) +{ + xChangeGCReq *req = (xChangeGCReq *)request; + xgcontext_t *gc; + + if (XS_GetResource(req->gc, &gc) != x_gcontext) + { + X_SendError(cl, BadGC, req->gc, X_FreeGC, 0); + return; + } + + XR_ChangeGCInternal(req->mask, gc, (CARD32 *)(req + 1)); +} + +void XR_CreateGC(xclient_t *cl, xReq *request) +{ + xCreateGCReq *req = (xCreateGCReq *)request; + xresource_t *drawable; + + if (XS_GetResource(req->gc, &drawable) != x_none) + { +// if (req->gc == cl->ridbase&&drawable->owner) +// XS_DestroyResourcesOfClient(drawable->owner); +// else + { + X_SendError(cl, BadIDChoice, req->gc, X_CreateGC, 0); + return; + } + } + XS_GetResource(req->drawable, &drawable); + /*if (drawable->restype != x_window && drawable->restype != x_gcontext) + { + X_SendError(cl, BadDrawable, req->drawable, X_CreateGC, 0); + return; + }*/ + + XR_ChangeGCInternal(req->mask, XS_CreateGContext(req->gc, cl, drawable), (CARD32 *)(req + 1)); +} + +void XR_FreeGC(xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq *)request; + xresource_t *gc; + if (XS_GetResource(req->id, &gc) != x_gcontext) + { + X_SendError(cl, BadGC, req->id, X_FreeGC, 0); + return; + } + + XS_DestroyResource(gc); +} + +void XW_ClearArea(xwindow_t *wnd, int xp, int yp, int width, int height) +{ + if (!wnd->buffer) + { + if (wnd->width*wnd->height<=0) + wnd->buffer = malloc(1); + else + wnd->buffer = malloc(wnd->width*wnd->height*4); + } + + if (xp < 0) + { + width += xp; + xp = 0; + } + if (xp>wnd->width) + xp = wnd->width; + if (yp < 0) + { + height += yp; + xp = 0; + } + if (yp>wnd->height) + yp = wnd->height; + if (width+xp > wnd->width) + width = wnd->width - xp; + if (height+yp > wnd->height) + height = wnd->height - yp; + + if (wnd->backpixmap && wnd->backpixmap->width && wnd->backpixmap->height) + { + int x, xs; + int y, ys; + unsigned int *out; + unsigned int *in; + + out = (unsigned int *)wnd->buffer + xp +yp*wnd->width; + in = (unsigned int *)wnd->backpixmap->data; + + for (y = 0, ys = 0; y < height; y++) + { + for (x = 0; x < width; x+=wnd->backpixmap->width) + { + //when do we stop? + xs = wnd->backpixmap->width; + if (xs > wnd->width-x) + xs = wnd->width-x; + for (; xs > 0; xs--) + { + out[x+xs] = in[xs+ys*wnd->backpixmap->width]; + } + } + out += wnd->width; + ys++; + if (ys >= wnd->backpixmap->height) + ys = 0; + } + } + else + { + int x; + int y; + unsigned int *out; + + out = (unsigned int *)wnd->buffer + xp +yp*wnd->width; + + for (y = yp; y < height; y++) + { + for (x = xp; x < width; x++) + { + out[x] = wnd->backpixel; + } + out+=wnd->width; + } + } +} + +void XW_CopyArea(unsigned int *dest, int dx, int dy, int dwidth, int dheight, unsigned int *source, int sx, int sy, int swidth, int sheight, int cwidth, int cheight, xgcontext_t *gc) +{ + int x, y; + + //tlcap on dest + if (dx < 0) + { + cwidth += dx; + dx = 0; + } + if (dy < 0) + { + cheight += dy; + dy = 0; + } + + //tlcap on source + if (sx < 0) + { + cwidth += sx; + sx = 0; + } + if (sy < 0) + { + cheight += sy; + sy = 0; + } + + //brcap on dest + if (cwidth > dwidth - dx) + cwidth = dwidth - dx; + + if (cheight > dheight - dy) + cheight = dheight - dy; + + //brcap on source + if (cwidth > swidth - sx) + cwidth = swidth - sx; + + if (cheight > sheight - sy) + cheight = sheight - sy; + + if (cwidth<=0) + return; + if (cheight<=0) + return; + + dest += dx+dy*dwidth; + source += sx+sy*swidth; + + for (y = 0; y < cheight; y++) + { + for (x = 0; x < cwidth;x++) + { + GCFunc(gc->fgcolour, dest[x], gc->function, source[x], 0xffffff); + } + dest += dwidth; + source += swidth; + } +} + +void XR_ClearArea(xclient_t *cl, xReq *request) +{//FIXME: Should be area rather than entire window + xClearAreaReq *req = (xClearAreaReq *)request; + xwindow_t *wnd; + + if (XS_GetResource(req->window, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->window, X_ClearArea, 0); + return; + } + + if (req->x < 0) + { + if (req->width) + req->width += req->x; + req->x = 0; + } + if (req->y < 0) + { + if (req->height) + req->height += req->y; + req->y = 0; + } + + if (!req->width || req->width + req->x > wnd->width) + { + if (req->width) + req->width = wnd->width - req->x; + req->width = wnd->width - req->x; + } + if (!req->height || req->height + req->y > wnd->height) + { + if (req->height) + req->height = wnd->height - req->y; + req->height = wnd->height - req->y; + } + + XW_ClearArea(wnd, req->x, req->y, req->width, req->height); + + xrefreshed=true; +} + +void XR_CopyArea(xclient_t *cl, xReq *request) //from and to pixmap or drawable. +{ + xCopyAreaReq *req = (xCopyAreaReq *)request; + + xresource_t *drawable; + xgcontext_t *gc; + + + unsigned int *outbuffer; + unsigned int *inbuffer; + int inwidth; + int inheight; + int outwidth; + int outheight; + + if (XS_GetResource(req->gc, &gc) == x_none) + { + X_SendError(cl, BadGC, req->gc, X_PutImage, 0); + return; + } + + + switch (XS_GetResource(req->srcDrawable, &drawable)) + { + default: + X_SendError(cl, BadDrawable, req->srcDrawable, X_PutImage, 0); + return; + + case x_window: + { + xwindow_t *wnd; + wnd = (xwindow_t *)drawable; + if (!wnd->buffer) + { + wnd->buffer = malloc(wnd->width*wnd->height*4); + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + } + + inwidth = wnd->width; + inheight = wnd->height; + inbuffer = (unsigned int *)wnd->buffer; + } + break; + + case x_pixmap: + { + xpixmap_t *pm; + pm = (xpixmap_t *)drawable; + if (!pm->data) + { + pm->data = malloc(pm->width*pm->height*4); + memset(pm->data, rand(), pm->width*pm->height*4); + } + + inwidth = pm->width; + inheight = pm->height; + inbuffer = (unsigned int *)pm->data; + } + break; + } + + switch (XS_GetResource(req->dstDrawable, &drawable)) + { + default: + X_SendError(cl, BadDrawable, req->dstDrawable, X_PutImage, 0); + return; + + case x_window: + { + xwindow_t *wnd; + wnd = (xwindow_t *)drawable; + if (!wnd->buffer) + { + wnd->buffer = malloc(wnd->width*wnd->height*4); + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + } + + outwidth = wnd->width; + outheight = wnd->height; + outbuffer = (unsigned int *)wnd->buffer; + } + break; + + case x_pixmap: + { + xpixmap_t *pm; + pm = (xpixmap_t *)drawable; + if (!pm->data) + { + pm->data = malloc(pm->width*pm->height*4); + memset(pm->data, rand(), pm->width*pm->height*4); + } + + outwidth = pm->width; + outheight = pm->height; + outbuffer = (unsigned int *)pm->data; + } + break; + } + + XW_CopyArea(outbuffer, req->dstX, req->dstY, outwidth, outheight, inbuffer, req->srcX, req->srcY, inwidth, inheight, req->width, req->height, gc); + + xrefreshed=true; +} + +void XR_MapWindow(xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq *)request; + + xwindow_t *wnd; + if (XS_GetResource(req->id, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->id, X_MapWindow, 0); + return; + } + + if (wnd->mapped) + return; + + if (!wnd->overrideredirect && X_NotifcationMaskPresent(wnd, SubstructureRedirectMask, cl)) + { + xEvent ev; + + ev.u.u.type = MapRequest; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.mapNotify.window = wnd->parent->res.id; + ev.u.mapNotify.window = wnd->res.id; + + X_SendNotificationMasked(&ev, wnd, SubstructureRedirectMask); + + return; + } + + if (!wnd->buffer) + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + + wnd->mapped = true; + + { + xEvent ev; + + ev.u.u.type = MapNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.mapNotify.window = wnd->res.id; + ev.u.mapNotify.window = wnd->res.id; + ev.u.mapNotify.override = wnd->overrideredirect; + ev.u.mapNotify.pad1 = 0; + ev.u.mapNotify.pad2 = 0; + ev.u.mapNotify.pad3 = 0; + + X_SendNotificationMasked(&ev, wnd, StructureNotifyMask); + X_SendNotificationMasked(&ev, wnd, SubstructureNotifyMask); + } + +/* { + xEvent ev; + + ev.u.u.type = GraphicsExpose; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.mapNotify.window = wnd->res.id; + ev.u.mapNotify.override = false; + ev.u.mapNotify.pad1 = 0; + ev.u.mapNotify.pad2 = 0; + ev.u.mapNotify.pad3 = 0; + + X_SendNotificationMasked(&ev, wnd, ExposureMask); + }*/ + + XW_ExposeWindowRegionInternal(wnd, 0, 0, wnd->width, wnd->height); + /* + + while(wnd->mapped) + { + xEvent ev; + + ev.u.u.type = VisibilityNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.visibility.window = wnd->res.id; + ev.u.visibility.state = 0; + ev.u.visibility.pad1 = 0; + ev.u.visibility.pad2 = 0; + ev.u.visibility.pad3 = 0; + + X_SendNotificationMasked(&ev, wnd, VisibilityChangeMask); + } + + { + xEvent ev; + + ev.u.u.type = Expose; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.expose.window = wnd->res.id; + ev.u.expose.x = 0; + ev.u.expose.y = 0; + ev.u.expose.width = wnd->width; + ev.u.expose.height = wnd->height; + ev.u.expose.count = false; //other expose events following + ev.u.expose.pad2 = 0; + + X_SendNotificationMasked(&ev, wnd, ExposureMask); + }*/ + + xrefreshed = true; +} + +void XR_UnmapWindow(xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq *)request; + + xwindow_t *wnd; + if (XS_GetResource(req->id, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->id, X_UnmapWindow, 0); + return; + } + + if (!wnd->mapped || !wnd->parent) + return; + + wnd->mapped = false; + xrefreshed=true; + + XW_ExposeWindow(wnd, 0, 0, wnd->width, wnd->height); + + { + xEvent ev; + + ev.u.u.type = UnmapNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.unmapNotify.event = wnd->res.id; + ev.u.unmapNotify.window = wnd->res.id; + ev.u.unmapNotify.fromConfigure = 0; + ev.u.unmapNotify.pad1 = 0; + ev.u.unmapNotify.pad2 = 0; + ev.u.unmapNotify.pad3 = 0; + + X_SendNotificationMasked(&ev, wnd, StructureNotifyMask); + X_SendNotificationMasked(&ev, wnd, SubstructureNotifyMask); + } +} + +void XR_MapSubwindows(xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq *)request; + xwindow_t *wnd; + + if (XS_GetResource(req->id, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->id, X_MapWindow, 0); + return; + } + + for (wnd = wnd->child; wnd; wnd = wnd->sibling) + { + req->id = wnd->res.id; + XR_MapWindow(cl, request); + } +} + +void XR_CreatePixmap(xclient_t *cl, xReq *request) +{ + xCreatePixmapReq *req = (xCreatePixmapReq *)request; + + xwindow_t *wnd; + if (XS_GetResource(req->drawable, &wnd) != x_window) + { + X_SendError(cl, BadDrawable, req->drawable, X_CreatePixmap, 0); + return; + } + + if (XS_GetResource(req->pid, &wnd) != x_none) + { + X_SendError(cl, BadIDChoice, req->pid, X_CreatePixmap, 0); + } + + XS_CreatePixmap(req->pid, cl, req->width, req->height, 24); +} + +void XR_FreePixmap(xclient_t *cl, xReq *request) +{ + xResourceReq *req = (xResourceReq *)request; + xresource_t *pm; + if (XS_GetResource(req->id, &pm) != x_pixmap) + { + X_SendError(cl, BadPixmap, req->id, X_FreePixmap, 0); + return; + } + + XS_DestroyResource(pm); +} + +void XR_PutImage(xclient_t *cl, xReq *request) +{ + unsigned char *out; + unsigned char *in; + xPutImageReq *req = (xPutImageReq *)request; + xresource_t *drawable; + xgcontext_t *gc; + int i; + + int drwidth; + int drheight; + int drdepth; + unsigned char *drbuffer; + + if (XS_GetResource(req->drawable, &drawable) == x_none) + { + X_SendError(cl, BadDrawable, req->drawable, X_PutImage, 0); + return; + } + + if (XS_GetResource(req->gc, &gc) == x_none) + { + X_SendError(cl, BadGC, req->gc, X_PutImage, 0); + return; + } + + + if (drawable->restype == x_window) + { + xwindow_t *wnd; + wnd = (xwindow_t *)drawable; + if (!wnd->buffer) + { + wnd->buffer = malloc(wnd->width*wnd->height*4); + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + } + + drwidth = wnd->width; + drheight = wnd->height; + drbuffer = wnd->buffer; + drdepth = wnd->depth; + } + else if (drawable->restype == x_pixmap) + { + xpixmap_t *pm; + pm = (xpixmap_t *)drawable; + if (!pm->data) + { + pm->data = malloc(pm->width*pm->height*4); + memset(pm->data, rand(), pm->width*pm->height*4); + } + + drwidth = pm->width; + drheight = pm->height; + drbuffer = pm->data; + drdepth = pm->depth; + } + else + { + X_SendError(cl, BadDrawable, req->drawable, X_PutImage, 0); + return; + } + + xrefreshed = true; + + if (req->dstX < 0) + { + req->width += req->dstX; + req->dstX = 0; + } + if (req->dstY < 0) + { + req->height += req->dstY; + req->dstY = 0; + } + + if (req->width > drwidth - req->dstX) + req->width = drwidth - req->dstX; + + if (req->height > drheight - req->dstY) + req->height = drheight - req->dstY; + + in = (qbyte *)(req+1); + + if (req->format == ZPixmap && req->leftPad) + { + X_SendError(cl, BadMatch, req->drawable, X_PutImage, 0); + } + else if (req->format != XYBitmap && req->depth != drdepth) + { +// X_SendError(cl, BadMatch, req->drawable, X_PutImage, 0); + } + else if (req->format == ZPixmap && req->depth == 24) //32 bit network bandwidth (hideous) + { + while(req->height) + { + out = drbuffer + (req->dstX + req->dstY*drwidth)*4; + for (i = 0; i < req->width; i++) + { + out[i*4+0] = in[i*4+0]; + out[i*4+1] = in[i*4+1]; + out[i*4+2] = in[i*4+2]; + } + in += req->width*4; + + req->height--; + req->dstY++; + } + } + else if (req->format == XYPixmap) + { + + } + else if (req->format == XYBitmap) + { //bitwise image... yuck + int bnum; + bnum=0; + if (req->depth == 1) + { + while(req->height) + { + bnum += req->leftPad; + + out = drbuffer + (req->dstX + req->dstY*drwidth)*4; + for (i = 0; i < req->width; i++) + { + if (in[bnum>>8]&(1<<(bnum&7))) + { + out[i*4+0] = 0xff; + out[i*4+1] = 0xff; + out[i*4+2] = 0xff; + } + else + { + out[i*4+0] = 0x00; + out[i*4+1] = 0x00; + out[i*4+2] = 0x00; + } + out[i*4+2] = rand(); + bnum++; + } + bnum += req->width; + + req->height--; + req->dstY++; + } + } + else + X_SendError(cl, BadMatch, req->drawable, X_PutImage, 0); + } + else + { + X_SendError(cl, BadImplementation, req->drawable, X_PutImage, req->format); + } +} +void XR_GetImage(xclient_t *cl, xReq *request) +{ + unsigned char *out; + unsigned char *in; + xGetImageReq *req = (xGetImageReq *)request; + xresource_t *drawable; + int i; + + unsigned int buffer[65535]; + xGetImageReply *rep = (xGetImageReply *)buffer; + + int drwidth; + int drheight; + unsigned char *drbuffer; + + if (XS_GetResource(req->drawable, &drawable) == x_none) + { + X_SendError(cl, BadDrawable, req->drawable, X_PutImage, 0); + return; + } + + + if (drawable->restype == x_window) + { + xwindow_t *wnd; + wnd = (xwindow_t *)drawable; + if (!wnd->buffer) + { + wnd->buffer = malloc(wnd->width*wnd->height*4); + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + } + + drwidth = wnd->width; + drheight = wnd->height; + drbuffer = wnd->buffer; + + rep->visual = 0x22; + } + else if (drawable->restype == x_pixmap) + { + xpixmap_t *pm; + pm = (xpixmap_t *)drawable; + if (!pm->data) + { + pm->data = malloc(pm->width*pm->height*4); + memset(pm->data, rand(), pm->width*pm->height*4); + } + + drwidth = pm->width; + drheight = pm->height; + drbuffer = pm->data; + + rep->visual = 0; + } + else + { + X_SendError(cl, BadDrawable, req->drawable, X_PutImage, 0); + return; + } + + if (req->x < 0) + { + X_SendError(cl, BadValue, req->drawable, X_PutImage, 0); + return; + } + if (req->y < 0) + { + X_SendError(cl, BadValue, req->drawable, X_PutImage, 0); + return; + } + + if (req->width > drwidth - req->x) + { + X_SendError(cl, BadValue, req->drawable, X_PutImage, 0); + return; + } + + if (req->height > drheight - req->y) + { + X_SendError(cl, BadValue, req->drawable, X_PutImage, 0); + return; + } + + out = (qbyte *)(rep+1); + if (req->format == 2) //32 bit network bandwidth (hideous) + { + while(req->height) + { + in = drbuffer + (req->x + req->y*drwidth)*4; + for (i = 0; i < req->width; i++) + { + out[i*4+0] = in[i*4+0]; + out[i*4+1] = in[i*4+1]; + out[i*4+2] = in[i*4+2]; + } + out += req->width*4; + + req->height--; + req->y++; + } + } + else + { + X_SendError(cl, BadImplementation, req->drawable, X_PutImage, req->format); + return; + } + + rep->type = X_Reply; + rep->sequenceNumber = cl->requestnum; + rep->length = (out-(qbyte *)(rep+1)+3)/4; + rep->depth = 24; + rep->pad3 = 0; + rep->pad4 = 0; + rep->pad5 = 0; + rep->pad6 = 0; + rep->pad7 = 0; + + X_SendData(cl, rep, sizeof(*rep)+rep->length*4); +} + +void XW_PolyLine(unsigned int *dbuffer, int dwidth, int dheight, int x1, int x2, int y1, int y2, xgcontext_t *gc) +{ + //FIXME: cap to region. + int len; + + int dx, dy; + + if (x1 < 0) + return; + if (x2 < 0) + return; + if (y1 < 0) + return; + if (y2 < 0) + return; + + if (x1 >= dwidth) + x1 = dwidth-1; + if (x2 >= dwidth) + x2 = dwidth-1; + + if (y1 >= dheight) + y1 = dheight-1; + if (y2 >= dheight) + y2 = dheight-1; + + dx = (x2 - x1); + dy = (y2 - y1); + len = sqrt(dx*dx+dy*dy); + + if (!len) + return; + + x1<<=16; + y1<<=16; + dx=(dx<<16)/len; + dy=(dy<<16)/len; + + for (; len ; len--) + { + GCFunc(gc->fgcolour, dbuffer[(x1>>16)+dwidth*(y1>>16)], gc->function, dbuffer[(x1>>16)+dwidth*(y1>>16)], 0xffffff); + x1+=dx; + y1+=dy; + } +} + +void XR_PolyLine(xclient_t *cl, xReq *request) +{ + xPolyLineReq *req = (xPolyLineReq *)request; + + xresource_t *drawable; + xgcontext_t *gc; + + int pointsleft; + + int drwidth; + int drheight; + unsigned char *drbuffer; + + INT16 *points; + points = (INT16 *)(req+1); + + + + if (XS_GetResource(req->drawable, &drawable) == x_none) + { + X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0); + return; + } + + if (XS_GetResource(req->gc, &gc) == x_none) + { + X_SendError(cl, BadGC, req->gc, X_PolyRectangle, 0); + return; + } + + if (drawable->restype == x_window) + { + xwindow_t *wnd; + wnd = (xwindow_t *)drawable; + if (!wnd->buffer) + { + wnd->buffer = malloc(wnd->width*wnd->height*4); + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + } + + drwidth = wnd->width; + drheight = wnd->height; + drbuffer = wnd->buffer; + } + else if (drawable->restype == x_pixmap) + { + xpixmap_t *pm; + pm = (xpixmap_t *)drawable; + if (!pm->data) + { + pm->data = malloc(pm->width*pm->height*4); + memset(pm->data, rand(), pm->width*pm->height*4); + } + + drwidth = pm->width; + drheight = pm->height; + drbuffer = pm->data; + } + else + { + X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0); + return; + } + + xrefreshed = true; + + if (req->reqType == X_PolySegment) + { + for (pointsleft = req->length/2-3; pointsleft>0; pointsleft--) + { + XW_PolyLine((unsigned int *)drbuffer, drwidth, drheight, points[0], points[2], points[1], points[3], gc); + points+=4; + } + } + else + { + if (req->coordMode) + { + for(pointsleft = req->length-4; pointsleft>0; pointsleft--) + { + points[2] += points[0]; + points[3] += points[1]; + points+=2; + } + points = (INT16 *)(req+1); + } + + for (pointsleft = req->length-4; pointsleft>0; pointsleft--) + { + XW_PolyLine((unsigned int *)drbuffer, drwidth, drheight, points[0], points[2], points[1], points[3], gc); + points+=2; + } + } +} + +void XR_PolyRectangle(xclient_t *cl, xReq *request) +{ + unsigned int *out; + xPolyRectangleReq *req = (xPolyRectangleReq *)request; + xresource_t *drawable; + xgcontext_t *gc; + int i; + + short *rect; + int rectnum; + + int drwidth; + int drheight; + unsigned char *drbuffer; + + + + if (XS_GetResource(req->drawable, &drawable) == x_none) + { + X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0); + return; + } + + if (XS_GetResource(req->gc, &gc) == x_none) + { + X_SendError(cl, BadGC, req->gc, X_PolyRectangle, 0); + return; + } + + if (drawable->restype == x_window) + { + xwindow_t *wnd; + wnd = (xwindow_t *)drawable; + if (!wnd->buffer) + { + wnd->buffer = malloc(wnd->width*wnd->height*4); + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + } + + drwidth = wnd->width; + drheight = wnd->height; + drbuffer = wnd->buffer; + } + else if (drawable->restype == x_pixmap) + { + xpixmap_t *pm; + pm = (xpixmap_t *)drawable; + if (!pm->data) + { + pm->data = malloc(pm->width*pm->height*4); + memset(pm->data, rand(), pm->width*pm->height*4); + } + + drwidth = pm->width; + drheight = pm->height; + drbuffer = pm->data; + } + else + { + X_SendError(cl, BadDrawable, req->drawable, X_PolyRectangle, 0); + return; + } + + xrefreshed = true; + + + rect = (short *)(req+1); + for (rectnum = req->length/2 - 1; rectnum>0; rectnum--) + { + +// Con_Printf("polyrect %i %i %i %i %i\n", req->drawable, rect[0], rect[1], rect[2], rect[3]); + + if (rect[2] < 0) + { + rect[2] *= -1; + } + if (rect[3] < 0) + { + rect[3] *= -1; + } + + if (rect[0] < 0) + { + rect[2] += rect[0]; + rect[0] = 0; + } + if (rect[0] >= drwidth) + rect[0] = drwidth-1; + if (rect[1] < 0) + { + rect[3] += rect[1]; + rect[1] = 0; + } + if (rect[1] >= drheight) + rect[1] = drheight-1; + + if (rect[0] + rect[2] > drwidth) + rect[2] = drwidth - rect[0]; + if (rect[1] + rect[3] > drheight) + rect[3] = drheight - rect[1]; + if (request->reqType == X_PolyFillRectangle) //fill + { + while(rect[3]) + { + out = (unsigned int *)drbuffer + (rect[0] + rect[1]*drwidth); + for (i = 0; i < rect[2]; i++) + { + GCFunc(gc->fgcolour, *(char *)&out[i], gc->function, *(char *)&out[i], 0xffffff); + } + + rect[3]--; + rect[1]++; + } + } + else //outline + { + //top + out = (unsigned int *)drbuffer + (rect[0] + rect[1]*drwidth); + for (i = 1; i < rect[2]-1; i++) + { + GCFunc(gc->fgcolour, out[i], gc->function, out[i], 0xffffff); + } + + //bottom + if (rect[3]-1) + { + out = (unsigned int *)drbuffer + (rect[0] + (rect[1]+rect[3]-1)*drwidth); + for (i = 1; i < rect[2]-1; i++) + { + GCFunc(gc->fgcolour, out[i], gc->function, out[i], 0xffffff); + } + } + + //left + out = (unsigned int *)drbuffer + (rect[0] + rect[1]*drwidth); + for (i = 0; i < rect[3]; i++) + { + GCFunc(gc->fgcolour, out[i*drwidth], gc->function, out[i*drwidth], 0xffffff); + } + + //right + if (rect[2]-1) + { + out = (unsigned int *)drbuffer + (rect[0]+rect[2]-1 + rect[1]*drwidth); + for (i = 0; i < rect[3]; i++) + { + GCFunc(gc->fgcolour, out[i*drwidth], gc->function, out[i*drwidth], 0xffffff); + } + } + } + + rect+=4; + } +} + +void XR_PolyPoint(xclient_t *cl, xReq *request) +{ + xPolyPointReq *req = (xPolyPointReq *)request; + + unsigned int *out; + xresource_t *drawable; + xgcontext_t *gc; + + short *point; + int pointnum; + + int drwidth; + int drheight; + unsigned char *drbuffer; + + short lastpoint[2]; + + if (XS_GetResource(req->drawable, &drawable) == x_none) + { + X_SendError(cl, BadDrawable, req->drawable, X_PolyPoint, 0); + return; + } + + if (XS_GetResource(req->gc, &gc) != x_gcontext) + { + X_SendError(cl, BadGC, req->gc, X_PolyPoint, 0); + return; + } + + if (drawable->restype == x_window) + { + xwindow_t *wnd; + wnd = (xwindow_t *)drawable; + if (!wnd->buffer) + { + wnd->buffer = malloc(wnd->width*wnd->height*4); + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + } + + drwidth = wnd->width; + drheight = wnd->height; + drbuffer = wnd->buffer; + } + else if (drawable->restype == x_pixmap) + { + xpixmap_t *pm; + pm = (xpixmap_t *)drawable; + if (!pm->data) + { + pm->data = malloc(pm->width*pm->height*4); + memset(pm->data, rand(), pm->width*pm->height*4); + } + + drwidth = pm->width; + drheight = pm->height; + drbuffer = pm->data; + } + else + { + X_SendError(cl, BadDrawable, req->drawable, X_PolyPoint, 0); + return; + } + + point = (short*)(req+1); + + if (req->coordMode) //relative + { + lastpoint[0] = 0; //do the absolute stuff + lastpoint[1] = 0; + for (pointnum = 1; pointnum>0; pointnum--) + { + lastpoint[0] += point[0]; //do the absolute stuff + lastpoint[1] += point[1]; + + out = (unsigned int *)drbuffer + lastpoint[0] + lastpoint[1]*drwidth; + GCFunc(gc->fgcolour, *out, gc->function, *out, 0xffffff); + point+=2; + } + + } + else //absolute + { + for (pointnum = req->length-1; pointnum>0; pointnum--) + { + if (!(point[0] < 0 || point[1] < 0 || point[0] >= drwidth || point[1] >= drheight)) + { + out = (unsigned int *)drbuffer + point[0] + point[1]*drwidth; + GCFunc(gc->fgcolour, *out, gc->function, *out, 0xffffff); + } + + point+=2; + } + } +} + +void Draw_CharToDrawable (int num, unsigned int *drawable, int x, int y, int width, int height, xgcontext_t *gc) +{ + int row, col; + qbyte *source; + int drawline; + int i; + + int s, e; + + s = 0; + e = 8; + if (x<0) + s = s - x; + + if (x > width - e) + e = width - x; + + if (s > e) + return; + if (y >= height) + return; + if (y < -8) + return; + if (!draw_chars) + return; + + if (y <= 0) + drawable += x; + else + drawable += (width*y) + x; + + + row = num>>4; + col = num&15; + source = draw_chars + (row<<10) + (col<<3); + if (y < 0) + source -= 128*y; + + drawline = height-y; + if (drawline > 8) + drawline = 8; + + if (y < 0) + drawline += y; + + while (drawline--) + { + for (i=s ; ifgcolour, drawable[i], gc->function, drawable[i], d_8to24rgbtable[source[i]]); + drawable[i] = gc->fgcolour;//d_8to24rgbtable[source[i]]; + source += 128; + drawable += width; + } + +} + +void XR_PolyText(xclient_t *cl, xReq *request) +{ + unsigned char *str; + + xPolyTextReq *req = (xPolyTextReq*)request; + + xresource_t *drawable; + xgcontext_t *gc; + + + int drwidth; + int drheight; + unsigned char *drbuffer; + + short charnum; + short numchars; + + int xpos, ypos; + + if (XS_GetResource(req->drawable, &drawable) == x_none) + { + X_SendError(cl, BadDrawable, req->drawable, req->reqType, 0); + return; + } + + if (XS_GetResource(req->gc, &gc) != x_gcontext) + { + X_SendError(cl, BadGC, req->gc, req->reqType, 0); + return; + } + + if (drawable->restype == x_window) + { + xwindow_t *wnd; + wnd = (xwindow_t *)drawable; + if (!wnd->buffer) + { + wnd->buffer = malloc(wnd->width*wnd->height*4); + XW_ClearArea(wnd, 0, 0, wnd->width, wnd->height); + } + + drwidth = wnd->width; + drheight = wnd->height; + drbuffer = wnd->buffer; + } + else if (drawable->restype == x_pixmap) + { + xpixmap_t *pm; + pm = (xpixmap_t *)drawable; + if (!pm->data) + { + pm->data = malloc(pm->width*pm->height*4); + memset(pm->data, rand(), pm->width*pm->height*4); + } + + drwidth = pm->width; + drheight = pm->height; + drbuffer = pm->data; + } + else + { + X_SendError(cl, BadDrawable, req->drawable, req->reqType, 0); + return; + } + + xrefreshed = true; + + xpos = req->x; + ypos = req->y-4; + + str = (char*)(req+1); + + if (req->reqType == X_ImageText16 || req->reqType == X_ImageText8) + { + while(1) + { + charnum = 0; + if (req->reqType == X_ImageText16) + charnum |= (*str++)<<8; + charnum |= *str++; + if (!charnum) + return; + + Draw_CharToDrawable(charnum, (unsigned int *)drbuffer, xpos, ypos, drwidth, drheight, gc); + + xpos += 8; + } + } + else + { + numchars = *(short*) str; + str+=2; + while(1) + { + charnum = 0; + if (req->reqType == X_PolyText16) + charnum |= (*str++)<<8; + charnum |= *str++; + if (!numchars--) + return; + + Draw_CharToDrawable(charnum, (unsigned int *)drbuffer, xpos, ypos, drwidth, drheight, gc); + + xpos += 8; + } + } +} + +void XR_OpenFont(xclient_t *cl, xReq *request) //basically ignored. We only support one font... +{ + xOpenFontReq *req = (xOpenFontReq *)request; + char *name; + + name = (char *)(req+1); + +} + +void XR_ListFonts(xclient_t *cl, xReq *request) //basically ignored. We only support one font... +{ + xListFontsReq *req = (xListFontsReq *)request; + int buffer[256]; + xListFontsReply *reply = (xListFontsReply *)buffer; + + reply->type = X_Reply; + reply->sequenceNumber = cl->requestnum; + reply->length = 0; + reply->nFonts = 0; + + X_SendData(cl, reply, sizeof(xGenericReply)+reply->length*4); +} + +void XR_QueryFont(xclient_t *cl, xReq *request) //basically ignored. We only support one font... +{ + xResourceReq *req = (xResourceReq *)request; + char buffer[8192]; + xQueryFontReply *rep = (xQueryFontReply *)buffer; + + rep->type = X_Reply; + rep->pad1 = 0; + rep->sequenceNumber = cl->requestnum; + rep->length = 0; /* definitely > 0, even if "nCharInfos" is 0 */ + + rep->minBounds.leftSideBearing = 0; + rep->minBounds.rightSideBearing = 0; + rep->minBounds.characterWidth = 8; + rep->minBounds.ascent = 4; + rep->minBounds.descent = 4; + rep->minBounds.attributes = 0; + +#ifndef WORD64 + rep->walign1 = 0; +#endif + rep->maxBounds.leftSideBearing = 0; + rep->maxBounds.rightSideBearing = 0; + rep->maxBounds.characterWidth = 8; + rep->maxBounds.ascent = 4; + rep->maxBounds.descent = 4; + rep->maxBounds.attributes = 0; +#ifndef WORD64 + rep->walign2 = 0; +#endif + rep->minCharOrByte2 = 0; + rep->maxCharOrByte2 = 0; + rep->defaultChar = 0; + rep->nFontProps = 0; /* followed by this many xFontProp structures */ + rep->drawDirection = 0; + rep->minByte1 = 0; + rep->maxByte1 = 0; + rep->allCharsExist = 1; + rep->fontAscent = 4; + rep->fontDescent = 4; + rep->nCharInfos = 0; /* followed by this many xCharInfo structures */ + + rep->length = ((sizeof(xQueryFontReply) - sizeof(xGenericReply)) + rep->nFontProps*sizeof(xFontProp) + rep->nCharInfos*sizeof(xCharInfo))/4; + + X_SendData(cl, rep, sizeof(xGenericReply)+rep->length*4); +} + +//esentually just throw it back at them. +void XR_AllocColor(xclient_t *cl, xReq *request) +{ + xAllocColorReq *req = (xAllocColorReq *)request; + xAllocColorReply rep; + + rep.type = X_Reply; + rep.pad1 = 0; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.red = req->red; + rep.green = req->green; + rep.blue = req->blue; + rep.pad2 = 0; + rep.pixel = ((req->blue>>8)<<16) | ((req->green>>8)<<8) | (req->red>>8); + rep.pad3 = 0; + rep.pad4 = 0; + rep.pad5 = 0; + + X_SendData(cl, &rep, sizeof(rep)); +} + +void XR_LookupColor(xclient_t *cl, xReq *request) +{ + typedef struct { + char *name; + float r, g, b; + } colour_t; + char colourname[256]; + colour_t *c, colour[] = { + {"black", 0,0,0}, + {"grey", 0.5,0.5,0.5}, + {"gray", 0.5,0.5,0.5}, //wmaker uses this one. humour it. + {"gray90", 0.9,0.9,0.9}, + {"gray80", 0.8,0.8,0.8}, + {"gray70", 0.7,0.7,0.7}, + {"gray60", 0.6,0.6,0.6}, + {"gray50", 0.5,0.5,0.5}, + {"gray40", 0.4,0.4,0.4}, + {"gray30", 0.3,0.3,0.3}, + {"gray20", 0.2,0.2,0.2}, + {"gray10", 0.1,0.1,0.1}, + {"grey10", 0.1,0.1,0.1}, + {"white", 1,1,1}, + {"red", 1,0,0}, + {"green", 0,1,0}, + {"blue", 0,0,1}, + {"blue4", 0,0,0.4}, + {NULL} + }; + + xLookupColorReq *req = (xLookupColorReq *)request; + xLookupColorReply rep; + + strncpy(colourname, (char *)(req+1), req->nbytes); + colourname[req->nbytes] = '\0'; + + for (c = colour; c->name; c++) + { + if (!stricmp(c->name, colourname)) + { + break; + } + } + + if (!c->name) + { + X_SendError(cl, BadName, 0, X_LookupColor, 0); + return; + } + + + rep.type = X_Reply; + rep.pad1 = 0; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.exactRed = c->r*0xffff; + rep.exactGreen = c->g*0xffff; + rep.exactBlue = c->b*0xffff; + rep.screenRed = rep.exactRed; + rep.screenGreen = rep.exactGreen; + rep.screenBlue = rep.exactBlue; + rep.pad3 = 0; + rep.pad4 = 0; + rep.pad5 = 0; + + X_SendData(cl, &rep, sizeof(rep)); +} + +//get's keyboard status stuff. +void XR_GetKeyboardControl(xclient_t *cl, xReq *request) +{ + xGetKeyboardControlReply rep; + + rep.type = X_Reply; + rep.globalAutoRepeat = false; + rep.sequenceNumber = cl->requestnum; + rep.length = 5; + rep.ledMask = 0; + rep.keyClickPercent = 0; + rep.bellPercent = 0; + rep.bellPitch = 0; + rep.bellDuration = 0; + rep.pad = 0; + memset(rep.map, 0, sizeof(rep.map)); //per key map + + X_SendData(cl, &rep, sizeof(rep)); +} + +void XR_WarpPointer(xclient_t *cl, xReq *request) +{ +// xWarpPointerReq *req = (xWarpPointerReq *)request; +// req->m +} + +#ifdef XBigReqExtensionName +void XR_BigReq(xclient_t *cl, xReq *request) +{ + xBigReqEnableReply rep; + + rep.type = X_Reply; + rep.pad0 = 0; + rep.sequenceNumber = cl->requestnum; + rep.length = 0; + rep.max_request_size = 65535*1000; + rep.pad1 = 0; + rep.pad2 = 0; + rep.pad3 = 0; + rep.pad4 = 0; + rep.pad5 = 0; + + X_SendData(cl, &rep, sizeof(rep)); +} +#endif + +#define MAXREQUESTSIZE 65535 + +//cl -> cl protocol +void XR_SendEvent (xclient_t *cl, xReq *request) +{ + int count; + xSendEventReq *req = (xSendEventReq *)request; + xwindow_t *wnd; + + if (XS_GetResource(req->destination, &wnd) != x_window) + { + X_SendError(cl, BadWindow, req->destination, X_SendEvent, 0); + return; + } + + if (!req->eventMask) //goes to owner. + { + req->event.u.u.sequenceNumber = cl->requestnum; + X_SendData(wnd->res.owner, &req->event, sizeof(req->event)); + } + else + { + xnotificationmask_t *nm; + count = 0; + while(!count) + { + for (nm = wnd->notificationmask; nm; nm = nm->next) + { + if (!(nm->mask & req->eventMask)) + continue; + cl = nm->client; + + if (cl->stillinitialising) + continue; + + count++; + + if (cl->tobedropped) + continue; + if (cl->outbufferlen > MAXREQUESTSIZE*4) + { + cl->tobedropped = true; + continue; + } + + req->event.u.u.sequenceNumber = cl->requestnum; + X_SendData(cl, &req->event, sizeof(xEvent)); + } + if (req->propagate) + wnd = wnd->parent; + else + break; + } + } +} + +void XR_GrabServer (xclient_t *cl, xReq *request) +{ + xgrabbedclient = cl; +} +void XR_UngrabServer (xclient_t *cl, xReq *request) +{ + xgrabbedclient = NULL; +} + +xclient_t *xpointergrabclient; +xwindow_t *xpgrabbedwindow; +xwindow_t *xpconfinewindow; +void XR_GrabPointer (xclient_t *cl, xReq *request) +{ + xGrabPointerReq *req = (xGrabPointerReq *)request; + xGrabPointerReply reply; + + reply.type = X_Reply; + reply.status = 0; + reply.sequenceNumber = cl->requestnum; + reply.length = 0; + reply.pad1 = 0; + reply.pad2 = 0; + reply.pad3 = 0; + reply.pad4 = 0; + reply.pad5 = 0; + reply.pad6 = 0; + + if (xpointergrabclient && xpointergrabclient != cl) + { //you can't have it. +// if (pointerstatus == Frozen) +// reply.status = GrabFrozen; +// else + reply.status = AlreadyGrabbed; + X_SendData(cl, &reply, sizeof(reply)); + return; + } + + xpointergrabclient = cl; + XS_GetResource(req->grabWindow, &xpgrabbedwindow); + XS_GetResource(req->confineTo, &xpconfinewindow); + + X_EvalutateCursorOwner(NotifyGrab); + + + reply.status = GrabSuccess; + X_SendData(cl, &reply, sizeof(reply)); +} +void XR_UngrabPointer (xclient_t *cl, xReq *request) +{ + xpointergrabclient = NULL; + xpgrabbedwindow = NULL; + xpconfinewindow = NULL; + + X_EvalutateCursorOwner(NotifyUngrab); +} + +void XR_NoOperation (xclient_t *cl, xReq *request) +{ +} + +void X_InitRequests(void) +{ + int ExtentionCode = X_NoOperation+1; + + memset(XRequests, 0, sizeof(XRequests)); + + XRequests[X_QueryExtension] = XR_QueryExtension; + XRequests[X_ListExtensions] = XR_ListExtensions; + XRequests[X_GetProperty] = XR_GetProperty; + XRequests[X_ChangeProperty] = XR_ChangeProperty; + XRequests[X_DeleteProperty] = XR_DeleteProperty; + XRequests[X_ListProperties] = XR_ListProperties; + XRequests[X_SetInputFocus] = XR_SetInputFocus; + XRequests[X_GetInputFocus] = XR_GetInputFocus; + XRequests[X_QueryBestSize] = XR_QueryBestSize; + XRequests[X_CreateWindow] = XR_CreateWindow; + XRequests[X_DestroyWindow] = XR_DestroyWindow; + XRequests[X_QueryTree] = XR_QueryTree; + XRequests[X_ChangeWindowAttributes] = XR_ChangeWindowAttributes; + XRequests[X_GetWindowAttributes] = XR_GetWindowAttributes; + XRequests[X_CreateGC] = XR_CreateGC; + XRequests[X_ChangeGC] = XR_ChangeGC; + XRequests[X_FreeGC] = XR_FreeGC; + XRequests[X_CreatePixmap] = XR_CreatePixmap; + XRequests[X_FreePixmap] = XR_FreePixmap; + XRequests[X_MapWindow] = XR_MapWindow; + XRequests[X_MapSubwindows] = XR_MapSubwindows; + XRequests[X_UnmapWindow] = XR_UnmapWindow; + XRequests[X_ClearArea] = XR_ClearArea; + XRequests[X_CopyArea] = XR_CopyArea; + XRequests[X_InternAtom] = XR_InternAtom; + XRequests[X_GetAtomName] = XR_GetAtomName; + XRequests[X_PutImage] = XR_PutImage; + XRequests[X_GetImage] = XR_GetImage; + XRequests[X_PolyRectangle] = XR_PolyRectangle; + XRequests[X_PolyFillRectangle] = XR_PolyRectangle; + XRequests[X_PolyPoint] = XR_PolyPoint; + XRequests[X_PolyLine] = XR_PolyLine; + XRequests[X_PolySegment] = XR_PolyLine; + XRequests[X_QueryPointer] = XR_QueryPointer; + XRequests[X_GetKeyboardMapping] = XR_GetKeyboardMapping; + XRequests[X_GetKeyboardControl] = XR_GetKeyboardControl; + XRequests[X_AllocColor] = XR_AllocColor; + XRequests[X_LookupColor] = XR_LookupColor; + XRequests[X_GetGeometry] = XR_GetGeometry; + + XRequests[X_WarpPointer] = XR_WarpPointer; + + XRequests[X_ListFonts] = XR_ListFonts; + XRequests[X_OpenFont] = XR_OpenFont; + XRequests[X_QueryFont] = XR_QueryFont; + XRequests[X_PolyText8] = XR_PolyText; + XRequests[X_PolyText16] = XR_PolyText; + XRequests[X_ImageText8] = XR_PolyText; + XRequests[X_ImageText16] = XR_PolyText; + + XRequests[X_ConfigureWindow] = XR_ConfigureWindow; + XRequests[X_ReparentWindow] = XR_ReparentWindow; + + XRequests[X_GrabServer] = XR_GrabServer; + XRequests[X_UngrabServer] = XR_UngrabServer; + XRequests[X_GrabPointer] = XR_GrabPointer; + XRequests[X_UngrabPointer] = XR_UngrabPointer; + + + XRequests[X_SendEvent] = XR_SendEvent; + + XRequests[X_GetSelectionOwner] = XR_GetSelectionOwner; + XRequests[X_SetSelectionOwner] = XR_SetSelectionOwner; + + XRequests[X_GrabKey] = XR_NoOperation; + XRequests[X_AllowEvents] = XR_NoOperation; + XRequests[X_FillPoly] = XR_PolyLine; + XRequests[X_NoOperation] = XR_NoOperation; + +#ifdef XBigReqExtensionName + X_BigReqCode=ExtentionCode++; + XRequests[X_BigReqCode] = XR_BigReq; +#endif +} + +#endif diff --git a/engine/qux/x_res.c b/engine/qux/x_res.c new file mode 100644 index 000000000..c36ea5183 --- /dev/null +++ b/engine/qux/x_res.c @@ -0,0 +1,541 @@ +#include "bothdefs.h" + +#ifndef NOMEDIA + +#include "qux.h" +#include "hash.h" + +void *Hash_AddKey2(hashtable_t *table, int key, void *data, bucket_t *buck); //fixme; move to hash.h +void Hash_RemoveKey(hashtable_t *table, int key); + +#undef malloc +#undef free + +#define free BZ_Free +#define malloc BZ_Malloc + +hashtable_t restable; +bucket_t *resbuckets[1357]; //strange number to help the hashing. + +xwindow_t *rootwindow; + +xresource_t *resources; + +qbyte *xscreen; +short xscreenwidth; +short xscreenheight; + +int baseres; + +void XS_ClearParent(xwindow_t *wnd); + +int XS_GetResource(int id, void **data) +{ + xresource_t *res; + if (id < 0) + return x_none; + + res = Hash_GetKey(&restable, id); + + if (res) + { + if (data) + *data = res; + return res->restype; + } + return x_none; +} + +Atom XS_FindAtom(char *name) +{ + xresource_t *res; + + for (res = resources; res; res = res->next) + { + if (res->restype == x_atom) + { + if (!strcmp(((xatom_t*)res)->atomname, name)) + return res->id; + } + } + + return None; +} + +void XS_DestroyResource(xresource_t *res) +{ + qboolean nofree = false; + if (res->restype == x_pixmap) + { + xpixmap_t *pm = (xpixmap_t *)res; + + if (pm->references) + nofree = true; + if (!pm->linked) + return; + + pm->linked = false; + } + if (res->restype == x_window) + { + extern xwindow_t *xfocusedwindow, *xpgrabbedwindow; + xwindow_t *wnd = (xwindow_t *)res; + while(wnd->child) + XS_DestroyResource((xresource_t *)(wnd->child)); + + if (xfocusedwindow == wnd) + xfocusedwindow = wnd->parent; + if (xpgrabbedwindow == wnd) + xpgrabbedwindow = wnd->parent; + + + if (wnd->mapped) + { + XW_ExposeWindow(wnd, 0, 0, wnd->width, wnd->height); + } + + + { + xEvent ev; + + xrefreshed = true; + + ev.u.u.type = DestroyNotify; + ev.u.u.detail = 0; + ev.u.u.sequenceNumber = 0; + ev.u.destroyNotify.event = wnd->res.id; //should be the window that has the recieve attribute. + ev.u.destroyNotify.window = wnd->res.id; + X_SendNotificationMasked (&ev, wnd, StructureNotifyMask); + X_SendNotificationMasked (&ev, wnd, SubstructureNotifyMask); + } + + XS_ClearParent(wnd); + } + if (!res->prev) + { + resources = res->next; + if (res->next) + res->next->prev = NULL; + } + else + { + res->prev->next = res->next; + res->next->prev = res->prev; + } + +// XS_FindAtom(""); + + Hash_RemoveKey(&restable, res->id); + if (!nofree) + free(res); + +// XS_FindAtom(""); +} + +void XS_DestroyResourcesOfClient(xclient_t *cl) +{ + xresource_t *res; + xnotificationmask_t *nm, *nm2; + + if (xgrabbedclient == cl) + xgrabbedclient = NULL; + if (xpointergrabclient == cl) + xpointergrabclient = NULL; + + for (res = resources; res;) + { + if (res->restype == x_window) + { //clear the event masks + nm = ((xwindow_t *)res)->notificationmask; + if (nm) + { + if (nm->client == cl) + { + ((xwindow_t *)res)->notificationmask = nm->next; + free(nm); + } + else + { + for (; nm->next; nm = nm->next) + { + if (nm->next->client == cl || !cl) + { + nm2 = nm->next; + nm->next = nm->next->next; + free(nm2); + break; + } + } + } + } + } + if (res->owner == cl) + { + XS_DestroyResource(res); + + res = resources; //evil!!! + continue; + } + res = res->next; + } +} + +void XS_LinkResource(xresource_t *res) +{ + res->next = resources; + resources = res; + + res->prev = NULL; + if (res->next) + res->next->prev = res; + Hash_AddKey2(&restable, res->id, res, malloc(sizeof(bucket_t))); +} + +xatom_t *XS_CreateAtom(Atom atomid, char *name, xclient_t *owner) +{ + xatom_t *at; + at = malloc(sizeof(xatom_t)+strlen(name)); + at->res.owner = owner; + at->res.restype = x_atom; + at->res.id = atomid; + strcpy(at->atomname, name); + + XS_LinkResource(&at->res); + + return at; +} + +void XS_ClearParent(xwindow_t *wnd) +{ + xwindow_t *sib; + + xwindow_t *parent = wnd->parent; + + if (!parent) + return; + + wnd->parent = NULL; + + if (parent->child == wnd) + { + parent->child = wnd->sibling; + return; + } + + for (sib = parent->child; sib; sib = sib->sibling) + { + if (sib->sibling == wnd) + { + sib->sibling = wnd->sibling; + return; + } + } +} + +int XS_GetProperty(xwindow_t *wnd, Atom atomid, Atom *atomtype, char *output, int maxlen, int offset, int *extrabytes, int *format) +{ + xproperty_t *xp; + for (xp = wnd->properties; xp; xp = xp->next) + { + if (xp->atomid == atomid) + { + if (maxlen > xp->datalen - offset) + maxlen = xp->datalen - offset; + memcpy(output, xp->data + offset, maxlen); + if (maxlen < 0) + maxlen = 0; + *extrabytes = xp->datalen - maxlen - offset; + *format = xp->format; + *atomtype = xp->type; + if (*extrabytes < 0) + *extrabytes = 0; + return maxlen; + } + } + *format = 0; + *extrabytes = 0; + *atomtype = None; + return 0; +} + +void XS_DeleteProperty(xwindow_t *wnd, Atom atomid) +{ + xproperty_t *xp, *prev = NULL; + for (xp = wnd->properties; xp; xp = xp->next) + { + if (xp->atomid == atomid) + { + if (prev) + prev->next = xp->next; + else + wnd->properties = xp->next; + + free(xp); + return; + } + prev = xp; + } +} + +void XS_SetProperty(xwindow_t *wnd, Atom atomid, Atom atomtype, char *data, int datalen, int format) +{ + xproperty_t *prop; + XS_DeleteProperty(wnd, atomid); + + prop = malloc(sizeof(xproperty_t) + datalen); + prop->atomid = atomid; + prop->format = format; + prop->type = atomtype; + + memcpy(prop->data, data, datalen); + prop->data[datalen] = '\0'; + prop->datalen = datalen; + + prop->next = wnd->properties; + wnd->properties = prop; +} + +void XS_RaiseWindow(xwindow_t *wnd) +{ + xwindow_t *bigger; + if (!wnd->parent) + return; + + bigger = wnd->parent->child; + if (bigger == wnd) + { + wnd->parent->child = wnd->sibling; + bigger = wnd->sibling; + if (!bigger) + { + wnd->parent->child = wnd; + //ah well, it was worth a try + return; + } + } + else + { + while(bigger->sibling != wnd) + bigger = bigger->sibling; + + bigger->sibling = wnd->sibling; //unlink + } + while(bigger->sibling) + bigger = bigger->sibling; + + bigger->sibling = wnd; + wnd->sibling = NULL; +} +void XS_SetParent(xwindow_t *wnd, xwindow_t *parent) +{ + XS_ClearParent(wnd); + if (parent) + { + wnd->sibling = parent->child; + parent->child = wnd; + } + wnd->parent = parent; + + XS_RaiseWindow(wnd); +} + +xwindow_t *XS_CreateWindow(int wid, xclient_t *owner, xwindow_t *parent, short x, short y, short width, short height) +{ + xwindow_t *neww; + neww = malloc(sizeof(xwindow_t)); + memset(neww, 0, sizeof(xwindow_t)); + + neww->res.id = wid; + neww->res.owner = owner; + neww->res.restype = x_window; + + if (width < 0) + { + width*=-1; + x-=width; + } + if (height < 0) + { + height*=-1; + x-=height; + } + + neww->xpos = (CARD16)x; + neww->ypos = (CARD16)y; + neww->width = width; + neww->height = height; + neww->buffer = NULL; + + XS_SetParent(neww, parent); + + XS_LinkResource(&neww->res); + return neww; +} + +xgcontext_t *XS_CreateGContext(int id, xclient_t *owner, xresource_t *drawable) +{ + xgcontext_t *newgc; + newgc = malloc(sizeof(xgcontext_t)); + memset(newgc, 0, sizeof(xgcontext_t)); + + newgc->res.id = id; + newgc->res.owner = owner; + newgc->res.restype = x_gcontext; + + newgc->function = GXcopy; + newgc->bgcolour = 0xffffff; + newgc->fgcolour = 0; + + XS_LinkResource(&newgc->res); + + return newgc; +} + +xpixmap_t *XS_CreatePixmap(int id, xclient_t *owner, int width, int height, int depth) +{ + xpixmap_t *newpm; + newpm = malloc(sizeof(xpixmap_t) + (width*height*4)); + memset(newpm, 0, sizeof(xpixmap_t)); + + newpm->res.id = id; + newpm->res.owner = owner; + newpm->res.restype = x_pixmap; + + if (id>0) + { + newpm->linked=true; //destroyed when last reference AND this are cleared + XS_LinkResource(&newpm->res); + } + + newpm->data = (qbyte*)(newpm+1); + newpm->width = width; + newpm->height = height; + newpm->depth = depth; + + return newpm; +} + +int XS_NewResource (void) +{ + return baseres++; +} +void XS_CreateInitialResources(void) +{ + static xpixmap_t pm; + static unsigned int rawpm[8*9] = { + 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, + 0x000000, 0x000000, 0xffffff, 0x000000, 0xffffff, 0x000000, 0x000000, 0x000000, + 0x000000, 0xffffff, 0x000000, 0x000000, 0x000000, 0xffffff, 0x000000, 0x000000, + 0xffffff, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xffffff, 0x000000, + 0xffffff, 0x000000, 0xffffff, 0xffffff, 0xffffff, 0x000000, 0xffffff, 0x000000, + 0xffffff, 0x000000, 0x000000, 0xffffff, 0x000000, 0x000000, 0xffffff, 0x000000, + 0x000000, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff, 0x000000, 0x000000, + 0x000000, 0x000000, 0x000000, 0xffffff, 0x000000, 0x000000, 0x000000, 0x000000, + 0x000000, 0x000000, 0x000000, 0xffffff, 0x000000, 0x000000, 0x000000, 0x000000}; + + if (baseres) + return; + baseres=1; + + xscreenwidth = 640; + xscreenheight = 480; + xscreen = realloc(xscreen, xscreenwidth*4 * xscreenheight); + + XS_DestroyResourcesOfClient(NULL); + + memset(resbuckets, 0, sizeof(resbuckets)); + Hash_InitTable(&restable, sizeof(resbuckets)/sizeof(resbuckets[0]), resbuckets); + + resources = NULL; + + + XS_CreateAtom(baseres++, "PRIMARY", NULL); + XS_CreateAtom(baseres++, "SECONDARY", NULL); + XS_CreateAtom(baseres++, "ARC", NULL); + XS_CreateAtom(baseres++, "ATOM", NULL); + XS_CreateAtom(baseres++, "BITMAP", NULL); + XS_CreateAtom(baseres++, "CARDINAL", NULL); + XS_CreateAtom(baseres++, "COLORMAP", NULL); + XS_CreateAtom(baseres++, "CURSOR", NULL); + XS_CreateAtom(baseres++, "CUT_BUFFER0", NULL); + XS_CreateAtom(baseres++, "CUT_BUFFER1", NULL); + XS_CreateAtom(baseres++, "CUT_BUFFER2", NULL); + XS_CreateAtom(baseres++, "CUT_BUFFER3", NULL); + XS_CreateAtom(baseres++, "CUT_BUFFER4", NULL); + XS_CreateAtom(baseres++, "CUT_BUFFER5", NULL); + XS_CreateAtom(baseres++, "CUT_BUFFER6", NULL); + XS_CreateAtom(baseres++, "CUT_BUFFER7", NULL); + XS_CreateAtom(baseres++, "DRAWABLE", NULL); + XS_CreateAtom(baseres++, "FONT", NULL); + XS_CreateAtom(baseres++, "INTEGER", NULL); + XS_CreateAtom(baseres++, "PIXMAP", NULL); + XS_CreateAtom(baseres++, "POINT", NULL); + XS_CreateAtom(baseres++, "RECTANGLE", NULL); + XS_CreateAtom(baseres++, "RESOURCE_MANAGER", NULL); + XS_CreateAtom(baseres++, "RGB_COLOR_MAP", NULL); + XS_CreateAtom(baseres++, "RGB_BEST_MAP", NULL); + XS_CreateAtom(baseres++, "RGB_BLUE_MAP", NULL); + XS_CreateAtom(baseres++, "RGB_DEFAULT_MAP", NULL); + XS_CreateAtom(baseres++, "RGB_GRAY_MAP", NULL); + XS_CreateAtom(baseres++, "RGB_GREEN_MAP", NULL); + XS_CreateAtom(baseres++, "RGB_RED_MAP", NULL); + XS_CreateAtom(baseres++, "STRING", NULL); + XS_CreateAtom(baseres++, "VISUALID", NULL); + XS_CreateAtom(baseres++, "WINDOW", NULL); + XS_CreateAtom(baseres++, "WM_COMMAND", NULL); + XS_CreateAtom(baseres++, "WM_HINTS", NULL); + XS_CreateAtom(baseres++, "WM_CLIENT_MACHINE", NULL); + XS_CreateAtom(baseres++, "WM_ICON_NAME", NULL); + XS_CreateAtom(baseres++, "WM_ICON_SIZE", NULL); + XS_CreateAtom(baseres++, "WM_NAME", NULL); + XS_CreateAtom(baseres++, "WM_NORMAL_HINTS", NULL); + XS_CreateAtom(baseres++, "WM_SIZE_HINTS", NULL); + XS_CreateAtom(baseres++, "WM_ZOOM_HINTS", NULL); + XS_CreateAtom(baseres++, "MIN_SPACE", NULL); + XS_CreateAtom(baseres++, "NORM_SPACE", NULL); + XS_CreateAtom(baseres++, "MAX_SPACE", NULL); + XS_CreateAtom(baseres++, "END_SPACE", NULL); + XS_CreateAtom(baseres++, "SUPERSCRIPT_X", NULL); + XS_CreateAtom(baseres++, "SUPERSCRIPT_Y", NULL); + XS_CreateAtom(baseres++, "SUBSCRIPT_X", NULL); + XS_CreateAtom(baseres++, "SUBSCRIPT_Y", NULL); + XS_CreateAtom(baseres++, "UNDERLINE_POSITION", NULL); + XS_CreateAtom(baseres++, "UNDERLINE_THICKNESS", NULL); + XS_CreateAtom(baseres++, "STRIKEOUT_ASCENT", NULL); + XS_CreateAtom(baseres++, "STRIKEOUT_DESCENT", NULL); + XS_CreateAtom(baseres++, "ITALIC_ANGLE", NULL); + XS_CreateAtom(baseres++, "X_HEIGHT", NULL); + XS_CreateAtom(baseres++, "QUAD_WIDTH", NULL); + XS_CreateAtom(baseres++, "WEIGHT", NULL); + XS_CreateAtom(baseres++, "POINT_SIZE", NULL); + XS_CreateAtom(baseres++, "RESOLUTION", NULL); + XS_CreateAtom(baseres++, "COPYRIGHT", NULL); + XS_CreateAtom(baseres++, "NOTICE", NULL); + XS_CreateAtom(baseres++, "FONT_NAME", NULL); + XS_CreateAtom(baseres++, "FAMILY_NAME", NULL); + XS_CreateAtom(baseres++, "FULL_NAME", NULL); + XS_CreateAtom(baseres++, "CAP_HEIGHT", NULL); + XS_CreateAtom(baseres++, "WM_CLASS", NULL); + XS_CreateAtom(baseres++, "WM_TRANSIENT_FOR", NULL); + + rootwindow = XS_CreateWindow(baseres++, NULL, NULL, 0, 0, xscreenwidth, xscreenheight); + rootwindow->mapped = true; + + + memset(&pm, 0, sizeof(pm)); + pm.linked = true; + pm.data = (qbyte *)rawpm; + pm.depth = 24; + pm.width = 8; + pm.height = 9; + pm.references = 2; + pm.res.restype = x_pixmap; + + rootwindow->backpixmap = ± + + XW_ClearArea(rootwindow, 0, 0, rootwindow->width, rootwindow->height); + + xrefreshed = true; +} + +#endif