summaryrefslogtreecommitdiff
path: root/Xext
diff options
context:
space:
mode:
authorKaleb Keithley <kaleb@freedesktop.org>2003-11-14 16:49:22 +0000
committerKaleb Keithley <kaleb@freedesktop.org>2003-11-14 16:49:22 +0000
commitd568221710959cf7d783e6ff0fb80fb43a231124 (patch)
tree8d6f039393294c6ffac8533639afdebe5d68bfc1 /Xext
parent9508a382f8a9f241dab097d921b6d290c1c3a776 (diff)
XFree86 4.3.0.1
Diffstat (limited to 'Xext')
-rw-r--r--Xext/EVI.c10
-rw-r--r--Xext/appgroup.c18
-rw-r--r--Xext/bigreq.c18
-rw-r--r--Xext/cup.c17
-rw-r--r--Xext/dpms.c88
-rw-r--r--Xext/dpmsstubs.c8
-rw-r--r--Xext/mbuf.c558
-rw-r--r--Xext/mbufbf.c1
-rw-r--r--Xext/mbufpx.c1
-rw-r--r--Xext/mitmisc.c24
-rw-r--r--Xext/panoramiX.c1301
-rw-r--r--Xext/panoramiXSwap.c89
-rw-r--r--Xext/panoramiXprocs.c3996
-rw-r--r--Xext/security.c25
-rw-r--r--Xext/shape.c370
-rw-r--r--Xext/shm.c719
-rw-r--r--Xext/sleepuntil.c48
-rw-r--r--Xext/sync.c298
-rw-r--r--Xext/xcmisc.c32
-rw-r--r--Xext/xprint.c578
-rw-r--r--Xext/xtest.c52
-rw-r--r--Xext/xtest1dd.c127
-rw-r--r--Xext/xtest1di.c87
23 files changed, 4332 insertions, 4133 deletions
diff --git a/Xext/EVI.c b/Xext/EVI.c
index 8ccc31af2..aa3734b02 100644
--- a/Xext/EVI.c
+++ b/Xext/EVI.c
@@ -21,6 +21,8 @@ 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/programs/Xserver/Xext/EVI.c,v 3.9 2001/10/28 03:32:50 tsi Exp $ */
+
#include "X.h"
#include "Xproto.h"
#include "dixstruct.h"
@@ -34,7 +36,7 @@ static EviPrivPtr eviPriv;
static int
ProcEVIQueryVersion(ClientPtr client)
{
- REQUEST(xEVIQueryVersionReq);
+ /* REQUEST(xEVIQueryVersionReq); */
xEVIQueryVersionReply rep;
register int n;
REQUEST_SIZE_MATCH (xEVIQueryVersionReq);
@@ -167,11 +169,11 @@ EVIResetProc(ExtensionEntry *extEntry)
void
EVIExtensionInit(void)
{
- ExtensionEntry *extEntry, *AddExtension();
- if (extEntry = AddExtension(EVINAME, 0, 0,
+ ExtensionEntry *extEntry;
+ if ((extEntry = AddExtension(EVINAME, 0, 0,
ProcEVIDispatch,
SProcEVIDispatch,
- EVIResetProc, StandardMinorOpcode))
+ EVIResetProc, StandardMinorOpcode)))
{
XEVIReqCode = (unsigned char)extEntry->base;
eviPriv = eviDDXInit();
diff --git a/Xext/appgroup.c b/Xext/appgroup.c
index 71e74da38..37e6ee0bc 100644
--- a/Xext/appgroup.c
+++ b/Xext/appgroup.c
@@ -1,3 +1,4 @@
+/* $XFree86: xc/programs/Xserver/Xext/appgroup.c,v 1.9 2001/12/17 20:52:25 dawes Exp $ */
/*
Copyright 1996, 1998, 2001 The Open Group
@@ -74,9 +75,9 @@ static int XagCallbackRefCount = 0;
static RESTYPE RT_APPGROUP;
static AppGroupPtr appGrpList = NULL;
-extern WindowPtr* WindowTable;
extern xConnSetupPrefix connSetupPrefix;
extern char* ConnectionInfo;
+extern int connBlockScreenStart;
static
int XagAppGroupFree (what, id)
@@ -121,7 +122,7 @@ void XagClientStateChange (pcbl, nulldata, calldata)
NewClientInfoRec* pci = (NewClientInfoRec*) calldata;
ClientPtr pClient = pci->client;
AppGroupPtr pAppGrp;
- XID authId;
+ XID authId = 0;
if (!pClient->appgroup) {
switch (pClient->clientState) {
@@ -220,13 +221,13 @@ XagExtensionInit ()
{
ExtensionEntry* extEntry;
- if (extEntry = AddExtension (XAGNAME,
+ if ((extEntry = AddExtension (XAGNAME,
0,
XagNumberErrors,
ProcXagDispatch,
SProcXagDispatch,
XagResetProc,
- StandardMinorOpcode)) {
+ StandardMinorOpcode))) {
XagReqCode = (unsigned char)extEntry->base;
XagErrorBase = extEntry->errorBase;
RT_APPGROUP = CreateNewResourceType (XagAppGroupFree);
@@ -247,7 +248,7 @@ static
int ProcXagQueryVersion (client)
register ClientPtr client;
{
- REQUEST (xXagQueryVersionReq);
+ /* REQUEST (xXagQueryVersionReq); */
xXagQueryVersionReply rep;
register int n;
@@ -309,8 +310,6 @@ static
void CreateConnectionInfo (pAppGrp)
AppGroupPtr pAppGrp;
{
- extern int connBlockScreenStart;
- xConnSetup *setup = (xConnSetup*) ConnectionInfo;
xWindowRoot* rootp;
xWindowRoot* roots[MAXSCREENS];
unsigned int rootlens[MAXSCREENS];
@@ -376,7 +375,6 @@ AppGroupPtr CreateAppGroup (client, appgroupId, attrib_mask, attribs)
CARD32* attribs;
{
AppGroupPtr pAppGrp;
- int i;
pAppGrp = (AppGroupPtr) xalloc (sizeof(AppGroupRec));
if (pAppGrp) {
@@ -570,7 +568,7 @@ int ProcXagCreateAssoc (client)
if (stuff->window_type != XagWindowTypeX11)
#endif
return BadMatch;
-#ifdef WIN32 /* and Mac, etc */
+#if defined(WIN32) || defined(__CYGWIN__) /* and Mac, etc */
if (!LocalClient (client))
return BadAccess;
#endif
@@ -584,7 +582,7 @@ static
int ProcXagDestroyAssoc (client)
register ClientPtr client;
{
- REQUEST (xXagDestroyAssocReq);
+ /* REQUEST (xXagDestroyAssocReq); */
REQUEST_SIZE_MATCH (xXagDestroyAssocReq);
/* Macintosh, OS/2, and MS-Windows servers have some work to do here */
diff --git a/Xext/bigreq.c b/Xext/bigreq.c
index 4f4bf5c02..0d2dc5178 100644
--- a/Xext/bigreq.c
+++ b/Xext/bigreq.c
@@ -26,7 +26,9 @@ other dealings in this Software without prior written authorization
from The Open Group.
*/
+/* $XFree86: xc/programs/Xserver/Xext/bigreq.c,v 3.5 2001/12/14 19:58:48 dawes Exp $ */
+#define NEED_EVENTS
#include "X.h"
#include "Xproto.h"
#include "misc.h"
@@ -36,17 +38,23 @@ from The Open Group.
#include "bigreqstr.h"
static unsigned char XBigReqCode;
-static int ProcBigReqDispatch();
-static void BigReqResetProc();
+
+static void BigReqResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* extEntry */
+#endif
+);
+
+static DISPATCH_PROC(ProcBigReqDispatch);
void
BigReqExtensionInit()
{
- ExtensionEntry *extEntry, *AddExtension();
+ ExtensionEntry *extEntry;
- if (extEntry = AddExtension(XBigReqExtensionName, 0, 0,
+ if ((extEntry = AddExtension(XBigReqExtensionName, 0, 0,
ProcBigReqDispatch, ProcBigReqDispatch,
- BigReqResetProc, StandardMinorOpcode))
+ BigReqResetProc, StandardMinorOpcode)) != 0)
XBigReqCode = (unsigned char)extEntry->base;
DeclareExtensionSecurity(XBigReqExtensionName, TRUE);
}
diff --git a/Xext/cup.c b/Xext/cup.c
index 4e8cf66b4..2159417bb 100644
--- a/Xext/cup.c
+++ b/Xext/cup.c
@@ -24,6 +24,7 @@ used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group.
*/
+/* $XFree86: xc/programs/Xserver/Xext/cup.c,v 1.10 2001/12/14 19:58:48 dawes Exp $ */
#define NEED_REPLIES
#define NEED_EVENTS
@@ -35,11 +36,16 @@ in this Software without prior written authorization from The Open Group.
#include "colormapst.h"
#include "scrnintstr.h"
#include "servermd.h"
+#include "swapreq.h"
#define _XCUP_SERVER_
#include "Xcupstr.h"
#include "Xfuncproto.h"
+#ifndef EXTMODULE
#include "../os/osdep.h"
+#else
+#include "xf86_ansic.h"
+#endif
static int ProcDispatch (), SProcDispatch ();
static void ResetProc ();
@@ -121,13 +127,13 @@ XcupExtensionInit ()
{
ExtensionEntry* extEntry;
- if (extEntry = AddExtension (XCUPNAME,
+ if ((extEntry = AddExtension (XCUPNAME,
0,
XcupNumberErrors,
ProcDispatch,
SProcDispatch,
ResetProc,
- StandardMinorOpcode)) {
+ StandardMinorOpcode))) {
ReqCode = (unsigned char)extEntry->base;
ErrorBase = extEntry->errorBase;
}
@@ -146,7 +152,7 @@ static
int ProcQueryVersion (client)
register ClientPtr client;
{
- REQUEST (xXcupQueryVersionReq);
+ /* REQUEST (xXcupQueryVersionReq); */
xXcupQueryVersionReply rep;
register int n;
@@ -214,7 +220,6 @@ int ProcStoreColors (client)
int ncolors, n;
xXcupStoreColorsReply rep;
xColorItem* cptr;
- Pixel pixel;
if (!(pcmp->class & DynamicClass))
return BadMatch;
@@ -302,7 +307,7 @@ int SProcGetReservedColormapEntries (client)
}
static
-int SProcStoreColors (client)
+int SProcXcupStoreColors (client)
ClientPtr client;
{
register int n;
@@ -331,7 +336,7 @@ int SProcDispatch (client)
case X_XcupGetReservedColormapEntries:
return SProcGetReservedColormapEntries (client);
case X_XcupStoreColors:
- return SProcStoreColors (client);
+ return SProcXcupStoreColors (client);
default:
return BadRequest;
}
diff --git a/Xext/dpms.c b/Xext/dpms.c
index ebc992dc2..23c377fb4 100644
--- a/Xext/dpms.c
+++ b/Xext/dpms.c
@@ -27,43 +27,55 @@ Equipment Corporation.
******************************************************************/
+/*
+ * HISTORY
+ *
+ * @(#)RCSfile: dpms.c,v Revision: 1.1.4.5 (DEC) Date: 1996/03/04 15:27:00
+ */
+
+/* $XFree86: xc/programs/Xserver/Xext/dpms.c,v 3.9 2001/10/28 03:32:50 tsi Exp $ */
+
#include "X.h"
#include "Xproto.h"
#include "misc.h"
#include "os.h"
#include "dixstruct.h"
#include "extnsionst.h"
+#include "opaque.h"
+#define DPMS_SERVER
#include "dpms.h"
#include "dpmsstr.h"
-#include <stdio.h>
+#include "dpmsproc.h"
static unsigned char DPMSCode;
-static int ProcDPMSDispatch(), SProcDPMSDispatch();
-static void DPMSResetProc();
-static int ProcDPMSGetVersion(), SProcDPMSGetVersion();
-static int ProcDPMSGetTimeouts(), SProcDPMSGetTimeouts();
-static int ProcDPMSSetTimeouts(), ProcDPMSSetTimeouts();
-static int ProcDPMSEnable(), ProcDPMSEnable();
-static int ProcDPMSDisable(), ProcDPMSDisable();
-static int ProcDPMSForceLevel(), ProcDPMSForceLevel();
-
-extern void Swap32Write(); /* XXX should be in header file */
-extern CARD32 ScreenSaverTime;
-extern CARD32 DPMSStandbyTime;
-extern CARD32 DPMSSuspendTime;
-extern CARD32 DPMSOffTime;
-extern BOOL DPMSCapableFlag;
-extern BOOL DPMSEnabled;
-extern CARD16 DPMSPowerLevel;
+static DISPATCH_PROC(ProcDPMSDispatch);
+static DISPATCH_PROC(SProcDPMSDispatch);
+static DISPATCH_PROC(ProcDPMSGetVersion);
+static DISPATCH_PROC(SProcDPMSGetVersion);
+static DISPATCH_PROC(ProcDPMSGetTimeouts);
+static DISPATCH_PROC(SProcDPMSGetTimeouts);
+static DISPATCH_PROC(ProcDPMSSetTimeouts);
+static DISPATCH_PROC(SProcDPMSSetTimeouts);
+static DISPATCH_PROC(ProcDPMSEnable);
+static DISPATCH_PROC(SProcDPMSEnable);
+static DISPATCH_PROC(ProcDPMSDisable);
+static DISPATCH_PROC(SProcDPMSDisable);
+static DISPATCH_PROC(ProcDPMSForceLevel);
+static DISPATCH_PROC(SProcDPMSForceLevel);
+static DISPATCH_PROC(ProcDPMSInfo);
+static DISPATCH_PROC(SProcDPMSInfo);
+static DISPATCH_PROC(ProcDPMSCapable);
+static DISPATCH_PROC(SProcDPMSCapable);
+static void DPMSResetProc(ExtensionEntry* extEntry);
void
DPMSExtensionInit()
{
- ExtensionEntry *extEntry, *AddExtension();
+ ExtensionEntry *extEntry;
- if (extEntry = AddExtension(DPMSExtensionName, 0, 0,
+ if ((extEntry = AddExtension(DPMSExtensionName, 0, 0,
ProcDPMSDispatch, SProcDPMSDispatch,
- DPMSResetProc, StandardMinorOpcode))
+ DPMSResetProc, StandardMinorOpcode)))
DPMSCode = (unsigned char)extEntry->base;
return;
}
@@ -79,7 +91,7 @@ static int
ProcDPMSGetVersion(client)
register ClientPtr client;
{
- REQUEST(xDPMSGetVersionReq);
+ /* REQUEST(xDPMSGetVersionReq); */
xDPMSGetVersionReply rep;
register int n;
@@ -100,10 +112,9 @@ ProcDPMSGetVersion(client)
}
static int
-ProcDPMSCapable(client)
- register ClientPtr client;
+ProcDPMSCapable(register ClientPtr client)
{
- REQUEST(xDPMSCapableReq);
+ /* REQUEST(xDPMSCapableReq); */
xDPMSCapableReply rep;
register int n;
@@ -114,6 +125,9 @@ ProcDPMSCapable(client)
rep.sequenceNumber = client->sequence;
rep.capable = DPMSCapableFlag;
+ if (client->swapped) {
+ swaps(&rep.sequenceNumber, n);
+ }
WriteToClient(client, sizeof(xDPMSCapableReply), (char *)&rep);
return(client->noClientException);
}
@@ -122,7 +136,7 @@ static int
ProcDPMSGetTimeouts(client)
register ClientPtr client;
{
- REQUEST(xDPMSGetTimeoutsReq);
+ /* REQUEST(xDPMSGetTimeoutsReq); */
xDPMSGetTimeoutsReply rep;
register int n;
@@ -150,7 +164,6 @@ ProcDPMSSetTimeouts(client)
register ClientPtr client;
{
REQUEST(xDPMSSetTimeoutsReq);
- register int n;
REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);
@@ -176,7 +189,7 @@ static int
ProcDPMSEnable(client)
register ClientPtr client;
{
- REQUEST(xDPMSEnableReq);
+ /* REQUEST(xDPMSEnableReq); */
REQUEST_SIZE_MATCH(xDPMSEnableReq);
@@ -190,13 +203,11 @@ static int
ProcDPMSDisable(client)
register ClientPtr client;
{
- REQUEST(xDPMSDisableReq);
+ /* REQUEST(xDPMSDisableReq); */
REQUEST_SIZE_MATCH(xDPMSDisableReq);
-#ifdef DPMSExtension
DPMSSet(DPMSModeOn);
-#endif
DPMSEnabled = FALSE;
@@ -217,9 +228,7 @@ ProcDPMSForceLevel(client)
if (stuff->level == DPMSModeOn) {
lastDeviceEventTime.milliseconds =
GetTimeInMillis();
- }
-#if 0
- else if (stuff->level == DPMSModeStandby) {
+ } else if (stuff->level == DPMSModeStandby) {
lastDeviceEventTime.milliseconds =
GetTimeInMillis() - DPMSStandbyTime;
} else if (stuff->level == DPMSModeSuspend) {
@@ -232,20 +241,16 @@ ProcDPMSForceLevel(client)
client->errorValue = stuff->level;
return BadValue;
}
-#endif
-#ifdef DPMSExtension
DPMSSet(stuff->level);
-#endif
return(client->noClientException);
}
static int
-ProcDPMSInfo(client)
- register ClientPtr client;
+ProcDPMSInfo(register ClientPtr client)
{
- REQUEST(xDPMSInfoReq);
+ /* REQUEST(xDPMSInfoReq); */
xDPMSInfoReply rep;
register int n;
@@ -309,8 +314,7 @@ SProcDPMSGetVersion(client)
}
static int
-SProcDPMSCapable(client)
- register ClientPtr client;
+SProcDPMSCapable(register ClientPtr client)
{
REQUEST(xDPMSCapableReq);
register int n;
diff --git a/Xext/dpmsstubs.c b/Xext/dpmsstubs.c
index 6f635f42b..ac1ee352a 100644
--- a/Xext/dpmsstubs.c
+++ b/Xext/dpmsstubs.c
@@ -26,23 +26,23 @@ dealings in this Software without prior written authorization from Digital
Equipment Corporation.
******************************************************************/
+/* $XFree86: xc/programs/Xserver/Xext/dpmsstubs.c,v 3.4 2001/01/17 22:13:15 dawes Exp $ */
typedef int Bool;
#define FALSE 0
-Bool DPMSSupported()
+Bool DPMSSupported(void)
{
return FALSE;
}
-int DPSMGet(level)
- int *level;
+int DPSMGet(int *level)
{
return -1;
}
-void DPMSSet(level)
+void DPMSSet(int level)
{
}
diff --git a/Xext/mbuf.c b/Xext/mbuf.c
index c65ed3dd2..16a59e58e 100644
--- a/Xext/mbuf.c
+++ b/Xext/mbuf.c
@@ -1,3 +1,4 @@
+/* $XFree86: xc/programs/Xserver/Xext/mbuf.c,v 3.14 2001/12/14 19:58:49 dawes Exp $ */
/************************************************************
Copyright 1989, 1998 The Open Group
@@ -27,29 +28,29 @@ in this Software without prior written authorization from The Open Group.
/* $Xorg: mbuf.c,v 1.4 2001/02/09 02:04:32 xorgcvs Exp $ */
#define NEED_REPLIES
#define NEED_EVENTS
-#include <stdio.h>
#include "X.h"
#include "Xproto.h"
-#include "misc.h"
+#include "window.h"
#include "os.h"
#include "windowstr.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
+#include "gcstruct.h"
#include "extnsionst.h"
#include "dixstruct.h"
#include "resource.h"
#include "opaque.h"
+#include "sleepuntil.h"
#define _MULTIBUF_SERVER_ /* don't want Xlib structures */
#include "multibufst.h"
-#include "regionstr.h"
-#include "gcstruct.h"
-#include "inputstr.h"
-#ifndef WIN32
+
+#ifdef EXTMODULE
+#include "xf86_ansic.h"
+#else
+#include <stdio.h>
+#if !defined(WIN32) && !defined(Lynx)
#include <sys/time.h>
#endif
-
-#ifdef PANORAMIX
-#include "panoramiX.h"
#endif
/* given an OtherClientPtr obj, get the ClientPtr */
@@ -60,121 +61,99 @@ in this Software without prior written authorization from The Open Group.
#define ValidEventMasks (ExposureMask|MultibufferClobberNotifyMask|MultibufferUpdateNotifyMask)
-#ifdef PANORAMIX
-extern int PanoramiXNumScreens;
-extern Bool noPanoramiXExtension;
-extern PanoramiXWindow *PanoramiXWinRoot;
-extern PanoramiXPmap *PanoramiXPmapRoot;
-extern PanoramiXData *panoramiXdataPtr;
-#endif
-
-/* The _Multibuffer and _Multibuffers structures below refer to each other,
- * so we need this forward declaration
- */
-
-typedef struct _Multibuffers *MultibuffersPtr;
-
-/*
- * per-Multibuffer data
- */
-
-typedef struct _Multibuffer {
- MultibuffersPtr pMultibuffers; /* associated window data */
- Mask eventMask; /* MultibufferClobberNotifyMask|ExposureMask|MultibufferUpdateNotifyMask */
- Mask otherEventMask; /* mask of all other clients event masks */
- OtherClients *otherClients; /* other clients that want events */
- int number; /* index of this buffer into array */
- int side; /* always Mono */
- int clobber; /* Unclobbered, PartiallyClobbered, FullClobbered */
- PixmapPtr pPixmap; /* associated pixmap */
-} MultibufferRec, *MultibufferPtr;
-
-/*
- * per-window data
- */
-
-typedef struct _Multibuffers {
- WindowPtr pWindow; /* associated window */
- int numMultibuffer; /* count of buffers */
- int refcnt; /* ref count for delete */
- int displayedMultibuffer; /* currently active buffer */
- int updateAction; /* Undefined, Background, Untouched, Copied */
- int updateHint; /* Frequent, Intermittent, Static */
- int windowMode; /* always Mono */
-
- TimeStamp lastUpdate; /* time of last update */
-
- unsigned short width, height; /* last known window size */
- short x, y; /* for static gravity */
-
- MultibufferPtr buffers; /* array of numMultibuffer buffers */
-} MultibuffersRec;
-
-/*
- * per-screen data
- */
-typedef struct _MultibufferScreen {
- Bool (*PositionWindow)();
-} MultibufferScreenRec, *MultibufferScreenPtr;
-
-/*
- * per display-image-buffers request data.
- */
-
-typedef struct _DisplayRequest {
- struct _DisplayRequest *next;
- TimeStamp activateTime;
- ClientPtr pClient;
- XID id;
-} DisplayRequestRec, *DisplayRequestPtr;
-
static unsigned char MultibufferReqCode;
static int MultibufferEventBase;
static int MultibufferErrorBase;
int MultibufferScreenIndex = -1;
int MultibufferWindowIndex = -1;
-static void PerformDisplayRequest ();
-static void DisposeDisplayRequest ();
-static Bool QueueDisplayRequest ();
-
-static void BumpTimeStamp ();
+static void PerformDisplayRequest (
+#if NeedFunctionPrototypes
+ MultibuffersPtr * /* ppMultibuffers */,
+ MultibufferPtr * /* pMultibuffer */,
+ int /* nbuf */
+#endif
+ );
+static Bool QueueDisplayRequest (
+#if NeedFunctionPrototypes
+ ClientPtr /* client */,
+ TimeStamp /* activateTime */
+#endif
+ );
-void MultibufferExpose ();
-void MultibufferUpdate ();
-static void AliasMultibuffer ();
-int CreateImageBuffers ();
-void DestroyImageBuffers ();
-int DisplayImageBuffers ();
-static void RecalculateMultibufferOtherEvents ();
-static int EventSelectForMultibuffer();
+static void BumpTimeStamp (
+#if NeedFunctionPrototypes
+ TimeStamp * /* ts */,
+ CARD32 /* inc */
+#endif
+ );
+static void AliasMultibuffer (
+#if NeedFunctionPrototypes
+ MultibuffersPtr /* pMultibuffers */,
+ int /* i */
+#endif
+ );
+static void RecalculateMultibufferOtherEvents (
+#if NeedFunctionPrototypes
+ MultibufferPtr /* pMultibuffer */
+#endif
+ );
+static int EventSelectForMultibuffer(
+#if NeedFunctionPrototypes
+ MultibufferPtr /* pMultibuffer */,
+ ClientPtr /* client */,
+ Mask /* mask */
+#endif
+ );
/*
* The Pixmap associated with a buffer can be found as a resource
* with this type
*/
RESTYPE MultibufferDrawableResType;
-static int MultibufferDrawableDelete ();
+static int MultibufferDrawableDelete (
+#if NeedFunctionPrototypes
+ pointer /* value */,
+ XID /* id */
+#endif
+ );
/*
* The per-buffer data can be found as a resource with this type.
* the resource id of the per-buffer data is the same as the resource
* id of the pixmap
*/
static RESTYPE MultibufferResType;
-static int MultibufferDelete ();
+static int MultibufferDelete (
+#if NeedFunctionPrototypes
+ pointer /* value */,
+ XID /* id */
+#endif
+ );
+
/*
* The per-window data can be found as a resource with this type,
* using the window resource id
*/
static RESTYPE MultibuffersResType;
-static int MultibuffersDelete ();
+static int MultibuffersDelete (
+#if NeedFunctionPrototypes
+ pointer /* value */,
+ XID /* id */
+#endif
+ );
+
/*
* Clients other than the buffer creator attach event masks in
* OtherClient structures; each has a resource of this type.
*/
static RESTYPE OtherClientResType;
-static int OtherClientDelete ();
+static int OtherClientDelete (
+#if NeedFunctionPrototypes
+ pointer /* value */,
+ XID /* id */
+#endif
+ );
/****************
* MultibufferExtensionInit
@@ -183,10 +162,70 @@ static int OtherClientDelete ();
*
****************/
-static int ProcMultibufferDispatch(), SProcMultibufferDispatch();
-static void MultibufferResetProc();
-static void SClobberNotifyEvent(), SUpdateNotifyEvent();
-static Bool MultibufferPositionWindow();
+extern DISPATCH_PROC(ProcGetBufferAttributes);
+
+static DISPATCH_PROC(ProcClearImageBufferArea);
+static DISPATCH_PROC(ProcCreateImageBuffers);
+static DISPATCH_PROC(ProcDestroyImageBuffers);
+static DISPATCH_PROC(ProcDisplayImageBuffers);
+static DISPATCH_PROC(ProcGetBufferInfo);
+static DISPATCH_PROC(ProcGetBufferVersion);
+static DISPATCH_PROC(ProcGetMBufferAttributes);
+static DISPATCH_PROC(ProcMultibufferDispatch);
+static DISPATCH_PROC(ProcSetBufferAttributes);
+static DISPATCH_PROC(ProcSetMBufferAttributes);
+static DISPATCH_PROC(SProcClearImageBufferArea);
+static DISPATCH_PROC(SProcCreateImageBuffers);
+static DISPATCH_PROC(SProcDestroyImageBuffers);
+static DISPATCH_PROC(SProcDisplayImageBuffers);
+static DISPATCH_PROC(SProcGetBufferAttributes);
+static DISPATCH_PROC(SProcGetBufferInfo);
+static DISPATCH_PROC(SProcGetBufferVersion);
+static DISPATCH_PROC(SProcGetMBufferAttributes);
+static DISPATCH_PROC(SProcMultibufferDispatch);
+static DISPATCH_PROC(SProcSetBufferAttributes);
+static DISPATCH_PROC(SProcSetMBufferAttributes);
+
+static void MultibufferResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* extEntry */
+#endif
+ );
+static void SClobberNotifyEvent(
+#if NeedFunctionPrototypes
+ xMbufClobberNotifyEvent * /* from */,
+ xMbufClobberNotifyEvent * /* to */
+# endif
+ );
+static void SUpdateNotifyEvent(
+#if NeedFunctionPrototypes
+ xMbufUpdateNotifyEvent * /* from */,
+ xMbufUpdateNotifyEvent * /* to */
+#endif
+ );
+static Bool MultibufferPositionWindow(
+#if NeedFunctionPrototypes
+ WindowPtr /* pWin */,
+ int /* x */,
+ int /* y */
+#endif
+ );
+
+static void SetupBackgroundPainter (
+#if NeedFunctionPrototypes
+ WindowPtr /* pWin */,
+ GCPtr /* pGC */
+#endif
+ );
+
+static int DeliverEventsToMultibuffer (
+#if NeedFunctionPrototypes
+ MultibufferPtr /* pMultibuffer */,
+ xEvent * /* pEvents */,
+ int /* count */,
+ Mask /* filter */
+#endif
+ );
void
MultibufferExtensionInit()
@@ -243,8 +282,8 @@ MultibufferExtensionInit()
MultibufferReqCode = (unsigned char)extEntry->base;
MultibufferEventBase = extEntry->eventBase;
MultibufferErrorBase = extEntry->errorBase;
- EventSwapVector[MultibufferEventBase + MultibufferClobberNotify] = SClobberNotifyEvent;
- EventSwapVector[MultibufferEventBase + MultibufferUpdateNotify] = SUpdateNotifyEvent;
+ EventSwapVector[MultibufferEventBase + MultibufferClobberNotify] = (EventSwapPtr) SClobberNotifyEvent;
+ EventSwapVector[MultibufferEventBase + MultibufferUpdateNotify] = (EventSwapPtr) SUpdateNotifyEvent;
}
}
@@ -275,7 +314,6 @@ static int
ProcGetBufferVersion (client)
register ClientPtr client;
{
- REQUEST(xMbufGetBufferVersionReq);
xMbufGetBufferVersionReply rep;
register int n;
@@ -331,8 +369,8 @@ SetupBackgroundPainter (pWin, pGC)
case BackgroundPixmap:
gcvalues[0] = (pointer) FillTiled;
gcvalues[1] = (pointer) background.pixmap;
- gcvalues[2] = (pointer) ts_x_origin;
- gcvalues[3] = (pointer) ts_y_origin;
+ gcvalues[2] = (pointer)(long) ts_x_origin;
+ gcvalues[3] = (pointer)(long) ts_y_origin;
gcmask = GCFillStyle|GCTile|GCTileStipXOrigin|GCTileStipYOrigin;
break;
@@ -430,80 +468,8 @@ CreateImageBuffers (pWin, nbuf, ids, action, hint)
return Success;
}
-#ifdef PANORAMIX
-static int
-ProcPanoramiXCreateImageBuffers (client)
- register ClientPtr client;
-{
- REQUEST(xMbufCreateImageBuffersReq);
-
- register int result;
- int i, j, k, len;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXWindow *next;
- PanoramiXWindow *pPanoramiXids;
- PanoramiXWindow *pPanoramiXPrev_ids;
- PanoramiXPmap *local;
- PanoramiXPmap *pPanoramiXPmap = PanoramiXPmapRoot;
- CARD32 *value, *orig_ids;
- XID *ids;
- XID ID;
- DrawablePtr pDrawable;
-
- REQUEST_AT_LEAST_SIZE (xMbufCreateImageBuffersReq);
- PANORAMIXFIND_ID(pPanoramiXWin,stuff->window);
- IF_RETURN(!pPanoramiXWin, BadRequest);
- len = stuff->length - (sizeof(xMbufCreateImageBuffersReq) >> 2);
- ids = (XID *)ALLOCATE_LOCAL(sizeof(XID)*len);
- orig_ids = (XID *)ALLOCATE_LOCAL(sizeof(XID)*len);
- if (!ids)
- return BadAlloc;
- memcpy((char *)orig_ids, (char *) &stuff[1], len * sizeof(XID));
- value = (CARD32 *)&stuff[1];
- /* New resources are pixmaps */
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin , j) {
- stuff->window = pPanoramiXWin->info[j].id;
- for (i = 0; i < len; i++) {
- ids[i] = (XID)orig_ids[i];
- /* These will be MultibufferDrawableResType & MultibufferResType */
- pPanoramiXPmap = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXPmap, ids[i]);
- if (!pPanoramiXPmap) {
- local = (PanoramiXWindow *)Xcalloc(sizeof(PanoramiXWindow));
- for (k = 0; k <= PanoramiXNumScreens - 1; k++) {
- ID = k ? FakeClientID(client->index) : ids[i];
- local->info[k].id = ID;
- }
- local->FreeMe = FALSE;
- PANORAMIXFIND_LAST(pPanoramiXPmap, PanoramiXPmapRoot);
- pPanoramiXPmap->next = local;
- value[i] = local->info[j].id;
- }else
- value[i] = pPanoramiXPmap->info[j].id;
- }
- if (!j)
- noPanoramiXExtension = TRUE;
- result = ProcCreateImageBuffers (client);
- noPanoramiXExtension = FALSE;
- BREAK_IF(result != Success);
- }
- if (result != Success) {
- if (ids)
- Xfree(ids);
- if (orig_ids)
- Xfree(orig_ids);
- if (local)
- Xfree(local);
- }
- return (result);
-}
-#endif
-#ifdef PANORAMIX
-int
-#else
static int
-#endif
ProcCreateImageBuffers (client)
register ClientPtr client;
{
@@ -565,10 +531,7 @@ ProcCreateImageBuffers (client)
swapl(&rep.length, n);
swaps(&rep.numberBuffer, n);
}
-#ifdef PANORAMIX
- if (noPanoramiXExtension)
-#endif
- WriteToClient(client, sizeof (xMbufCreateImageBuffersReply), (char*)&rep);
+ WriteToClient(client, sizeof (xMbufCreateImageBuffersReply), (char*)&rep);
return (client->noClientException);
}
@@ -585,16 +548,6 @@ ProcDisplayImageBuffers (client)
CARD32 minDelay;
TimeStamp activateTime, bufferTime;
-#ifdef PANORAMIX
- WindowPtr pWndw;
- PanoramiXPmap *pPanoramiXPmap = PanoramiXPmapRoot;
- MultibufferPtr *pScrn0Multibuffer;
- MultibuffersPtr *ppScrn0Multibuffers;
- int k;
- int panoramiX_buf = 0;
- Bool FoundScreen;
-
-#endif
REQUEST_AT_LEAST_SIZE (xMbufDisplayImageBuffersReq);
nbuf = stuff->length - (sizeof (xMbufDisplayImageBuffersReq) >> 2);
@@ -602,23 +555,6 @@ ProcDisplayImageBuffers (client)
return Success;
minDelay = stuff->minDelay;
ids = (XID *) &stuff[1];
-#ifdef PANORAMIX
- if (!noPanoramiXExtension)
- {
- int maxbuf = 0;
- maxbuf = nbuf * PanoramiXNumScreens;
- ppScrn0Multibuffers = (MultibuffersPtr *) xalloc(maxbuf * sizeof (MultibuffersPtr));
- pScrn0Multibuffer = (MultibufferPtr *) xalloc (maxbuf * sizeof(MultibufferPtr));
- if (!ppScrn0Multibuffers || !pScrn0Multibuffer)
- {
- if ( sizeof (long) != sizeof(CARD32) ) DEALLOCATE_LOCAL(ids);
- xfree (ppScrn0Multibuffers);
- xfree (pScrn0Multibuffer);
- client->errorValue = 0;
- return BadAlloc;
- }
- }
-#endif
ppMultibuffers = (MultibuffersPtr *) ALLOCATE_LOCAL(nbuf * sizeof (MultibuffersPtr));
pMultibuffer = (MultibufferPtr *) ALLOCATE_LOCAL(nbuf * sizeof (MultibufferPtr));
if (!ppMultibuffers || !pMultibuffer)
@@ -632,81 +568,6 @@ ProcDisplayImageBuffers (client)
activateTime.milliseconds = 0;
for (i = 0; i < nbuf; i++)
{
-#ifdef PANORAMIX
- if (!noPanoramiXExtension) {
- pPanoramiXPmap = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXPmap, ids[i]);
- if (!pPanoramiXPmap){
- if ( sizeof (long) != sizeof(CARD32) ) DEALLOCATE_LOCAL(ids);
- xfree (ppMultibuffers);
- xfree (pMultibuffer);
- client->errorValue = ids[i];
- return MultibufferErrorBase + MultibufferBadBuffer;
- }
- FoundScreen = FALSE;
- pScrn0Multibuffer[panoramiX_buf] = (MultibufferPtr)
- LookupIDByType (ids[i], MultibufferResType);
- ppScrn0Multibuffers[i] = pScrn0Multibuffer[i]->pMultibuffers;
- pWndw = ppScrn0Multibuffers[i]->pWindow;
- for (k = 0; (k < PanoramiXNumScreens && !FoundScreen); k++) {
- pMultibuffer[panoramiX_buf] = (MultibufferPtr)
- LookupIDByType (pPanoramiXPmap->info[k].id, MultibufferResType);
- if (!pMultibuffer[i])
- {
- if ( sizeof (long) != sizeof(CARD32) ) DEALLOCATE_LOCAL(ids);
- xfree (ppMultibuffers);
- xfree (pMultibuffer);
- client->errorValue = ids[i];
- return MultibufferErrorBase + MultibufferBadBuffer;
- }
- ppMultibuffers[panoramiX_buf] = pMultibuffer[panoramiX_buf]->pMultibuffers;
- /* Figure out where the buffer resides, which screens */
- if ( ((pWndw->drawable.x < 0) &&
- (pWndw->drawable.x + pWndw->drawable.width < 0))
- || ( (pWndw->drawable.x >
- panoramiXdataPtr[k].x + panoramiXdataPtr[k].width) &&
- (pWndw->drawable.x + pWndw->drawable.width >
- panoramiXdataPtr[k].x + panoramiXdataPtr[k].width)))
- /* its not on screen - k -, try next screen */
- continue;
- if ( ((pWndw->drawable.y < 0) &&
- (pWndw->drawable.y + pWndw->drawable.height < 0))
- || ( (pWndw->drawable.y >
- panoramiXdataPtr[k].y + panoramiXdataPtr[k].height) &&
- (pWndw->drawable.y + pWndw->drawable.height >
- panoramiXdataPtr[k].y + panoramiXdataPtr[k].height)))
- /* its not on screen - k -, try next screen */
- continue;
-
- /* The window resides on screen k, which means we need to
- keep the buffer information for this screen */
- panoramiX_buf++;
-
- /* Is it only on this screen, or does it enter onto another
- screen */
- if ( ((pWndw->drawable.x + pWndw->drawable.width) <=
- (panoramiXdataPtr[k].x + panoramiXdataPtr[k].width)) &&
- ((pWndw->drawable.y + pWndw->drawable.height) <=
- (panoramiXdataPtr[k].y +
- panoramiXdataPtr[k].height )) )
- FoundScreen = TRUE;
- } /* for each screen k */
- for (j = 0; j < i; j++)
- {
- if (ppScrn0Multibuffers[i] == ppScrn0Multibuffers[j])
- {
- if ( sizeof (long) != sizeof(CARD32) ) DEALLOCATE_LOCAL(ids);
- DEALLOCATE_LOCAL(ppScrn0Multibuffers);
- DEALLOCATE_LOCAL(pScrn0Multibuffer);
- DEALLOCATE_LOCAL(ppMultibuffers);
- DEALLOCATE_LOCAL(pMultibuffer);
- client->errorValue = ids[i];
- return BadMatch;
- }
- }
- bufferTime = ppScrn0Multibuffers[i]->lastUpdate;
- }else {
-#endif
pMultibuffer[i] = (MultibufferPtr) LookupIDByType (ids[i],
MultibufferResType);
if (!pMultibuffer[i])
@@ -728,9 +589,6 @@ MultibufferResType);
}
}
bufferTime = ppMultibuffers[i]->lastUpdate;
-#ifdef PANORAMIX
- }
-#endif
BumpTimeStamp (&bufferTime, minDelay);
if (CompareTimeStamps (bufferTime, activateTime) == LATER)
activateTime = bufferTime;
@@ -742,54 +600,15 @@ MultibufferResType);
;
}
else
-#ifdef PANORAMIX
- if (!noPanoramiXExtension){
- PerformDisplayRequest (ppMultibuffers, pMultibuffer, panoramiX_buf);
- }else
-#endif
PerformDisplayRequest (ppMultibuffers, pMultibuffer, nbuf);
-#ifdef PANORAMIX
- if (!noPanoramiXExtension){
- DEALLOCATE_LOCAL(ppScrn0Multibuffers);
- DEALLOCATE_LOCAL(pScrn0Multibuffer);
- }
-#endif
-
DEALLOCATE_LOCAL(ppMultibuffers);
DEALLOCATE_LOCAL(pMultibuffer);
return Success;
}
-#ifdef PANORAMIX
-static int
-ProcPanoramiXDestroyImageBuffers (client)
- ClientPtr client;
-{
- REQUEST (xMbufDestroyImageBuffersReq);
- WindowPtr pWin;
-
- register int result;
- int j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
-
- REQUEST_SIZE_MATCH (xMbufDestroyImageBuffersReq);
- PANORAMIXFIND_ID(pPanoramiXWin,stuff->window);
- IF_RETURN(!pPanoramiXWin, BadRequest);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin , j) {
- stuff->window = pPanoramiXWin->info[j].id;
- result = ProcDestroyImageBuffers (client);
- BREAK_IF(result != Success);
- }
- return (result);
-}
-#endif
-#ifdef PANORAMIX
-int
-#else
static int
-#endif
ProcDestroyImageBuffers (client)
register ClientPtr client;
{
@@ -803,34 +622,7 @@ ProcDestroyImageBuffers (client)
return Success;
}
-#ifdef PANORAMIX
-static int
-ProcPanoramiXSetMBufferAttributes (client)
- ClientPtr client;
-{
- REQUEST (xMbufSetMBufferAttributesReq);
- WindowPtr pWin;
-
- register int result;
- int j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
-
- REQUEST_SIZE_MATCH (xMbufSetMBufferAttributesReq);
- PANORAMIXFIND_ID(pPanoramiXWin,stuff->window);
- IF_RETURN(!pPanoramiXWin, BadRequest);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin , j) {
- stuff->window = pPanoramiXWin->info[j].id;
- result = ProcSetMBufferAttributes (client);
- BREAK_IF(result != Success);
- }
- return (result);
-}
-#endif
-#ifdef PANORAMIX
-int
-#else
static int
-#endif
ProcSetMBufferAttributes (client)
register ClientPtr client;
{
@@ -839,7 +631,7 @@ ProcSetMBufferAttributes (client)
MultibuffersPtr pMultibuffers;
int len;
Mask vmask;
- Mask index;
+ Mask index2;
CARD32 updateHint;
XID *vlist;
@@ -857,9 +649,9 @@ ProcSetMBufferAttributes (client)
vlist = (XID *) &stuff[1];
while (vmask)
{
- index = (Mask) lowbit (vmask);
- vmask &= ~index;
- switch (index)
+ index2 = (Mask) lowbit (vmask);
+ vmask &= ~index2;
+ switch (index2)
{
case MultibufferWindowUpdateHint:
updateHint = (CARD32) *vlist;
@@ -936,7 +728,7 @@ ProcSetBufferAttributes (client)
REQUEST(xMbufSetBufferAttributesReq);
MultibufferPtr pMultibuffer;
int len;
- Mask vmask, index;
+ Mask vmask, index2;
XID *vlist;
Mask eventMask;
int result;
@@ -952,9 +744,9 @@ ProcSetBufferAttributes (client)
vlist = (XID *) &stuff[1];
while (vmask)
{
- index = (Mask) lowbit (vmask);
- vmask &= ~index;
- switch (index)
+ index2 = (Mask) lowbit (vmask);
+ vmask &= ~index2;
+ switch (index2)
{
case MultibufferBufferEventMask:
eventMask = (Mask) *vlist;
@@ -971,6 +763,7 @@ ProcSetBufferAttributes (client)
return Success;
}
+int
ProcGetBufferAttributes (client)
register ClientPtr client;
{
@@ -1150,34 +943,13 @@ ProcMultibufferDispatch (client)
case X_MbufGetBufferVersion:
return ProcGetBufferVersion (client);
case X_MbufCreateImageBuffers:
-#ifdef PANORAMIX
- if ( !noPanoramiXExtension )
- return ProcPanoramiXCreateImageBuffers (client);
- else
- return ProcCreateImageBuffers (client);
-#else
return ProcCreateImageBuffers (client);
-#endif
case X_MbufDisplayImageBuffers:
return ProcDisplayImageBuffers (client);
case X_MbufDestroyImageBuffers:
-#ifdef PANORAMIX
- if ( !noPanoramiXExtension )
- return ProcPanoramiXDestroyImageBuffers (client);
- else
- return ProcDestroyImageBuffers (client);
-#else
return ProcDestroyImageBuffers (client);
-#endif
case X_MbufSetMBufferAttributes:
-#ifdef PANORAMIX
- if ( !noPanoramiXExtension )
- return ProcPanoramiXSetMBufferAttributes (client);
- else
- return ProcSetMBufferAttributes (client);
-#else
return ProcSetMBufferAttributes (client);
-#endif
case X_MbufGetMBufferAttributes:
return ProcGetMBufferAttributes (client);
case X_MbufSetBufferAttributes:
@@ -1447,8 +1219,6 @@ PerformDisplayRequest (ppMultibuffers, pMultibuffer, nbuf)
if (pExposed)
{
RegionPtr pWinSize;
- ScreenPtr pScreen = pWin->drawable.pScreen;
- extern RegionPtr CreateUnclippedWinSize();
pWinSize = CreateUnclippedWinSize (pWin);
/* pExposed is window-relative, but at this point
@@ -1456,13 +1226,13 @@ PerformDisplayRequest (ppMultibuffers, pMultibuffer, nbuf)
* window-relative so that region ops involving
* pExposed and pWinSize behave sensibly.
*/
- REGION_TRANSLATE(pScreen, pWinSize,
- -pWin->drawable.x,
- -pWin->drawable.y);
- REGION_INTERSECT(pScreen, pExposed, pExposed, pWinSize);
- REGION_DESTROY(pScreen, pWinSize);
+ REGION_TRANSLATE(pWin->drawable.pScreen, pWinSize,
+ -pWin->drawable.x, -pWin->drawable.y);
+ REGION_INTERSECT(pWin->drawable.pScreen, pExposed,
+ pExposed, pWinSize);
+ REGION_DESTROY(pWin->drawable.pScreen, pWinSize);
MultibufferExpose (pPrevMultibuffer, pExposed);
- REGION_DESTROY(pScreen, pExposed);
+ REGION_DESTROY(pWin->drawable.pScreen, pExposed);
}
graphicsExpose = FALSE;
DoChangeGC (pGC, GCGraphicsExposures, &graphicsExpose, FALSE);
@@ -1590,8 +1360,8 @@ DeliverEventsToMultibuffer (pMultibuffer, pEvents, count, filter)
return 0;
/* maybe send event to owner */
- if (attempt = TryClientEvents(
- bClient(pMultibuffer), pEvents, count, pMultibuffer->eventMask, filter, (GrabPtr) 0))
+ if ((attempt = TryClientEvents(
+ bClient(pMultibuffer), pEvents, count, pMultibuffer->eventMask, filter, (GrabPtr) 0)) != 0)
{
if (attempt > 0)
deliveries++;
@@ -1602,8 +1372,8 @@ DeliverEventsToMultibuffer (pMultibuffer, pEvents, count, filter)
/* maybe send event to other clients */
for (other = pMultibuffer->otherClients; other; other=other->next)
{
- if (attempt = TryClientEvents(
- rClient(other), pEvents, count, other->mask, filter, (GrabPtr) 0))
+ if ((attempt = TryClientEvents(
+ rClient(other), pEvents, count, other->mask, filter, (GrabPtr) 0)) != 0)
{
if (attempt > 0)
deliveries++;
@@ -1664,15 +1434,15 @@ MultibufferExpose (pMultibuffer, pRegion)
/* send UpdateNotify event */
void
-MultibufferUpdate (pMultibuffer, time)
+MultibufferUpdate (pMultibuffer, time2)
MultibufferPtr pMultibuffer;
- CARD32 time;
+ CARD32 time2;
{
xMbufUpdateNotifyEvent event;
event.type = MultibufferEventBase + MultibufferUpdateNotify;
event.buffer = pMultibuffer->pPixmap->drawable.id;
- event.timeStamp = time;
+ event.timeStamp = time2;
(void) DeliverEventsToMultibuffer (pMultibuffer, (xEvent *)&event,
1, (Mask)MultibufferUpdateNotifyMask);
}
diff --git a/Xext/mbufbf.c b/Xext/mbufbf.c
index 3c873086f..925745712 100644
--- a/Xext/mbufbf.c
+++ b/Xext/mbufbf.c
@@ -1,3 +1,4 @@
+/* $XFree86: xc/programs/Xserver/Xext/mbufbf.c,v 3.4 2001/12/14 19:58:49 dawes Exp $ */
/*
Copyright 1989, 1998 The Open Group
diff --git a/Xext/mbufpx.c b/Xext/mbufpx.c
index 9474cc9aa..9c531c292 100644
--- a/Xext/mbufpx.c
+++ b/Xext/mbufpx.c
@@ -1,3 +1,4 @@
+/* $XFree86: xc/programs/Xserver/Xext/mbufpx.c,v 3.4 2001/12/14 19:58:49 dawes Exp $ */
/************************************************************
Copyright 1989, 1998 The Open Group
diff --git a/Xext/mitmisc.c b/Xext/mitmisc.c
index 63e496209..b6038edba 100644
--- a/Xext/mitmisc.c
+++ b/Xext/mitmisc.c
@@ -1,3 +1,4 @@
+/* $XFree86: xc/programs/Xserver/Xext/mitmisc.c,v 3.4 2001/12/14 19:58:49 dawes Exp $ */
/************************************************************
Copyright 1989, 1998 The Open Group
@@ -28,6 +29,7 @@ in this Software without prior written authorization from The Open Group.
/* $Xorg: mitmisc.c,v 1.4 2001/02/09 02:04:32 xorgcvs Exp $ */
+#define NEED_EVENTS
#include "X.h"
#include "Xproto.h"
#include "misc.h"
@@ -40,17 +42,28 @@ in this Software without prior written authorization from The Open Group.
extern Bool permitOldBugs;
static unsigned char MITReqCode;
-static int ProcMITDispatch(), SProcMITDispatch();
-static void MITResetProc();
+
+static void MITResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* extEntry */
+#endif
+);
+
+static DISPATCH_PROC(ProcMITDispatch);
+static DISPATCH_PROC(ProcMITGetBugMode);
+static DISPATCH_PROC(ProcMITSetBugMode);
+static DISPATCH_PROC(SProcMITDispatch);
+static DISPATCH_PROC(SProcMITGetBugMode);
+static DISPATCH_PROC(SProcMITSetBugMode);
void
MITMiscExtensionInit()
{
- ExtensionEntry *extEntry, *AddExtension();
+ ExtensionEntry *extEntry;
- if (extEntry = AddExtension(MITMISCNAME, 0, 0,
+ if ((extEntry = AddExtension(MITMISCNAME, 0, 0,
ProcMITDispatch, SProcMITDispatch,
- MITResetProc, StandardMinorOpcode))
+ MITResetProc, StandardMinorOpcode)) != 0)
MITReqCode = (unsigned char)extEntry->base;
}
@@ -81,7 +94,6 @@ static int
ProcMITGetBugMode(client)
register ClientPtr client;
{
- REQUEST(xMITGetBugModeReq);
xMITGetBugModeReply rep;
register int n;
diff --git a/Xext/panoramiX.c b/Xext/panoramiX.c
index 2d3eb7c42..fb0b9c541 100644
--- a/Xext/panoramiX.c
+++ b/Xext/panoramiX.c
@@ -23,11 +23,13 @@ shall not be used in advertising or otherwise to promote the sale, use or other
dealings in this Software without prior written authorization from Digital
Equipment Corporation.
******************************************************************/
+/* $XFree86: xc/programs/Xserver/Xext/panoramiX.c,v 3.32 2002/08/01 00:30:34 mvojkovi Exp $ */
#define NEED_REPLIES
#include <stdio.h>
#include "X.h"
#include "Xproto.h"
+#include "Xarch.h"
#include "misc.h"
#include "cursor.h"
#include "cursorstr.h"
@@ -39,32 +41,44 @@ Equipment Corporation.
#include "window.h"
#include "windowstr.h"
#include "pixmapstr.h"
-#if 0
-#include <sys/workstation.h>
-#include <X11/Xserver/ws.h>
-#endif
#include "panoramiX.h"
#include "panoramiXproto.h"
+#include "panoramiXsrv.h"
+#include "globals.h"
+#include "servermd.h"
+#include "resource.h"
+#ifdef RENDER
+#include "picturestr.h"
+#endif
+
static unsigned char PanoramiXReqCode = 0;
/*
* PanoramiX data declarations
*/
-int PanoramiXPixWidth;
-int PanoramiXPixHeight;
-int PanoramiXNumScreens;
+int PanoramiXPixWidth = 0;
+int PanoramiXPixHeight = 0;
+int PanoramiXNumScreens = 0;
+
+PanoramiXData *panoramiXdataPtr = NULL;
-PanoramiXData *panoramiXdataPtr;
-PanoramiXWindow *PanoramiXWinRoot;
-PanoramiXGC *PanoramiXGCRoot;
-PanoramiXCmap *PanoramiXCmapRoot;
-PanoramiXPmap *PanoramiXPmapRoot;
-PanoramiXEdge panoramiXEdgePtr[MAXSCREENS];
-RegionRec PanoramiXScreenRegion[MAXSCREENS];
-PanoramiXCDT PanoramiXColorDepthTable[MAXSCREENS];
-PanoramiXDepth PanoramiXLargestScreenDepth;
+RegionRec PanoramiXScreenRegion;
+
+int PanoramiXNumDepths;
+DepthPtr PanoramiXDepths;
+int PanoramiXNumVisuals;
+VisualPtr PanoramiXVisuals;
+/* We support at most 256 visuals */
+XID *PanoramiXVisualTable = NULL;
+
+unsigned long XRC_DRAWABLE;
+unsigned long XRT_WINDOW;
+unsigned long XRT_PIXMAP;
+unsigned long XRT_GC;
+unsigned long XRT_COLORMAP;
+
int (* SavedProcVector[256]) ();
ScreenInfo *GlobalScrInfo;
@@ -75,7 +89,6 @@ static int ProcPanoramiXDispatch();
* Function prototypes
*/
-static void locate_neighbors(int);
static void PanoramiXResetProc(ExtensionEntry*);
/*
@@ -83,16 +96,9 @@ static void PanoramiXResetProc(ExtensionEntry*);
*/
extern int SProcPanoramiXDispatch();
-extern Bool noPanoramiXExtension;
-extern Bool PanoramiXVisibilityNotifySent;
-extern WindowPtr *WindowTable;
-#if 0
-extern ScreenArgsRec screenArgs[MAXSCREENS];
-#endif
-extern int defaultBackingStore;
extern char *ConnectionInfo;
extern int connBlockScreenStart;
-extern int (* ProcVector[256]) ();
+extern xConnSetupPrefix connSetupPrefix;
/*
* Server dispatcher function replacements
@@ -104,11 +110,10 @@ int PanoramiXChangeSaveSet(), PanoramiXReparentWindow();
int PanoramiXMapWindow(), PanoramiXMapSubwindows();
int PanoramiXUnmapWindow(), PanoramiXUnmapSubwindows();
int PanoramiXConfigureWindow(), PanoramiXCirculateWindow();
-int PanoramiXGetGeometry(), PanoramiXChangeProperty();
-int PanoramiXDeleteProperty(), PanoramiXSendEvent();
+int PanoramiXGetGeometry(), PanoramiXTranslateCoords();
int PanoramiXCreatePixmap(), PanoramiXFreePixmap();
int PanoramiXCreateGC(), PanoramiXChangeGC();
-int PanoramiXCopyGC();
+int PanoramiXCopyGC(), PanoramiXCopyColormapAndFree();
int PanoramiXSetDashes(), PanoramiXSetClipRectangles();
int PanoramiXFreeGC(), PanoramiXClearToBackground();
int PanoramiXCopyArea(), PanoramiXCopyPlane();
@@ -122,8 +127,326 @@ int PanoramiXImageText8(), PanoramiXImageText16();
int PanoramiXCreateColormap(), PanoramiXFreeColormap();
int PanoramiXInstallColormap(), PanoramiXUninstallColormap();
int PanoramiXAllocColor(), PanoramiXAllocNamedColor();
-int PanoramiXAllocColorCells();
+int PanoramiXAllocColorCells(), PanoramiXStoreNamedColor();
int PanoramiXFreeColors(), PanoramiXStoreColors();
+int PanoramiXAllocColorPlanes();
+
+static int PanoramiXGCIndex = -1;
+static int PanoramiXScreenIndex = -1;
+
+typedef struct {
+ DDXPointRec clipOrg;
+ DDXPointRec patOrg;
+ GCFuncs *wrapFuncs;
+} PanoramiXGCRec, *PanoramiXGCPtr;
+
+typedef struct {
+ CreateGCProcPtr CreateGC;
+ CloseScreenProcPtr CloseScreen;
+} PanoramiXScreenRec, *PanoramiXScreenPtr;
+
+RegionRec XineramaScreenRegions[MAXSCREENS];
+
+static void XineramaValidateGC(GCPtr, unsigned long, DrawablePtr);
+static void XineramaChangeGC(GCPtr, unsigned long);
+static void XineramaCopyGC(GCPtr, unsigned long, GCPtr);
+static void XineramaDestroyGC(GCPtr);
+static void XineramaChangeClip(GCPtr, int, pointer, int);
+static void XineramaDestroyClip(GCPtr);
+static void XineramaCopyClip(GCPtr, GCPtr);
+
+GCFuncs XineramaGCFuncs = {
+ XineramaValidateGC, XineramaChangeGC, XineramaCopyGC, XineramaDestroyGC,
+ XineramaChangeClip, XineramaDestroyClip, XineramaCopyClip
+};
+
+#define Xinerama_GC_FUNC_PROLOGUE(pGC)\
+ PanoramiXGCPtr pGCPriv = \
+ (PanoramiXGCPtr) (pGC)->devPrivates[PanoramiXGCIndex].ptr;\
+ (pGC)->funcs = pGCPriv->wrapFuncs;
+
+#define Xinerama_GC_FUNC_EPILOGUE(pGC)\
+ pGCPriv->wrapFuncs = (pGC)->funcs;\
+ (pGC)->funcs = &XineramaGCFuncs;
+
+
+static Bool
+XineramaCloseScreen (int i, ScreenPtr pScreen)
+{
+ PanoramiXScreenPtr pScreenPriv =
+ (PanoramiXScreenPtr) pScreen->devPrivates[PanoramiXScreenIndex].ptr;
+
+ pScreen->CloseScreen = pScreenPriv->CloseScreen;
+ pScreen->CreateGC = pScreenPriv->CreateGC;
+
+ REGION_UNINIT(pScreen, &XineramaScreenRegions[pScreen->myNum]);
+ if (pScreen->myNum == 0)
+ REGION_UNINIT(pScreen, &PanoramiXScreenRegion);
+
+ xfree ((pointer) pScreenPriv);
+
+ return (*pScreen->CloseScreen) (i, pScreen);
+}
+
+Bool
+XineramaCreateGC(GCPtr pGC)
+{
+ ScreenPtr pScreen = pGC->pScreen;
+ PanoramiXScreenPtr pScreenPriv =
+ (PanoramiXScreenPtr) pScreen->devPrivates[PanoramiXScreenIndex].ptr;
+ Bool ret;
+
+ pScreen->CreateGC = pScreenPriv->CreateGC;
+ if((ret = (*pScreen->CreateGC)(pGC))) {
+ PanoramiXGCPtr pGCPriv =
+ (PanoramiXGCPtr) pGC->devPrivates[PanoramiXGCIndex].ptr;
+
+ pGCPriv->wrapFuncs = pGC->funcs;
+ pGC->funcs = &XineramaGCFuncs;
+
+ pGCPriv->clipOrg.x = pGC->clipOrg.x;
+ pGCPriv->clipOrg.y = pGC->clipOrg.y;
+ pGCPriv->patOrg.x = pGC->patOrg.x;
+ pGCPriv->patOrg.y = pGC->patOrg.y;
+ }
+ pScreen->CreateGC = XineramaCreateGC;
+
+ return ret;
+}
+
+static void
+XineramaValidateGC(
+ GCPtr pGC,
+ unsigned long changes,
+ DrawablePtr pDraw
+){
+ Xinerama_GC_FUNC_PROLOGUE (pGC);
+
+ if((pDraw->type == DRAWABLE_WINDOW) && !(((WindowPtr)pDraw)->parent)) {
+ /* the root window */
+ int x_off = panoramiXdataPtr[pGC->pScreen->myNum].x;
+ int y_off = panoramiXdataPtr[pGC->pScreen->myNum].y;
+ int new_val;
+
+ new_val = pGCPriv->clipOrg.x - x_off;
+ if(pGC->clipOrg.x != new_val) {
+ pGC->clipOrg.x = new_val;
+ changes |= GCClipXOrigin;
+ }
+ new_val = pGCPriv->clipOrg.y - y_off;
+ if(pGC->clipOrg.y != new_val) {
+ pGC->clipOrg.y = new_val;
+ changes |= GCClipYOrigin;
+ }
+ new_val = pGCPriv->patOrg.x - x_off;
+ if(pGC->patOrg.x != new_val) {
+ pGC->patOrg.x = new_val;
+ changes |= GCTileStipXOrigin;
+ }
+ new_val = pGCPriv->patOrg.y - y_off;
+ if(pGC->patOrg.y != new_val) {
+ pGC->patOrg.y = new_val;
+ changes |= GCTileStipYOrigin;
+ }
+ } else {
+ if(pGC->clipOrg.x != pGCPriv->clipOrg.x) {
+ pGC->clipOrg.x = pGCPriv->clipOrg.x;
+ changes |= GCClipXOrigin;
+ }
+ if(pGC->clipOrg.y != pGCPriv->clipOrg.y) {
+ pGC->clipOrg.y = pGCPriv->clipOrg.y;
+ changes |= GCClipYOrigin;
+ }
+ if(pGC->patOrg.x != pGCPriv->patOrg.x) {
+ pGC->patOrg.x = pGCPriv->patOrg.x;
+ changes |= GCTileStipXOrigin;
+ }
+ if(pGC->patOrg.y != pGCPriv->patOrg.y) {
+ pGC->patOrg.y = pGCPriv->patOrg.y;
+ changes |= GCTileStipYOrigin;
+ }
+ }
+
+ (*pGC->funcs->ValidateGC)(pGC, changes, pDraw);
+ Xinerama_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+XineramaDestroyGC(GCPtr pGC)
+{
+ Xinerama_GC_FUNC_PROLOGUE (pGC);
+ (*pGC->funcs->DestroyGC)(pGC);
+ Xinerama_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+XineramaChangeGC (
+ GCPtr pGC,
+ unsigned long mask
+){
+ Xinerama_GC_FUNC_PROLOGUE (pGC);
+
+ if(mask & GCTileStipXOrigin)
+ pGCPriv->patOrg.x = pGC->patOrg.x;
+ if(mask & GCTileStipYOrigin)
+ pGCPriv->patOrg.y = pGC->patOrg.y;
+ if(mask & GCClipXOrigin)
+ pGCPriv->clipOrg.x = pGC->clipOrg.x;
+ if(mask & GCClipYOrigin)
+ pGCPriv->clipOrg.y = pGC->clipOrg.y;
+
+ (*pGC->funcs->ChangeGC) (pGC, mask);
+ Xinerama_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+XineramaCopyGC (
+ GCPtr pGCSrc,
+ unsigned long mask,
+ GCPtr pGCDst
+){
+ PanoramiXGCPtr pSrcPriv =
+ (PanoramiXGCPtr) pGCSrc->devPrivates[PanoramiXGCIndex].ptr;
+ Xinerama_GC_FUNC_PROLOGUE (pGCDst);
+
+ if(mask & GCTileStipXOrigin)
+ pGCPriv->patOrg.x = pSrcPriv->patOrg.x;
+ if(mask & GCTileStipYOrigin)
+ pGCPriv->patOrg.y = pSrcPriv->patOrg.y;
+ if(mask & GCClipXOrigin)
+ pGCPriv->clipOrg.x = pSrcPriv->clipOrg.x;
+ if(mask & GCClipYOrigin)
+ pGCPriv->clipOrg.y = pSrcPriv->clipOrg.y;
+
+ (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
+ Xinerama_GC_FUNC_EPILOGUE (pGCDst);
+}
+
+static void
+XineramaChangeClip (
+ GCPtr pGC,
+ int type,
+ pointer pvalue,
+ int nrects
+){
+ Xinerama_GC_FUNC_PROLOGUE (pGC);
+ (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
+ Xinerama_GC_FUNC_EPILOGUE (pGC);
+}
+
+static void
+XineramaCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
+{
+ Xinerama_GC_FUNC_PROLOGUE (pgcDst);
+ (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
+ Xinerama_GC_FUNC_EPILOGUE (pgcDst);
+}
+
+static void
+XineramaDestroyClip(GCPtr pGC)
+{
+ Xinerama_GC_FUNC_PROLOGUE (pGC);
+ (* pGC->funcs->DestroyClip)(pGC);
+ Xinerama_GC_FUNC_EPILOGUE (pGC);
+}
+
+
+
+int
+XineramaDeleteResource(pointer data, XID id)
+{
+ xfree(data);
+ return 1;
+}
+
+
+static Bool
+XineramaFindIDOnAnyScreen(pointer resource, XID id, pointer privdata)
+{
+ PanoramiXRes *res = (PanoramiXRes*)resource;
+ int j;
+
+ FOR_NSCREENS(j)
+ if(res->info[j].id == *((XID*)privdata)) return TRUE;
+
+ return FALSE;
+}
+
+PanoramiXRes *
+PanoramiXFindIDOnAnyScreen(RESTYPE type, XID id)
+{
+ return LookupClientResourceComplex(clients[CLIENT_ID(id)], type,
+ XineramaFindIDOnAnyScreen, &id);
+}
+
+typedef struct {
+ int screen;
+ int id;
+} PanoramiXSearchData;
+
+
+static Bool
+XineramaFindIDByScrnum(pointer resource, XID id, pointer privdata)
+{
+ PanoramiXRes *res = (PanoramiXRes*)resource;
+ PanoramiXSearchData *data = (PanoramiXSearchData*)privdata;
+
+ return (res->info[data->screen].id == data->id);
+}
+
+PanoramiXRes *
+PanoramiXFindIDByScrnum(RESTYPE type, XID id, int screen)
+{
+ PanoramiXSearchData data;
+
+ if(!screen)
+ return LookupIDByType(id, type);
+
+ data.screen = screen;
+ data.id = id;
+
+ return LookupClientResourceComplex(clients[CLIENT_ID(id)], type,
+ XineramaFindIDByScrnum, &data);
+}
+
+WindowPtr
+PanoramiXChangeWindow(int ScrnNum, WindowPtr pWin)
+{
+ int num = pWin->drawable.pScreen->myNum;
+
+ if(num != ScrnNum) {
+ PanoramiXRes *win;
+
+ win = PanoramiXFindIDByScrnum(XRT_WINDOW, pWin->drawable.id, num);
+
+ if (win)
+ pWin = (WindowPtr) LookupIDByType(win->info[ScrnNum].id, RT_WINDOW);
+ }
+
+ return pWin;
+}
+
+typedef struct _connect_callback_list {
+ void (*func)(void);
+ struct _connect_callback_list *next;
+} XineramaConnectionCallbackList;
+
+static XineramaConnectionCallbackList *ConnectionCallbackList = NULL;
+
+Bool
+XineramaRegisterConnectionBlockCallback(void (*func)(void))
+{
+ XineramaConnectionCallbackList *newlist;
+
+ if(!(newlist = xalloc(sizeof(XineramaConnectionCallbackList))))
+ return FALSE;
+
+ newlist->next = ConnectionCallbackList;
+ newlist->func = func;
+ ConnectionCallbackList = newlist;
+
+ return TRUE;
+}
/*
* PanoramiXExtensionInit():
@@ -134,14 +457,16 @@ int PanoramiXFreeColors(), PanoramiXStoreColors();
void PanoramiXExtensionInit(int argc, char *argv[])
{
- int i, j, PhyScrNum, ArgScrNum;
- Bool success = FALSE;
- ExtensionEntry *extEntry, *AddExtension();
- PanoramiXData *panoramiXtempPtr;
- ScreenPtr pScreen;
+ int i;
+ Bool success = FALSE;
+ ExtensionEntry *extEntry;
+ ScreenPtr pScreen;
+ PanoramiXScreenPtr pScreenPriv;
+ int w, h;
- if (!noPanoramiXExtension)
- {
+ if (noPanoramiXExtension)
+ return;
+
GlobalScrInfo = &screenInfo; /* For debug visibility */
PanoramiXNumScreens = screenInfo.numScreens;
if (PanoramiXNumScreens == 1) { /* Only 1 screen */
@@ -165,13 +490,43 @@ void PanoramiXExtensionInit(int argc, char *argv[])
* run in non-PanoramiXeen mode.
*/
- panoramiXdataPtr = (PanoramiXData *) Xcalloc(PanoramiXNumScreens * sizeof(PanoramiXData));
- PanoramiXWinRoot = (PanoramiXWindow *) Xcalloc(sizeof(PanoramiXWindow));
- PanoramiXGCRoot = (PanoramiXGC *) Xcalloc(sizeof(PanoramiXGC));
- PanoramiXCmapRoot = (PanoramiXCmap *) Xcalloc(sizeof(PanoramiXCmap));
- PanoramiXPmapRoot = (PanoramiXPmap *) Xcalloc(sizeof(PanoramiXPmap));
- BREAK_IF(!(panoramiXdataPtr && PanoramiXWinRoot && PanoramiXGCRoot &&
- PanoramiXCmapRoot && PanoramiXPmapRoot));
+ panoramiXdataPtr = (PanoramiXData *)
+ xcalloc(PanoramiXNumScreens, sizeof(PanoramiXData));
+
+ BREAK_IF(!panoramiXdataPtr);
+ BREAK_IF((PanoramiXGCIndex = AllocateGCPrivateIndex()) < 0);
+ BREAK_IF((PanoramiXScreenIndex = AllocateScreenPrivateIndex()) < 0);
+
+ for (i = 0; i < PanoramiXNumScreens; i++) {
+ pScreen = screenInfo.screens[i];
+ if(!AllocateGCPrivate(pScreen, PanoramiXGCIndex,
+ sizeof(PanoramiXGCRec))) {
+ noPanoramiXExtension = TRUE;
+ return;
+ }
+
+ pScreenPriv = xalloc(sizeof(PanoramiXScreenRec));
+ pScreen->devPrivates[PanoramiXScreenIndex].ptr =
+ (pointer)pScreenPriv;
+ if(!pScreenPriv) {
+ noPanoramiXExtension = TRUE;
+ return;
+ }
+
+ pScreenPriv->CreateGC = pScreen->CreateGC;
+ pScreenPriv->CloseScreen = pScreen->CloseScreen;
+
+ pScreen->CreateGC = XineramaCreateGC;
+ pScreen->CloseScreen = XineramaCloseScreen;
+ }
+
+ XRC_DRAWABLE = CreateNewResourceClass();
+ XRT_WINDOW = CreateNewResourceType(XineramaDeleteResource) |
+ XRC_DRAWABLE;
+ XRT_PIXMAP = CreateNewResourceType(XineramaDeleteResource) |
+ XRC_DRAWABLE;
+ XRT_GC = CreateNewResourceType(XineramaDeleteResource);
+ XRT_COLORMAP = CreateNewResourceType(XineramaDeleteResource);
panoramiXGeneration = serverGeneration;
success = TRUE;
@@ -182,117 +537,40 @@ void PanoramiXExtensionInit(int argc, char *argv[])
ErrorF("%s Extension failed to initialize\n", PANORAMIX_PROTOCOL_NAME);
return;
}
-
- /* Set up a default configuration base on horizontal ordering */
- for (i = PanoramiXNumScreens -1; i >= 0 ; i--) {
- panoramiXdataPtr[i].above = panoramiXdataPtr[i].below = -1;
- panoramiXdataPtr[i].left = panoramiXdataPtr[i].right = -1;
- panoramiXEdgePtr[i].no_edges = TRUE;
- }
- for (i = PanoramiXNumScreens - 1; i >= 0; i--) {
- panoramiXdataPtr[i].left = i - 1;
- panoramiXdataPtr[i].right = i + 1;
- }
- panoramiXdataPtr[PanoramiXNumScreens - 1].right = -1;
+
- /*
- * Position the screens relative to each other based on
- * command line options.
- */
+ REGION_INIT(pScreen, &PanoramiXScreenRegion, NullBox, 1);
+ for (i = 0; i < PanoramiXNumScreens; i++) {
+ BoxRec TheBox;
-#if 0
- for (PhyScrNum = PanoramiXNumScreens - 1; PhyScrNum >= 0; PhyScrNum--) {
- if (wsRemapPhysToLogScreens)
- i = wsPhysToLogScreens[PhyScrNum];
- else
- i = PhyScrNum;
- if (i < 0)
- continue;
- panoramiXdataPtr[i].width = (screenInfo.screens[i])->width;
- panoramiXdataPtr[i].height = (screenInfo.screens[i])->height;
- if (screenArgs[i].flags & ARG_EDGE_L) {
- ArgScrNum = screenArgs[PhyScrNum].edge_left;
- if (ArgScrNum < 0)
- j = -1;
- else {
- if (wsRemapPhysToLogScreens)
- j = wsPhysToLogScreens[ArgScrNum];
- else
- j = ArgScrNum;
- }
- panoramiXdataPtr[i].left = j;
- panoramiXEdgePtr[i].no_edges = FALSE;
- if ( j >= 0)
- panoramiXdataPtr[j].right = i;
- else {
- if ( i >= 1 )
- panoramiXdataPtr[i - 1].right = -1;
- }
- }
- if (screenArgs[i].flags & ARG_EDGE_R) {
- ArgScrNum = screenArgs[PhyScrNum].edge_right;
- if (ArgScrNum < 0)
- j = -1;
- else {
- if (wsRemapPhysToLogScreens)
- j = wsPhysToLogScreens[ArgScrNum];
- else
- j = ArgScrNum;
- }
- panoramiXdataPtr[i].right = j;
- panoramiXEdgePtr[i].no_edges = FALSE;
- if ( j >= 0)
- panoramiXdataPtr[j].left = i;
- }
- if (screenArgs[i].flags & ARG_EDGE_T) {
- ArgScrNum = screenArgs[PhyScrNum].edge_top;
- if (ArgScrNum < 0)
- j = -1;
- else {
- if (wsRemapPhysToLogScreens)
- j = wsPhysToLogScreens[ArgScrNum];
- else
- j = ArgScrNum;
- }
- panoramiXdataPtr[i].above = j;
- panoramiXEdgePtr[i].no_edges = FALSE;
- if ( j >= 0)
- panoramiXdataPtr[j].below = i;
- }
- if (screenArgs[i].flags & ARG_EDGE_B) {
- ArgScrNum = screenArgs[PhyScrNum].edge_bottom;
- if (ArgScrNum < 0)
- j = -1;
- else {
- if (wsRemapPhysToLogScreens)
- j = wsPhysToLogScreens[ArgScrNum];
- else
- j = ArgScrNum;
- }
- panoramiXdataPtr[i].below = j;
- panoramiXEdgePtr[i].no_edges = FALSE;
- if ( j >= 0)
- panoramiXdataPtr[j].above = i;
- }
- }
-#else
- for (PhyScrNum = PanoramiXNumScreens - 1; PhyScrNum >= 0; PhyScrNum--) {
- i = PhyScrNum;
- if (i < 0)
- continue;
+ panoramiXdataPtr[i].x = dixScreenOrigins[i].x;
+ panoramiXdataPtr[i].y = dixScreenOrigins[i].y;
panoramiXdataPtr[i].width = (screenInfo.screens[i])->width;
panoramiXdataPtr[i].height = (screenInfo.screens[i])->height;
+
+ TheBox.x1 = panoramiXdataPtr[i].x;
+ TheBox.x2 = TheBox.x1 + panoramiXdataPtr[i].width;
+ TheBox.y1 = panoramiXdataPtr[i].y;
+ TheBox.y2 = TheBox.y1 + panoramiXdataPtr[i].height;
+
+ REGION_INIT(pScreen, &XineramaScreenRegions[i], &TheBox, 1);
+ REGION_UNION(pScreen, &PanoramiXScreenRegion, &PanoramiXScreenRegion,
+ &XineramaScreenRegions[i]);
}
-#endif
- /*
- * Find the upper-left screen and then locate all the others
- */
- panoramiXtempPtr = panoramiXdataPtr;
- for (i = PanoramiXNumScreens; i; i--, panoramiXtempPtr++)
- if (panoramiXtempPtr->above == -1 && panoramiXtempPtr->left == -1)
- break;
- locate_neighbors(PanoramiXNumScreens - i);
+
+ PanoramiXPixWidth = panoramiXdataPtr[0].x + panoramiXdataPtr[0].width;
+ PanoramiXPixHeight = panoramiXdataPtr[0].y + panoramiXdataPtr[0].height;
+
+ for (i = 1; i < PanoramiXNumScreens; i++) {
+ w = panoramiXdataPtr[i].x + panoramiXdataPtr[i].width;
+ h = panoramiXdataPtr[i].y + panoramiXdataPtr[i].height;
+
+ if(PanoramiXPixWidth < w)
+ PanoramiXPixWidth = w;
+ if(PanoramiXPixHeight < h)
+ PanoramiXPixHeight = h;
+ }
/*
* Put our processes into the ProcVector
@@ -314,9 +592,7 @@ void PanoramiXExtensionInit(int argc, char *argv[])
ProcVector[X_ConfigureWindow] = PanoramiXConfigureWindow;
ProcVector[X_CirculateWindow] = PanoramiXCirculateWindow;
ProcVector[X_GetGeometry] = PanoramiXGetGeometry;
- ProcVector[X_ChangeProperty] = PanoramiXChangeProperty;
- ProcVector[X_DeleteProperty] = PanoramiXDeleteProperty;
- ProcVector[X_SendEvent] = PanoramiXSendEvent;
+ ProcVector[X_TranslateCoords] = PanoramiXTranslateCoords;
ProcVector[X_CreatePixmap] = PanoramiXCreatePixmap;
ProcVector[X_FreePixmap] = PanoramiXFreePixmap;
ProcVector[X_CreateGC] = PanoramiXCreateGC;
@@ -344,252 +620,262 @@ void PanoramiXExtensionInit(int argc, char *argv[])
ProcVector[X_ImageText16] = PanoramiXImageText16;
ProcVector[X_CreateColormap] = PanoramiXCreateColormap;
ProcVector[X_FreeColormap] = PanoramiXFreeColormap;
+ ProcVector[X_CopyColormapAndFree] = PanoramiXCopyColormapAndFree;
ProcVector[X_InstallColormap] = PanoramiXInstallColormap;
ProcVector[X_UninstallColormap] = PanoramiXUninstallColormap;
ProcVector[X_AllocColor] = PanoramiXAllocColor;
ProcVector[X_AllocNamedColor] = PanoramiXAllocNamedColor;
ProcVector[X_AllocColorCells] = PanoramiXAllocColorCells;
+ ProcVector[X_AllocColorPlanes] = PanoramiXAllocColorPlanes;
ProcVector[X_FreeColors] = PanoramiXFreeColors;
- ProcVector[X_StoreColors] = PanoramiXStoreColors;
+ ProcVector[X_StoreColors] = PanoramiXStoreColors;
+ ProcVector[X_StoreNamedColor] = PanoramiXStoreNamedColor;
- }
- else
- return;
+#ifdef RENDER
+ PanoramiXRenderInit ();
+#endif
}
-extern
+
+extern Bool CreateConnectionBlock(void);
+
Bool PanoramiXCreateConnectionBlock(void)
{
- int i;
+ int i, j, length;
+ Bool disableBackingStore = FALSE;
+ Bool disableSaveUnders = FALSE;
int old_width, old_height;
- int width_mult, height_mult;
+ float width_mult, height_mult;
xWindowRoot *root;
xConnSetup *setup;
+ xVisualType *visual;
+ xDepth *depth;
+ VisualPtr pVisual;
+ ScreenPtr pScreen;
/*
* Do normal CreateConnectionBlock but faking it for only one screen
*/
+ if(!PanoramiXNumDepths) {
+ ErrorF("PanoramiX error: Incompatible screens. No common visuals\n");
+ return FALSE;
+ }
+
+ for(i = 1; i < screenInfo.numScreens; i++) {
+ pScreen = screenInfo.screens[i];
+ if(pScreen->rootDepth != screenInfo.screens[0]->rootDepth) {
+ ErrorF("PanoramiX error: Incompatible screens. Root window depths differ\n");
+ return FALSE;
+ }
+ if(pScreen->backingStoreSupport != screenInfo.screens[0]->backingStoreSupport)
+ disableBackingStore = TRUE;
+ if(pScreen->saveUnderSupport != screenInfo.screens[0]->saveUnderSupport)
+ disableSaveUnders = TRUE;
+ }
+
+ if(disableBackingStore || disableSaveUnders) {
+ for(i = 0; i < screenInfo.numScreens; i++) {
+ pScreen = screenInfo.screens[i];
+ if(disableBackingStore)
+ pScreen->backingStoreSupport = NotUseful;
+ if(disableSaveUnders)
+ pScreen->saveUnderSupport = NotUseful;
+ }
+ }
+
+ i = screenInfo.numScreens;
+ screenInfo.numScreens = 1;
if (!CreateConnectionBlock()) {
+ screenInfo.numScreens = i;
return FALSE;
}
+ screenInfo.numScreens = i;
+
+ setup = (xConnSetup *) ConnectionInfo;
+ root = (xWindowRoot *) (ConnectionInfo + connBlockScreenStart);
+ length = connBlockScreenStart + sizeof(xWindowRoot);
+
+ /* overwrite the connection block */
+ root->nDepths = PanoramiXNumDepths;
+
+ for (i = 0; i < PanoramiXNumDepths; i++) {
+ depth = (xDepth *) (ConnectionInfo + length);
+ depth->depth = PanoramiXDepths[i].depth;
+ depth->nVisuals = PanoramiXDepths[i].numVids;
+ length += sizeof(xDepth);
+ visual = (xVisualType *)(ConnectionInfo + length);
+
+ for (j = 0; j < depth->nVisuals; j++, visual++) {
+ visual->visualID = PanoramiXDepths[i].vids[j];
+
+ for (pVisual = PanoramiXVisuals;
+ pVisual->vid != visual->visualID;
+ pVisual++)
+ ;
+
+ visual->class = pVisual->class;
+ visual->bitsPerRGB = pVisual->bitsPerRGBValue;
+ visual->colormapEntries = pVisual->ColormapEntries;
+ visual->redMask = pVisual->redMask;
+ visual->greenMask = pVisual->greenMask;
+ visual->blueMask = pVisual->blueMask;
+ }
+
+ length += (depth->nVisuals * sizeof(xVisualType));
+ }
+
+ connSetupPrefix.length = length >> 2;
+
+ xfree(PanoramiXVisuals);
+ for (i = 0; i < PanoramiXNumDepths; i++)
+ xfree(PanoramiXDepths[i].vids);
+ xfree(PanoramiXDepths);
+
/*
* OK, change some dimensions so it looks as if it were one big screen
*/
-
- setup = (xConnSetup *) ConnectionInfo;
- setup->numRoots = 1;
- root = (xWindowRoot *) (ConnectionInfo + connBlockScreenStart);
old_width = root->pixWidth;
old_height = root->pixHeight;
- for (i = PanoramiXNumScreens - 1; i >= 0; i--) {
- if (panoramiXdataPtr[i].right == -1 )
- root->pixWidth = panoramiXdataPtr[i].x + panoramiXdataPtr[i].width;
- if (panoramiXdataPtr[i].below == -1)
- root->pixHeight = panoramiXdataPtr[i].y + panoramiXdataPtr[i].height;
- }
- PanoramiXPixWidth = root->pixWidth;
- PanoramiXPixHeight = root->pixHeight;
- width_mult = root->pixWidth / old_width;
- height_mult = root->pixHeight / old_height;
+
+ root->pixWidth = PanoramiXPixWidth;
+ root->pixHeight = PanoramiXPixHeight;
+ width_mult = (1.0 * root->pixWidth) / old_width;
+ height_mult = (1.0 * root->pixHeight) / old_height;
root->mmWidth *= width_mult;
root->mmHeight *= height_mult;
- return TRUE;
-}
-extern
-Bool PanoramiXCreateScreenRegion(pWin)
-WindowPtr pWin;
-{
- ScreenPtr pScreen;
- BoxRec box;
- int i;
- Bool ret;
-
- pScreen = pWin->drawable.pScreen;
- for (i = 0; i < PanoramiXNumScreens; i++) {
- box.x1 = 0 - panoramiXdataPtr[i].x;
- box.x2 = box.x1 + PanoramiXPixWidth;
- box.y1 = 0 - panoramiXdataPtr[i].y;
- box.y2 = box.y1 + PanoramiXPixHeight;
- REGION_INIT(pScreen, &PanoramiXScreenRegion[i], &box, 1);
- ret = REGION_NOTEMPTY(pScreen, &PanoramiXScreenRegion[i]);
- if (!ret)
- return ret;
- }
- return ret;
-}
+ while(ConnectionCallbackList) {
+ pointer tmp;
-extern
-void PanoramiXDestroyScreenRegion(pWin)
-WindowPtr pWin;
-{
- ScreenPtr pScreen;
- int i;
- Bool ret;
+ tmp = (pointer)ConnectionCallbackList;
+ (*ConnectionCallbackList->func)();
+ ConnectionCallbackList = ConnectionCallbackList->next;
+ xfree(tmp);
+ }
- pScreen = pWin->drawable.pScreen;
- for (i = 0; i < PanoramiXNumScreens; i++)
- REGION_DESTROY(pScreen, &PanoramiXScreenRegion[i]);
+ return TRUE;
}
-/*
- * Assign the Root window and colormap ID's in the PanoramiXScreen Root
- * linked lists. Note: WindowTable gets setup in dix_main by
- * InitRootWindow, and GlobalScrInfo is screenInfo which gets setup
- * by InitOutput.
- */
extern
void PanoramiXConsolidate(void)
{
- int i,j,k,v,d,n, thisMaxDepth;
- int depthIndex;
- DepthPtr pDepth, pLargeDepth;
- VisualPtr pVisual;
- VisualID it;
- register WindowPtr pWin, pLargeWin;
- Bool SameDepth;
-
- PanoramiXLargestScreenDepth.numDepths = (screenInfo.screens[PanoramiXNumScreens -1])->numDepths;
- PanoramiXLargestScreenDepth.screenNum = PanoramiXNumScreens - 1;
- SameDepth = TRUE;
- for (i = 0; i < 2; i++)
- {
- for (j =0; j < 6; j++)
- {
- PanoramiXColorDepthTable[i].panoramiXScreenMap[j].numDepths=0;
- for (n = 0; n < 6; n++)
- {
- PanoramiXColorDepthTable[i].panoramiXScreenMap[j].listDepths[n]=0;
+ int i, j, k;
+ VisualPtr pVisual, pVisual2;
+ ScreenPtr pScreen, pScreen2;
+ PanoramiXRes *root, *defmap;
+
+ if(!PanoramiXVisualTable)
+ PanoramiXVisualTable = xcalloc(256 * MAXSCREENS, sizeof(XID));
+
+ pScreen = screenInfo.screens[0];
+ pVisual = pScreen->visuals;
+
+ PanoramiXNumDepths = 0;
+ PanoramiXDepths = xcalloc(pScreen->numDepths,sizeof(DepthRec));
+ PanoramiXNumVisuals = 0;
+ PanoramiXVisuals = xcalloc(pScreen->numVisuals,sizeof(VisualRec));
+
+ for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
+ PanoramiXVisualTable[pVisual->vid * MAXSCREENS] = pVisual->vid;
+
+ /* check if the visual exists on all screens */
+ for (j = 1; j < PanoramiXNumScreens; j++) {
+ pScreen2 = screenInfo.screens[j];
+ pVisual2 = pScreen2->visuals;
+
+ for (k = 0; k < pScreen2->numVisuals; k++, pVisual2++) {
+ if ((pVisual->class == pVisual2->class) &&
+ (pVisual->ColormapEntries == pVisual2->ColormapEntries) &&
+ (pVisual->nplanes == pVisual2->nplanes) &&
+ (pVisual->redMask == pVisual2->redMask) &&
+ (pVisual->greenMask == pVisual2->greenMask) &&
+ (pVisual->blueMask == pVisual2->blueMask) &&
+ (pVisual->offsetRed == pVisual2->offsetRed) &&
+ (pVisual->offsetGreen == pVisual2->offsetGreen) &&
+ (pVisual->offsetBlue == pVisual2->offsetBlue))
+ {
+ Bool AlreadyUsed = FALSE;
+#if 0
+/* Open GL should do this reduction, not us */
+ for (l = 0; l < 256; l++) {
+ if (pVisual2->vid ==
+ PanoramiXVisualTable[(l * MAXSCREENS) + j])
+ {
+ AlreadyUsed = TRUE;
+ break;
+ }
+ }
+#endif
+ if (!AlreadyUsed) {
+ PanoramiXVisualTable[(pVisual->vid * MAXSCREENS) + j] =
+ pVisual2->vid;
+ break;
+ }
+ }
+ }
}
- for (k = 0; k < 33; k++)
- {
- PanoramiXColorDepthTable[i].panoramiXScreenMap[j].vmap[k].numVids=0;
- for (v = 0; v < 10; v++)
- {
- PanoramiXColorDepthTable[i].panoramiXScreenMap[j].vmap[k].vid[v]=0;
+
+ /* if it doesn't exist on all screens we can't use it */
+ for (j = 0; j < PanoramiXNumScreens; j++) {
+ if (!PanoramiXVisualTable[(pVisual->vid * MAXSCREENS) + j]) {
+ PanoramiXVisualTable[pVisual->vid * MAXSCREENS] = 0;
+ break;
}
}
- }
- }
- for (i = PanoramiXNumScreens - 1; i >= 0; i--)
- {
- PanoramiXWinRoot->info[i].id = WindowTable[i]->drawable.id;
- PanoramiXCmapRoot->info[i].id = (screenInfo.screens[i])->defColormap;
-
- /* Create a Color-Depth-Table, this will help us deal
- with mixing graphics boards and visuals, of course
- given that the boards support multi-screen to begin
- with. Fill the panoramiXCDT table by screen, then
- visual type and allowable depths.
- */
- pWin = WindowTable[i];
- if ( (screenInfo.screens[i])->numDepths >
- PanoramiXLargestScreenDepth.numDepths )
- {
- PanoramiXLargestScreenDepth.numDepths = (screenInfo.screens[i])->numDepths;
- PanoramiXLargestScreenDepth.screenNum = i;
- SameDepth = FALSE;
- }
- for (v = 0, pVisual = pWin->drawable.pScreen->visuals;
- v < pWin->drawable.pScreen->numVisuals; v++, pVisual++)
- {
- PanoramiXColorDepthTable[i].panoramiXScreenMap[pVisual->class].numDepths = (screenInfo.screens[i])->numDepths;
- for ( j = 0; j < (screenInfo.screens[i])->numDepths; j++)
- {
- pDepth = (DepthPtr) &pWin->drawable.pScreen->allowedDepths[j];
- PanoramiXColorDepthTable[i].panoramiXScreenMap[pVisual->class].listDepths[j] = pDepth->depth;
- for (d = 0; d < pDepth->numVids; d++)
- {
- if (pVisual->vid == pDepth->vids[d])
- {
- PanoramiXColorDepthTable[i].
- panoramiXScreenMap[pVisual->class].vmap[pDepth->depth].
- vid[
- PanoramiXColorDepthTable[i].
- panoramiXScreenMap[pVisual->class].
- vmap[pDepth->depth].numVids++
- ]
- = pDepth->vids[d];
- }
- }
- }
- }
- PanoramiXColorDepthTable[i].numVisuals = 6;
- } /* for each screen */
- /* Fill in ColorDepthTable for mixed visuals with varying depth.
- Can't do that until we figure out how to handle mixed visuals
- and varying card visual/depth initialization. If we can decide
- how to map the relationship, then we can use this table to
- shove the information into and use for cross-referencing when
- necessary.
-
- In the meantime, check to see if the screens are the same,
- if they don't then disable panoramiX, print out a message,
- don't support this mode.
- */
-}
-/* Since locate_neighbors is recursive, a quick simple example
- is in order.This mostly so you can see what the initial values are.
-
- Given 3 screens:
- upperleft screen[0]
- panoramiXdataPtr[0].x = 0
- panoramiXdataPtr[0].y = 0
- panoramiXdataPtr[0].width = 640
- panoramiXdataPtr[0].height = 480
- panoramiXdataPtr[0].below = -1
- panoramiXdataPtr[0].right = 1
- panoramiXdataPtr[0].above = -1
- panoramiXdataPtr[0].left = -1
- middle screen[1]
- panoramiXdataPtr[1].x = 0
- panoramiXdataPtr[1].y = 0
- panoramiXdataPtr[1].width = 640
- panoramiXdataPtr[1].height = 480
- panoramiXdataPtr[1].below = -1
- panoramiXdataPtr[1].right = 2
- panoramiXdataPtr[1].above = -1
- panoramiXdataPtr[1].left = 0
- last right screen[2]
- panoramiXdataPtr[2].x = 0
- panoramiXdataPtr[2].y = 0
- panoramiXdataPtr[2].width = 640
- panoramiXdataPtr[2].height = 480
- panoramiXdataPtr[2].below = -1
- panoramiXdataPtr[2].right = -1
- panoramiXdataPtr[2].above = -1
- panoramiXdataPtr[2].left = 1
-
- Calling locate_neighbors(0) results in:
- panoramiXdataPtr[0].x = 0
- panoramiXdataPtr[0].y = 0
- panoramiXdataPtr[1].x = 640
- panoramiXdataPtr[1].y = 0
- panoramiXdataPtr[2].x = 1280
- panoramiXdataPtr[2].y = 0
-*/
-
-static void locate_neighbors(int i)
-{
- int j;
-
- j = panoramiXdataPtr[i].right;
- if ((j != -1) && !panoramiXdataPtr[j].x && !panoramiXdataPtr[j].y) {
- panoramiXdataPtr[j].x = panoramiXdataPtr[i].x + panoramiXdataPtr[i].width;
- panoramiXdataPtr[j].y = panoramiXdataPtr[i].y;
- locate_neighbors(j);
- }
- j = panoramiXdataPtr[i].below;
- if ((j != -1) && !panoramiXdataPtr[j].x && !panoramiXdataPtr[j].y) {
- panoramiXdataPtr[j].y = panoramiXdataPtr[i].y + panoramiXdataPtr[i].height;
- panoramiXdataPtr[j].x = panoramiXdataPtr[i].x;
- locate_neighbors(j);
+ /* if it does, make sure it's in the list of supported depths and visuals */
+ if(PanoramiXVisualTable[pVisual->vid * MAXSCREENS]) {
+ Bool GotIt = FALSE;
+
+ PanoramiXVisuals[PanoramiXNumVisuals].vid = pVisual->vid;
+ PanoramiXVisuals[PanoramiXNumVisuals].class = pVisual->class;
+ PanoramiXVisuals[PanoramiXNumVisuals].bitsPerRGBValue = pVisual->bitsPerRGBValue;
+ PanoramiXVisuals[PanoramiXNumVisuals].ColormapEntries = pVisual->ColormapEntries;
+ PanoramiXVisuals[PanoramiXNumVisuals].nplanes = pVisual->nplanes;
+ PanoramiXVisuals[PanoramiXNumVisuals].redMask = pVisual->redMask;
+ PanoramiXVisuals[PanoramiXNumVisuals].greenMask = pVisual->greenMask;
+ PanoramiXVisuals[PanoramiXNumVisuals].blueMask = pVisual->blueMask;
+ PanoramiXVisuals[PanoramiXNumVisuals].offsetRed = pVisual->offsetRed;
+ PanoramiXVisuals[PanoramiXNumVisuals].offsetGreen = pVisual->offsetGreen;
+ PanoramiXVisuals[PanoramiXNumVisuals].offsetBlue = pVisual->offsetBlue;
+ PanoramiXNumVisuals++;
+
+ for (j = 0; j < PanoramiXNumDepths; j++) {
+ if (PanoramiXDepths[j].depth == pVisual->nplanes) {
+ PanoramiXDepths[j].vids[PanoramiXDepths[j].numVids] = pVisual->vid;
+ PanoramiXDepths[j].numVids++;
+ GotIt = TRUE;
+ break;
+ }
+ }
+
+ if (!GotIt) {
+ PanoramiXDepths[PanoramiXNumDepths].depth = pVisual->nplanes;
+ PanoramiXDepths[PanoramiXNumDepths].numVids = 1;
+ PanoramiXDepths[PanoramiXNumDepths].vids = xalloc(sizeof(VisualID) * 256);
+ PanoramiXDepths[PanoramiXNumDepths].vids[0] = pVisual->vid;
+ PanoramiXNumDepths++;
+ }
+ }
+ }
+
+
+ root = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes));
+ root->type = XRT_WINDOW;
+ defmap = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes));
+ defmap->type = XRT_COLORMAP;
+
+ for (i = 0; i < PanoramiXNumScreens; i++) {
+ root->info[i].id = WindowTable[i]->drawable.id;
+ root->u.win.class = InputOutput;
+ defmap->info[i].id = (screenInfo.screens[i])->defColormap;
}
-}
+ AddResource(root->info[0].id, XRT_WINDOW, root);
+ AddResource(defmap->info[0].id, XRT_COLORMAP, defmap);
+}
/*
@@ -597,46 +883,25 @@ static void locate_neighbors(int i)
* Exit, deallocating as needed.
*/
-static void PanoramiXResetProc(extEntry)
- ExtensionEntry* extEntry;
+static void PanoramiXResetProc(ExtensionEntry* extEntry)
{
int i;
- PanoramiXList *pPanoramiXList;
- PanoramiXList *tempList;
- for (pPanoramiXList = PanoramiXPmapRoot; pPanoramiXList; pPanoramiXList = tempList){
- tempList = pPanoramiXList->next;
- Xfree(pPanoramiXList);
- }
- for (pPanoramiXList = PanoramiXCmapRoot; pPanoramiXList; pPanoramiXList = tempList){
- tempList = pPanoramiXList->next;
- Xfree(pPanoramiXList);
- }
- for (pPanoramiXList = PanoramiXGCRoot; pPanoramiXList; pPanoramiXList = tempList) {
- tempList = pPanoramiXList->next;
- Xfree(pPanoramiXList);
- }
- for (pPanoramiXList = PanoramiXWinRoot; pPanoramiXList; pPanoramiXList = tempList) {
- tempList = pPanoramiXList->next;
- Xfree(pPanoramiXList);
- }
+#ifdef RENDER
+ PanoramiXRenderReset ();
+#endif
screenInfo.numScreens = PanoramiXNumScreens;
for (i = 256; i--; )
ProcVector[i] = SavedProcVector[i];
- Xfree(panoramiXdataPtr);
-
+
+ Xfree(panoramiXdataPtr);
}
int
-#if NeedFunctionPrototypes
ProcPanoramiXQueryVersion (ClientPtr client)
-#else
-ProcPanoramiXQueryVersion (client)
- register ClientPtr client;
-#endif
{
- REQUEST(xPanoramiXQueryVersionReq);
+ /* REQUEST(xPanoramiXQueryVersionReq); */
xPanoramiXQueryVersionReply rep;
register int n;
@@ -649,18 +914,15 @@ ProcPanoramiXQueryVersion (client)
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
+ swaps(&rep.majorVersion, n);
+ swaps(&rep.minorVersion, n);
}
WriteToClient(client, sizeof (xPanoramiXQueryVersionReply), (char *)&rep);
return (client->noClientException);
}
int
-#if NeedFunctionPrototypes
ProcPanoramiXGetState(ClientPtr client)
-#else
-ProcPanoramiXGetState(client)
- register ClientPtr client;
-#endif
{
REQUEST(xPanoramiXGetStateReq);
WindowPtr pWin;
@@ -686,12 +948,7 @@ ProcPanoramiXGetState(client)
}
int
-#if NeedFunctionPrototypes
ProcPanoramiXGetScreenCount(ClientPtr client)
-#else
-ProcPanoramiXGetScreenCount(client)
- register ClientPtr client;
-#endif
{
REQUEST(xPanoramiXGetScreenCountReq);
WindowPtr pWin;
@@ -716,12 +973,7 @@ ProcPanoramiXGetScreenCount(client)
}
int
-#if NeedFunctionPrototypes
ProcPanoramiXGetScreenSize(ClientPtr client)
-#else
-ProcPanoramiXGetScreenSize(client)
- register ClientPtr client;
-#endif
{
REQUEST(xPanoramiXGetScreenSizeReq);
WindowPtr pWin;
@@ -741,29 +993,84 @@ ProcPanoramiXGetScreenSize(client)
if (client->swapped) {
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);
- swaps (rep.width, n);
- swaps (rep.height, n);
+ swaps (&rep.width, n);
+ swaps (&rep.height, n);
}
WriteToClient (client, sizeof (xPanoramiXGetScreenSizeReply), (char *) &rep);
return client->noClientException;
}
-void PrintList(PanoramiXList *head)
+int
+ProcXineramaIsActive(ClientPtr client)
+{
+ /* REQUEST(xXineramaIsActiveReq); */
+ xXineramaIsActiveReply rep;
+
+ REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
+
+ rep.type = X_Reply;
+ rep.length = 0;
+ rep.sequenceNumber = client->sequence;
+ rep.state = !noPanoramiXExtension;
+ if (client->swapped) {
+ register int n;
+ swaps (&rep.sequenceNumber, n);
+ swapl (&rep.length, n);
+ swapl (&rep.state, n);
+ }
+ WriteToClient (client, sizeof (xXineramaIsActiveReply), (char *) &rep);
+ return client->noClientException;
+}
+
+
+int
+ProcXineramaQueryScreens(ClientPtr client)
{
- int i = 0;
+ /* REQUEST(xXineramaQueryScreensReq); */
+ xXineramaQueryScreensReply rep;
+
+ REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
+
+ rep.type = X_Reply;
+ rep.sequenceNumber = client->sequence;
+ rep.number = (noPanoramiXExtension) ? 0 : PanoramiXNumScreens;
+ rep.length = rep.number * sz_XineramaScreenInfo >> 2;
+ if (client->swapped) {
+ register int n;
+ swaps (&rep.sequenceNumber, n);
+ swapl (&rep.length, n);
+ swapl (&rep.number, n);
+ }
+ WriteToClient (client, sizeof (xXineramaQueryScreensReply), (char *) &rep);
- for (; head; i++, head = head->next)
- fprintf(stderr, "%2d next = 0x%010lx, id[0] = 0x%08x, id[1] = 0x%08x\n",
- i, head->next, head->info[0].id, head->info[1].id);
+ if(!noPanoramiXExtension) {
+ xXineramaScreenInfo scratch;
+ int i;
+
+ for(i = 0; i < PanoramiXNumScreens; i++) {
+ scratch.x_org = panoramiXdataPtr[i].x;
+ scratch.y_org = panoramiXdataPtr[i].y;
+ scratch.width = panoramiXdataPtr[i].width;
+ scratch.height = panoramiXdataPtr[i].height;
+
+ if(client->swapped) {
+ register int n;
+ swaps (&scratch.x_org, n);
+ swaps (&scratch.y_org, n);
+ swaps (&scratch.width, n);
+ swaps (&scratch.height, n);
+ }
+ WriteToClient (client, sz_XineramaScreenInfo, (char *) &scratch);
+ }
+ }
+
+ return client->noClientException;
}
+
+
static int
-#if NeedFunctionPrototypes
ProcPanoramiXDispatch (ClientPtr client)
-#else
-ProcPanoramiXDispatch (client)
- ClientPtr client;
-#endif
{ REQUEST(xReq);
switch (stuff->data)
{
@@ -775,6 +1082,184 @@ ProcPanoramiXDispatch (client)
return ProcPanoramiXGetScreenCount(client);
case X_PanoramiXGetScreenSize:
return ProcPanoramiXGetScreenSize(client);
+ case X_XineramaIsActive:
+ return ProcXineramaIsActive(client);
+ case X_XineramaQueryScreens:
+ return ProcXineramaQueryScreens(client);
}
return BadRequest;
}
+
+
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+#define SHIFT_L(v,s) (v) << (s)
+#define SHIFT_R(v,s) (v) >> (s)
+#else
+#define SHIFT_L(v,s) (v) >> (s)
+#define SHIFT_R(v,s) (v) << (s)
+#endif
+
+static void
+CopyBits(char *dst, int shiftL, char *src, int bytes)
+{
+ /* Just get it to work. Worry about speed later */
+ int shiftR = 8 - shiftL;
+
+ while(bytes--) {
+ *dst |= SHIFT_L(*src, shiftL);
+ *(dst + 1) |= SHIFT_R(*src, shiftR);
+ dst++; src++;
+ }
+}
+
+
+/* Caution. This doesn't support 2 and 4 bpp formats. We expect
+ 1 bpp and planar data to be already cleared when presented
+ to this function */
+
+void
+XineramaGetImageData(
+ DrawablePtr *pDrawables,
+ int left,
+ int top,
+ int width,
+ int height,
+ unsigned int format,
+ unsigned long planemask,
+ char *data,
+ int pitch,
+ Bool isRoot
+){
+ RegionRec SrcRegion, GrabRegion;
+ BoxRec SrcBox, *pbox;
+ int x, y, w, h, i, j, nbox, size, sizeNeeded, ScratchPitch, inOut, depth;
+ DrawablePtr pDraw = pDrawables[0];
+ char *ScratchMem = NULL;
+
+ size = 0;
+
+ /* find box in logical screen space */
+ SrcBox.x1 = left;
+ SrcBox.y1 = top;
+ if(!isRoot) {
+ SrcBox.x1 += pDraw->x + panoramiXdataPtr[0].x;
+ SrcBox.y1 += pDraw->y + panoramiXdataPtr[0].y;
+ }
+ SrcBox.x2 = SrcBox.x1 + width;
+ SrcBox.y2 = SrcBox.y1 + height;
+
+ REGION_INIT(pScreen, &SrcRegion, &SrcBox, 1);
+ REGION_INIT(pScreen, &GrabRegion, NullBox, 1);
+
+ depth = (format == XYPixmap) ? 1 : pDraw->depth;
+
+ for(i = 0; i < PanoramiXNumScreens; i++) {
+ pDraw = pDrawables[i];
+
+ inOut = RECT_IN_REGION(pScreen,&XineramaScreenRegions[i],&SrcBox);
+
+ if(inOut == rgnIN) {
+ (*pDraw->pScreen->GetImage)(pDraw,
+ SrcBox.x1 - pDraw->x - panoramiXdataPtr[i].x,
+ SrcBox.y1 - pDraw->y - panoramiXdataPtr[i].y,
+ width, height, format, planemask, data);
+ break;
+ } else if (inOut == rgnOUT)
+ continue;
+
+ REGION_INTERSECT(pScreen, &GrabRegion, &SrcRegion,
+ &XineramaScreenRegions[i]);
+
+ nbox = REGION_NUM_RECTS(&GrabRegion);
+
+ if(nbox) {
+ pbox = REGION_RECTS(&GrabRegion);
+
+ while(nbox--) {
+ w = pbox->x2 - pbox->x1;
+ h = pbox->y2 - pbox->y1;
+ ScratchPitch = PixmapBytePad(w, depth);
+ sizeNeeded = ScratchPitch * h;
+
+ if(sizeNeeded > size) {
+ char *tmpdata = ScratchMem;
+ ScratchMem = xrealloc(ScratchMem, sizeNeeded);
+ if(ScratchMem)
+ size = sizeNeeded;
+ else {
+ ScratchMem = tmpdata;
+ break;
+ }
+ }
+
+ x = pbox->x1 - pDraw->x - panoramiXdataPtr[i].x;
+ y = pbox->y1 - pDraw->y - panoramiXdataPtr[i].y;
+
+ (*pDraw->pScreen->GetImage)(pDraw, x, y, w, h,
+ format, planemask, ScratchMem);
+
+ /* copy the memory over */
+
+ if(depth == 1) {
+ int k, shift, leftover, index, index2;
+
+ x = pbox->x1 - SrcBox.x1;
+ y = pbox->y1 - SrcBox.y1;
+ shift = x & 7;
+ x >>= 3;
+ leftover = w & 7;
+ w >>= 3;
+
+ /* clean up the edge */
+ if(leftover) {
+ int mask = (1 << leftover) - 1;
+ for(j = h, k = w; j--; k += ScratchPitch)
+ ScratchMem[k] &= mask;
+ }
+
+ for(j = 0, index = (pitch * y) + x, index2 = 0; j < h;
+ j++, index += pitch, index2 += ScratchPitch)
+ {
+ if(w) {
+ if(!shift)
+ memcpy(data + index, ScratchMem + index2, w);
+ else
+ CopyBits(data + index, shift,
+ ScratchMem + index2, w);
+ }
+
+ if(leftover) {
+ data[index + w] |=
+ SHIFT_L(ScratchMem[index2 + w], shift);
+ if((shift + leftover) > 8)
+ data[index + w + 1] |=
+ SHIFT_R(ScratchMem[index2 + w],(8 - shift));
+ }
+ }
+ } else {
+ j = BitsPerPixel(depth) >> 3;
+ x = (pbox->x1 - SrcBox.x1) * j;
+ y = pbox->y1 - SrcBox.y1;
+ w *= j;
+
+ for(j = 0; j < h; j++) {
+ memcpy(data + (pitch * (y + j)) + x,
+ ScratchMem + (ScratchPitch * j), w);
+ }
+ }
+ pbox++;
+ }
+
+ REGION_SUBTRACT(pScreen, &SrcRegion, &SrcRegion, &GrabRegion);
+ if(!REGION_NOTEMPTY(pScreen, &SrcRegion))
+ break;
+ }
+
+ }
+
+ if(ScratchMem)
+ xfree(ScratchMem);
+
+ REGION_UNINIT(pScreen, &SrcRegion);
+ REGION_UNINIT(pScreen, &GrabRegion);
+}
diff --git a/Xext/panoramiXSwap.c b/Xext/panoramiXSwap.c
index c6bb5071e..e78624187 100644
--- a/Xext/panoramiXSwap.c
+++ b/Xext/panoramiXSwap.c
@@ -23,6 +23,7 @@ shall not be used in advertising or otherwise to promote the sale, use or other
dealings in this Software without prior written authorization from Digital
Equipment Corporation.
******************************************************************/
+/* $XFree86: xc/programs/Xserver/Xext/panoramiXSwap.c,v 3.8 2001/08/23 13:01:36 alanh Exp $ */
#include <stdio.h>
#include "X.h"
@@ -44,20 +45,16 @@ Equipment Corporation.
#endif
#include "panoramiX.h"
#include "panoramiXproto.h"
+#include "panoramiXsrv.h"
+#include "globals.h"
/*
-/*
* External references for data variables
*/
-extern Bool noPanoramiXExtension;
-extern Bool PanoramiXVisibilityNotifySent;
-extern WindowPtr *WindowTable;
-extern int defaultBackingStore;
extern char *ConnectionInfo;
extern int connBlockScreenStart;
-extern int (* ProcVector[256]) ();
#if NeedFunctionPrototypes
#define PROC_EXTERN(pfunc) extern int pfunc(ClientPtr)
@@ -68,50 +65,38 @@ extern int (* ProcVector[256]) ();
PROC_EXTERN(ProcPanoramiXQueryVersion);
PROC_EXTERN(ProcPanoramiXGetState);
PROC_EXTERN(ProcPanoramiXGetScreenCount);
-PROC_EXTERN(PropPanoramiXGetScreenSize);
+PROC_EXTERN(ProcPanoramiXGetScreenSize);
+
+PROC_EXTERN(ProcXineramaIsActive);
+PROC_EXTERN(ProcXineramaQueryScreens);
static int
-#if NeedFunctionPrototypes
SProcPanoramiXQueryVersion (ClientPtr client)
-#else
-SProcPanoramiXQueryVersion (client)
- register ClientPtr client;
-#endif
{
- register int n;
- REQUEST(xPanoramiXQueryVersionReq);
+ REQUEST(xPanoramiXQueryVersionReq);
+ register int n;
- swaps(&stuff->length,n);
- REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
- return ProcPanoramiXQueryVersion(client);
+ swaps(&stuff->length,n);
+ REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
+ return ProcPanoramiXQueryVersion(client);
}
static int
-#if NeedFunctionPrototypes
SProcPanoramiXGetState(ClientPtr client)
-#else
-SProcPanoramiXGetState(client)
- register ClientPtr client;
-#endif
{
REQUEST(xPanoramiXGetStateReq);
- register int n;
+ register int n;
swaps (&stuff->length, n);
REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
-
+ return ProcPanoramiXGetState(client);
}
static int
-#if NeedFunctionPrototypes
SProcPanoramiXGetScreenCount(ClientPtr client)
-#else
-SProcPanoramixGetScreenCount(client)
- register ClientPtr client;
-#endif
{
REQUEST(xPanoramiXGetScreenCountReq);
- register int n;
+ register int n;
swaps (&stuff->length, n);
REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
@@ -119,29 +104,43 @@ SProcPanoramixGetScreenCount(client)
}
static int
-#if NeedFunctionPrototypes
SProcPanoramiXGetScreenSize(ClientPtr client)
-#else
-SProcPanoramiXGetScreenSize(client)
- register ClientPtr client;
-#endif
{
REQUEST(xPanoramiXGetScreenSizeReq);
- WindowPtr pWin;
- register int n;
+ register int n;
swaps (&stuff->length, n);
REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
return ProcPanoramiXGetScreenSize(client);
}
+
+static int
+SProcXineramaIsActive(ClientPtr client)
+{
+ REQUEST(xXineramaIsActiveReq);
+ register int n;
+
+ swaps (&stuff->length, n);
+ REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
+ return ProcXineramaIsActive(client);
+}
+
+
+static int
+SProcXineramaQueryScreens(ClientPtr client)
+{
+ REQUEST(xXineramaQueryScreensReq);
+ register int n;
+
+ swaps (&stuff->length, n);
+ REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
+ return ProcXineramaQueryScreens(client);
+}
+
+
int
-#if NeedFunctionPrototypes
SProcPanoramiXDispatch (ClientPtr client)
-#else
-SProcPanoramiXDispatch (client)
- ClientPtr client;
-#endif
{ REQUEST(xReq);
switch (stuff->data)
{
@@ -153,6 +152,10 @@ SProcPanoramiXDispatch (client)
return SProcPanoramiXGetScreenCount(client);
case X_PanoramiXGetScreenSize:
return SProcPanoramiXGetScreenSize(client);
- return BadRequest;
+ case X_XineramaIsActive:
+ return SProcXineramaIsActive(client);
+ case X_XineramaQueryScreens:
+ return SProcXineramaQueryScreens(client);
}
+ return BadRequest;
}
diff --git a/Xext/panoramiXprocs.c b/Xext/panoramiXprocs.c
index cd54bdcb3..37b54f4bc 100644
--- a/Xext/panoramiXprocs.c
+++ b/Xext/panoramiXprocs.c
@@ -24,6 +24,10 @@ dealings in this Software without prior written authorization from Digital
Equipment Corporation.
******************************************************************/
+/* Massively rewritten by Mark Vojkovich <markv@valinux.com> */
+
+/* $XFree86: xc/programs/Xserver/Xext/panoramiXprocs.c,v 3.33 2002/04/10 21:38:53 mvojkovi Exp $ */
+
#include <stdio.h>
#include "X.h"
#define NEED_REPLIES
@@ -40,757 +44,485 @@ Equipment Corporation.
#include "misc.h"
#include "dixstruct.h"
#include "panoramiX.h"
+#include "panoramiXsrv.h"
+#include "resource.h"
+
+#define XINERAMA_IMAGE_BUFSIZE (256*1024)
+#define INPUTONLY_LEGAL_MASK (CWWinGravity | CWEventMask | \
+ CWDontPropagate | CWOverrideRedirect | CWCursor )
-extern Bool noPanoramiXExtension;
-extern Bool PanoramiXVisibilityNotifySent;
-extern Bool PanoramiXMapped;
-extern int PanoramiXNumScreens;
-extern int PanoramiXPixWidth;
-extern int PanoramiXPixHeight;
-extern PanoramiXWindow *PanoramiXWinRoot;
-extern PanoramiXGC *PanoramiXGCRoot;
-extern PanoramiXCmap *PanoramiXCmapRoot;
-extern PanoramiXPmap *PanoramiXPmapRoot;
-extern PanoramiXData *panoramiXdataPtr;
-extern PanoramiXCDT PanoramiXColorDepthTable[MAXSCREENS];
extern ScreenInfo *GlobalScrInfo;
-extern int (* SavedProcVector[256])();
-extern void (* ReplySwapVector[256])();
-extern WindowPtr *WindowTable;
extern char *ConnectionInfo;
extern int connBlockScreenStart;
-extern XID clientErrorValue;
-
-extern void Swap32Write();
-
-extern long defaultScreenSaverTime;
-extern long defaultScreenSaverInterval;
-extern int defaultScreenSaverBlanking;
-extern int defaultScreenSaverAllowExposures;
-static ClientPtr onlyClient;
-static Bool grabbingClient = FALSE;
-#ifdef __alpha /* THIS NEEDS TO BE LONG !!!! Change driver! */
-int *checkForInput[2];
-#else
-long *checkForInput[2];
-#endif
-extern int connBlockScreenStart;
-
-extern int (* InitialVector[3]) ();
-extern int (* ProcVector[256]) ();
-extern int (* SwappedProcVector[256]) ();
+extern int (* SavedProcVector[256]) ();
extern void (* EventSwapVector[128]) ();
-extern void (* ReplySwapVector[256]) ();
extern void Swap32Write(), SLHostsExtend(), SQColorsExtend(),
WriteSConnectionInfo();
extern void WriteSConnSetupPrefix();
-extern char *ClientAuthorized();
-extern Bool InsertFakeRequest();
-static void KillAllClients();
-static void DeleteClientFromAnySelections();
-extern void ProcessWorkQueue();
-
-
-static int nextFreeClientID; /* always MIN free client ID */
-
-static int nClients; /* number active clients */
-
-char isItTimeToYield;
/* Various of the DIX function interfaces were not designed to allow
* the client->errorValue to be set on BadValue and other errors.
* Rather than changing interfaces and breaking untold code we introduce
* a new global that dispatch can use.
*/
-XID clientErrorValue; /* XXX this is a kludge */
-
-
-#define SAME_SCREENS(a, b) (\
- (a.pScreen == b.pScreen))
+extern XID clientErrorValue; /* XXX this is a kludge */
-
-
-extern int Ones();
-
-int PanoramiXCreateWindow(register ClientPtr client)
+int PanoramiXCreateWindow(ClientPtr client)
{
- register WindowPtr pParent, pWin;
+ PanoramiXRes *parent, *newWin;
+ PanoramiXRes *backPix = NULL;
+ PanoramiXRes *bordPix = NULL;
+ PanoramiXRes *cmap = NULL;
REQUEST(xCreateWindowReq);
- int result, j = 0;
- unsigned len;
- Bool FoundIt = FALSE;
- Window winID;
- Window parID;
- PanoramiXWindow *localWin;
- PanoramiXWindow *parentWin = PanoramiXWinRoot;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXCmap *pPanoramiXCmap = NULL;
- PanoramiXPmap *pBackgndPmap = NULL;
- PanoramiXPmap *pBorderPmap = NULL;
- VisualID orig_visual;
- XID orig_wid;
- int orig_x, orig_y;
- register Mask orig_mask;
- int cmap_offset = 0;
- int pback_offset = 0;
- int pbord_offset = 0;
- int class_index, this_class_index;
- int vid_index, this_vid_index;
+ int pback_offset = 0, pbord_offset = 0, cmap_offset = 0;
+ int result = 0, len, j;
+ int orig_x, orig_y;
+ XID orig_visual, tmp;
+ Bool parentIsRoot;
REQUEST_AT_LEAST_SIZE(xCreateWindowReq);
len = client->req_len - (sizeof(xCreateWindowReq) >> 2);
- IF_RETURN((Ones((Mask)stuff->mask) != len), BadLength);
- orig_mask = stuff->mask;
- PANORAMIXFIND_ID(parentWin, stuff->parent);
- if (parentWin) {
- localWin = (PanoramiXWindow *)Xcalloc(sizeof(PanoramiXWindow));
- IF_RETURN(!localWin, BadAlloc);
- } else {
- return BadWindow;
- }
- if ((PanoramiXNumScreens - 1) && ((Mask)stuff->mask & CWBackPixmap)) {
- XID pmapID;
+ if (Ones(stuff->mask) != len)
+ return BadLength;
+
+ if (!(parent = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->parent, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ if(stuff->class == CopyFromParent)
+ stuff->class = parent->u.win.class;
+
+ if((stuff->class == InputOnly) && (stuff->mask & (~INPUTONLY_LEGAL_MASK)))
+ return BadMatch;
+ if ((Mask)stuff->mask & CWBackPixmap) {
pback_offset = Ones((Mask)stuff->mask & (CWBackPixmap - 1));
- pmapID = *((CARD32 *) &stuff[1] + pback_offset);
- if (pmapID) {
- pBackgndPmap = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pBackgndPmap, pmapID);
+ tmp = *((CARD32 *) &stuff[1] + pback_offset);
+ if ((tmp != None) && (tmp != ParentRelative)) {
+ if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
- if ((PanoramiXNumScreens - 1) && ((Mask)stuff->mask & CWBorderPixmap)) {
- XID pmapID;
-
+ if ((Mask)stuff->mask & CWBorderPixmap) {
pbord_offset = Ones((Mask)stuff->mask & (CWBorderPixmap - 1));
- pmapID = *((CARD32 *) &stuff[1] + pbord_offset);
- if (pmapID) {
- pBorderPmap = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pBorderPmap, pmapID);
+ tmp = *((CARD32 *) &stuff[1] + pbord_offset);
+ if (tmp != CopyFromParent) {
+ if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
- if ((PanoramiXNumScreens - 1) && ((Mask)stuff->mask & CWColormap)) {
- Colormap cmapID;
-
+ if ((Mask)stuff->mask & CWColormap) {
cmap_offset = Ones((Mask)stuff->mask & (CWColormap - 1));
- cmapID = *((CARD32 *) &stuff[1] + cmap_offset);
- if (cmapID) {
- pPanoramiXCmap = PanoramiXCmapRoot;
- PANORAMIXFIND_ID(pPanoramiXCmap, cmapID);
+ tmp = *((CARD32 *) &stuff[1] + cmap_offset);
+ if ((tmp != CopyFromParent) && (tmp != None)) {
+ if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_COLORMAP, SecurityReadAccess)))
+ return BadColor;
}
}
+
+ if(!(newWin = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+ return BadAlloc;
+
+ newWin->type = XRT_WINDOW;
+ newWin->u.win.visibility = VisibilityNotViewable;
+ newWin->u.win.class = stuff->class;
+ newWin->info[0].id = stuff->wid;
+ for(j = 1; j < PanoramiXNumScreens; j++)
+ newWin->info[j].id = FakeClientID(client->index);
+
+ if (stuff->class == InputOnly)
+ stuff->visual = CopyFromParent;
+ orig_visual = stuff->visual;
orig_x = stuff->x;
orig_y = stuff->y;
- orig_wid = stuff->wid;
- orig_visual = stuff->visual;
- for (j = 0; j <= PanoramiXNumScreens - 1; j++) {
- winID = j ? FakeClientID(client->index) : orig_wid;
- localWin->info[j].id = winID;
- }
- localWin->FreeMe = FALSE;
- localWin->visibility = VisibilityNotViewable;
- localWin->VisibilitySent = FALSE;
- PANORAMIXFIND_LAST(pPanoramiXWin, PanoramiXWinRoot);
- pPanoramiXWin->next = localWin;
- if ( (stuff->visual != CopyFromParent) && (stuff->depth != 0))
- {
- /* Find the correct visual for this screen */
- for (class_index = 0; class_index < PanoramiXColorDepthTable[0].numVisuals;
-class_index++)
- {
- for (vid_index = 0; vid_index < PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index].vmap[stuff->depth].numVids; vid_index++)
- {
- if ( stuff->visual == PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index].vmap[stuff->depth].vid[vid_index] )
- {
- this_class_index = class_index;
- this_vid_index = vid_index;
- FoundIt = TRUE;
- break;
- }
- }
- }
- }
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- if (parentWin == PanoramiXWinRoot) {
+ parentIsRoot = (stuff->parent == WindowTable[0]->drawable.id);
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->wid = newWin->info[j].id;
+ stuff->parent = parent->info[j].id;
+ if (parentIsRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
}
- stuff->wid = localWin->info[j].id;
- parID = (XID)(parentWin->info[j].id);
- pParent = (WindowPtr)SecurityLookupWindow(parID, client,SecurityReadAccess);
- IF_RETURN((!pParent),BadWindow);
- stuff->parent = parID;
- if ( (orig_visual != CopyFromParent) && (stuff->depth != 0) && FoundIt )
- {
- stuff->visual = PanoramiXColorDepthTable[j].panoramiXScreenMap[this_class_index].vmap[stuff->depth].vid[this_vid_index];
- }
- if (pBackgndPmap)
- *((CARD32 *) &stuff[1] + pback_offset) = pBackgndPmap->info[j].id;
- if (pBorderPmap)
- *((CARD32 *) &stuff[1] + pbord_offset) = pBorderPmap->info[j].id;
- if (pPanoramiXCmap)
- *((CARD32 *) &stuff[1] + cmap_offset) = pPanoramiXCmap->info[j].id;
- stuff->mask = orig_mask;
- result = (*SavedProcVector[X_CreateWindow])(client);
- BREAK_IF(result != Success);
- }
- if (result != Success) {
- pPanoramiXWin->next = NULL;
- if (localWin)
- Xfree(localWin);
- }
+ if (backPix)
+ *((CARD32 *) &stuff[1] + pback_offset) = backPix->info[j].id;
+ if (bordPix)
+ *((CARD32 *) &stuff[1] + pbord_offset) = bordPix->info[j].id;
+ if (cmap)
+ *((CARD32 *) &stuff[1] + cmap_offset) = cmap->info[j].id;
+ if ( orig_visual != CopyFromParent )
+ stuff->visual = PanoramiXVisualTable[(orig_visual*MAXSCREENS) + j];
+ result = (*SavedProcVector[X_CreateWindow])(client);
+ if(result != Success) break;
+ }
+
+ if (result == Success)
+ AddResource(newWin->info[0].id, XRT_WINDOW, newWin);
+ else
+ xfree(newWin);
+
return (result);
}
-
-int PanoramiXChangeWindowAttributes(register ClientPtr client)
+int PanoramiXChangeWindowAttributes(ClientPtr client)
{
- register WindowPtr pWin;
+ PanoramiXRes *win;
+ PanoramiXRes *backPix = NULL;
+ PanoramiXRes *bordPix = NULL;
+ PanoramiXRes *cmap = NULL;
REQUEST(xChangeWindowAttributesReq);
- register int result;
- int len;
- int j;
- Window winID;
- Mask orig_valueMask;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXWindow *pPanoramiXWinback = NULL;
- PanoramiXCmap *pPanoramiXCmap = NULL;
- PanoramiXPmap *pBackgndPmap = NULL;
- PanoramiXPmap *pBorderPmap = NULL;
- int cmap_offset = 0;
- int pback_offset = 0;
- int pbord_offset = 0;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
+ int pback_offset = 0, pbord_offset = 0, cmap_offset = 0;
+ int result = 0, len, j;
+ XID tmp;
REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
+
len = client->req_len - (sizeof(xChangeWindowAttributesReq) >> 2);
- IF_RETURN((len != Ones((Mask) stuff->valueMask)), BadLength);
- orig_valueMask = stuff->valueMask;
- winID = stuff->window;
- for (; pPanoramiXWin && (pPanoramiXWin->info[0].id != stuff->window);
- pPanoramiXWin = pPanoramiXWin->next)
- pPanoramiXWinback = pPanoramiXWin;
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, winID);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- if ((PanoramiXNumScreens - 1) && ((Mask)stuff->valueMask & CWBackPixmap)) {
- XID pmapID;
+ if (Ones(stuff->valueMask) != len)
+ return BadLength;
+ if (!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ if((win->u.win.class == InputOnly) &&
+ (stuff->valueMask & (~INPUTONLY_LEGAL_MASK)))
+ return BadMatch;
+
+ if ((Mask)stuff->valueMask & CWBackPixmap) {
pback_offset = Ones((Mask)stuff->valueMask & (CWBackPixmap - 1));
- pmapID = *((CARD32 *) &stuff[1] + pback_offset);
- if (pmapID) {
- pBackgndPmap = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pBackgndPmap, pmapID);
+ tmp = *((CARD32 *) &stuff[1] + pback_offset);
+ if ((tmp != None) && (tmp != ParentRelative)) {
+ if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
- if ((PanoramiXNumScreens - 1) && ((Mask)stuff->valueMask & CWBorderPixmap)) {
- XID pmapID;
-
+ if ((Mask)stuff->valueMask & CWBorderPixmap) {
pbord_offset = Ones((Mask)stuff->valueMask & (CWBorderPixmap - 1));
- pmapID = *((CARD32 *) &stuff[1] + pbord_offset);
- if (pmapID) {
- pBorderPmap = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pBorderPmap, pmapID);
+ tmp = *((CARD32 *) &stuff[1] + pbord_offset);
+ if (tmp != CopyFromParent) {
+ if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
- if ((PanoramiXNumScreens - 1) && ((Mask)stuff->valueMask & CWColormap )) {
- Colormap cmapID;
-
+ if ((Mask)stuff->valueMask & CWColormap) {
cmap_offset = Ones((Mask)stuff->valueMask & (CWColormap - 1));
- cmapID = *((CARD32 *) &stuff[1] + cmap_offset);
- if (cmapID) {
- pPanoramiXCmap = PanoramiXCmapRoot;
- PANORAMIXFIND_ID(pPanoramiXCmap, cmapID);
+ tmp = *((CARD32 *) &stuff[1] + cmap_offset);
+ if ((tmp != CopyFromParent) && (tmp != None)) {
+ if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_COLORMAP, SecurityReadAccess)))
+ return BadColor;
}
}
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->window = pPanoramiXWin->info[j].id;
- stuff->valueMask = orig_valueMask;
- if (pBackgndPmap)
- *((CARD32 *) &stuff[1] + pback_offset) = pBackgndPmap->info[j].id;
- if (pBorderPmap)
- *((CARD32 *) &stuff[1] + pbord_offset) = pBorderPmap->info[j].id;
- if (pPanoramiXCmap)
- *((CARD32 *) &stuff[1] + cmap_offset) = pPanoramiXCmap->info[j].id;
- result = (*SavedProcVector[X_ChangeWindowAttributes])(client);
- BREAK_IF(result != Success);
- }
- if ((result == Success) && pPanoramiXWinback &&
- pPanoramiXWin && pPanoramiXWin->FreeMe) {
- pPanoramiXWinback->next = pPanoramiXWin->next;
- Xfree(pPanoramiXWin);
- }
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->window = win->info[j].id;
+ if (backPix)
+ *((CARD32 *) &stuff[1] + pback_offset) = backPix->info[j].id;
+ if (bordPix)
+ *((CARD32 *) &stuff[1] + pbord_offset) = bordPix->info[j].id;
+ if (cmap)
+ *((CARD32 *) &stuff[1] + cmap_offset) = cmap->info[j].id;
+ result = (*SavedProcVector[X_ChangeWindowAttributes])(client);
+ }
+
return (result);
}
int PanoramiXDestroyWindow(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j;
REQUEST(xResourceReq);
- int j, result;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXWindow *pPanoramiXWinback = NULL;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xResourceReq);
- for (; pPanoramiXWin && (pPanoramiXWin->info[0].id != stuff->id);
- pPanoramiXWin = pPanoramiXWin->next)
- pPanoramiXWinback = pPanoramiXWin;
- IF_RETURN(!pPanoramiXWin,BadWindow);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->id = pPanoramiXWin->info[j].id;
- result = (* SavedProcVector[X_DestroyWindow])(client);
- BREAK_IF(result != Success);
- }
- if ((result == Success) && pPanoramiXWinback &&
- pPanoramiXWin && pPanoramiXWin->FreeMe) {
- pPanoramiXWinback->next = pPanoramiXWin->next;
- Xfree(pPanoramiXWin);
- }
- PANORAMIX_FREE(client);
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_WINDOW, SecurityDestroyAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->id = win->info[j].id;
+ result = (*SavedProcVector[X_DestroyWindow])(client);
+ if(result != Success) break;
+ }
+
+ /* Since ProcDestroyWindow is using FreeResource, it will free
+ our resource for us on the last pass through the loop above */
+
return (result);
}
int PanoramiXDestroySubwindows(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j;
REQUEST(xResourceReq);
- int j,result;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXWindow *pPanoramiXWinback = NULL;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xResourceReq);
- for (; pPanoramiXWin && (pPanoramiXWin->info[0].id != stuff->id);
- pPanoramiXWin = pPanoramiXWin->next)
- pPanoramiXWinback = pPanoramiXWin;
- IF_RETURN(!pPanoramiXWin, BadWindow);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->id = pPanoramiXWin->info[j].id;
- result = (* SavedProcVector[X_DestroySubwindows])(client);
- }
- if ((result == Success) && pPanoramiXWinback &&
- pPanoramiXWin && pPanoramiXWin->FreeMe) {
- pPanoramiXWinback->next = pPanoramiXWin->next;
- Xfree(pPanoramiXWin);
- }
- PANORAMIX_FREE(client);
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_WINDOW, SecurityDestroyAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->id = win->info[j].id;
+ result = (*SavedProcVector[X_DestroySubwindows])(client);
+ if(result != Success) break;
+ }
+
+ /* DestroySubwindows is using FreeResource which will free
+ our resources for us on the last pass through the loop above */
+
return (result);
}
int PanoramiXChangeSaveSet(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j;
REQUEST(xChangeSaveSetReq);
- int j, result;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
REQUEST_SIZE_MATCH(xChangeSaveSetReq);
- if (!stuff->window)
- result = (* SavedProcVector[X_ChangeSaveSet])(client);
- else {
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->window = pPanoramiXWin->info[j].id;
- result = (* SavedProcVector[X_ChangeSaveSet])(client);
- }
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->window, XRT_WINDOW, SecurityReadAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->window = win->info[j].id;
+ result = (*SavedProcVector[X_ChangeSaveSet])(client);
+ if(result != Success) break;
}
+
return (result);
}
-int PanoramiXReparentWindow(register ClientPtr client)
+int PanoramiXReparentWindow(ClientPtr client)
{
- register WindowPtr pWin, pParent;
+ PanoramiXRes *win, *parent;
+ int result = 0, j;
+ int x, y;
+ Bool parentIsRoot;
REQUEST(xReparentWindowReq);
- register int result;
- int j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXWindow *pPanoramiXPar = PanoramiXWinRoot;
REQUEST_SIZE_MATCH(xReparentWindowReq);
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- PANORAMIXFIND_ID(pPanoramiXPar, stuff->parent);
- IF_RETURN(!pPanoramiXPar, BadWindow);
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXPar), j) {
- stuff->window = pPanoramiXWin->info[j].id;
- stuff->parent = pPanoramiXPar->info[j].id;
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ if(!(parent = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->parent, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ x = stuff->x;
+ y = stuff->y;
+ parentIsRoot = (stuff->parent == WindowTable[0]->drawable.id);
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->window = win->info[j].id;
+ stuff->parent = parent->info[j].id;
+ if(parentIsRoot) {
+ stuff->x = x - panoramiXdataPtr[j].x;
+ stuff->y = y - panoramiXdataPtr[j].y;
+ }
result = (*SavedProcVector[X_ReparentWindow])(client);
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
+
return (result);
}
-int PanoramiXMapWindow(register ClientPtr client)
+int PanoramiXMapWindow(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j;
REQUEST(xResourceReq);
- int j,result;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- register WindowPtr pWin, pChild;
- Window winID;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xResourceReq);
- /* initialize visibility */
- pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-SecurityReadAccess);
- IF_RETURN(!pWin, BadWindow);
- for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) {
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
- if (pPanoramiXWin)
- pPanoramiXWin->VisibilitySent = FALSE;
- }
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->id);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- PanoramiXMapped = TRUE;
- PanoramiXVisibilityNotifySent = FALSE;
- pPanoramiXWin->VisibilitySent = FALSE;
- for (j = 0; j <= (PanoramiXNumScreens - 1); j++)
- {
- winID = pPanoramiXWin->info[j].id;
- pWin = (WindowPtr) SecurityLookupWindow(winID,
-client,SecurityReadAccess);
- IF_RETURN((!pWin), BadWindow);
- stuff->id = winID;
- result = (*SavedProcVector[X_MapWindow])(client);
- }
- /* clean up */
- PanoramiXMapped = FALSE;
- PanoramiXVisibilityNotifySent = FALSE;
- pPanoramiXWin->VisibilitySent = FALSE;
- pWin = (WindowPtr) SecurityLookupWindow(stuff->id,
-client,SecurityReadAccess);
- for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
- if (pPanoramiXWin)
- pPanoramiXWin->VisibilitySent = FALSE;
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS_FORWARD(j) {
+ stuff->id = win->info[j].id;
+ result = (*SavedProcVector[X_MapWindow])(client);
+ if(result != Success) break;
}
+
return (result);
}
-int PanoramiXMapSubwindows(register ClientPtr client)
+int PanoramiXMapSubwindows(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j;
REQUEST(xResourceReq);
- int j,result;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- register WindowPtr pWin, pChild;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xResourceReq);
- /* initialize visibility values */
- pWin = (WindowPtr) SecurityLookupWindow(stuff->id,
-client,SecurityReadAccess);
- IF_RETURN(!pWin, BadWindow);
- for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
- if (pPanoramiXWin)
- pPanoramiXWin->VisibilitySent = FALSE;
- }
-
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->id);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- PanoramiXMapped = TRUE;
- PanoramiXVisibilityNotifySent = FALSE;
- pPanoramiXWin->VisibilitySent = FALSE;
- for (j = 0; j <= (PanoramiXNumScreens - 1); j++)
- {
- stuff->id = pPanoramiXWin->info[j].id;
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS_FORWARD(j) {
+ stuff->id = win->info[j].id;
result = (*SavedProcVector[X_MapSubwindows])(client);
+ if(result != Success) break;
}
- /* clean up */
- PanoramiXMapped = FALSE;
- PanoramiXVisibilityNotifySent = FALSE;
- pPanoramiXWin->VisibilitySent = FALSE;
- pWin = (WindowPtr) SecurityLookupWindow(stuff->id,
-client,SecurityReadAccess);
- for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) {
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
- if (pPanoramiXWin)
- pPanoramiXWin->VisibilitySent = FALSE;
- }
- PANORAMIX_FREE(client);
+
return (result);
}
-int PanoramiXUnmapWindow(register ClientPtr client)
+int PanoramiXUnmapWindow(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j;
REQUEST(xResourceReq);
- int j, result;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- register WindowPtr pWin, pChild;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xResourceReq);
- /* initialize visibility values */
- pWin = (WindowPtr) SecurityLookupWindow(stuff->id,
-client,SecurityReadAccess);
- IF_RETURN(!pWin, BadWindow);
- for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, pWin->drawable.id);
- if (pPanoramiXWin)
- pPanoramiXWin->VisibilitySent = FALSE;
- }
-
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->id);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- PanoramiXMapped = TRUE;
- PanoramiXVisibilityNotifySent = FALSE;
- pPanoramiXWin->VisibilitySent = FALSE;
- for (j = 0; j <= (PanoramiXNumScreens - 1); j++)
- {
- stuff->id = pPanoramiXWin->info[j].id;
- result = (*SavedProcVector[X_UnmapWindow])(client);
- }
-
- /* clean up */
- PanoramiXMapped = FALSE;
- PanoramiXVisibilityNotifySent = FALSE;
- pPanoramiXWin->VisibilitySent = FALSE;
- pWin = (WindowPtr) SecurityLookupWindow(stuff->id,
-client,SecurityReadAccess);
- for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib) {
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, pChild->drawable.id);
- if (pPanoramiXWin)
- pPanoramiXWin->VisibilitySent = FALSE;
- }
- PANORAMIX_FREE(client);
- return (client->noClientException);
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS_FORWARD(j) {
+ stuff->id = win->info[j].id;
+ result = (*SavedProcVector[X_UnmapWindow])(client);
+ if(result != Success) break;
+ }
+
+ return (result);
}
-int PanoramiXUnmapSubwindows(register ClientPtr client)
+int PanoramiXUnmapSubwindows(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j;
REQUEST(xResourceReq);
- int j, result;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- register WindowPtr pWin, pChild;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xResourceReq);
- /* initialize visibility values */
- pWin = (WindowPtr) SecurityLookupWindow(stuff->id,
-client,SecurityReadAccess);
- IF_RETURN(!pWin, BadWindow);
- for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, pWin->drawable.id);
- if (pPanoramiXWin)
- pPanoramiXWin->VisibilitySent = FALSE;
- }
-
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->id);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- PanoramiXMapped = TRUE;
- PanoramiXVisibilityNotifySent = FALSE;
- pPanoramiXWin->VisibilitySent = FALSE;
- for (j = 0; j <= (PanoramiXNumScreens - 1); j++)
- {
- stuff->id = pPanoramiXWin->info[j].id;
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS_FORWARD(j) {
+ stuff->id = win->info[j].id;
result = (*SavedProcVector[X_UnmapSubwindows])(client);
+ if(result != Success) break;
}
- /* clean up */
- PanoramiXMapped = FALSE;
- PanoramiXVisibilityNotifySent = FALSE;
- pPanoramiXWin->VisibilitySent = FALSE;
- pWin = (WindowPtr) SecurityLookupWindow(stuff->id,
-client,SecurityReadAccess);
- for (pChild = pWin->firstChild; pChild; pChild = pChild->nextSib){
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, pWin->drawable.id);
- if (pPanoramiXWin)
- pPanoramiXWin->VisibilitySent = FALSE;
- }
- PANORAMIX_FREE(client);
- return (client->noClientException);
+ return (result);
}
-int PanoramiXConfigureWindow(register ClientPtr client)
+int PanoramiXConfigureWindow(ClientPtr client)
{
- register WindowPtr pWin;
+ PanoramiXRes *win;
+ PanoramiXRes *sib = NULL;
+ WindowPtr pWin;
+ int result = 0, j, len, sib_offset = 0, x = 0, y = 0;
+ int x_offset = -1;
+ int y_offset = -1;
REQUEST(xConfigureWindowReq);
- register int result;
- unsigned len, i, things;
- XID changes[32];
- register Mask orig_mask;
- int j, sib_position;
- Window winID;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXWindow *pPanoramiXSib = NULL;
- int x_off = 0, y_off = 0;
- XID *pStuff;
- XID *origStuff, *modStuff;
- Mask local_mask;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
+
len = client->req_len - (sizeof(xConfigureWindowReq) >> 2);
- things = Ones((Mask)stuff->mask);
- IF_RETURN((things != len), BadLength);
- orig_mask = stuff->mask;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
- if (!pPanoramiXWin) {
- client->errorValue = stuff->window;
- return (BadWindow);
- }
- if (things > 0) {
- pStuff = (XID *) ALLOCATE_LOCAL(things * sizeof(XID));
- memcpy((char *) pStuff, (char *) &stuff[1], things * sizeof(XID));
- local_mask = (CWSibling | CWX | CWY) & ((Mask) stuff->mask);
- if (local_mask & CWSibling) {
- sib_position = Ones((Mask) stuff->mask & (CWSibling - 1));
- pPanoramiXSib = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXSib, *(pStuff + sib_position));
- }
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- winID = pPanoramiXWin->info[j].id;
- pWin = (WindowPtr)SecurityLookupWindow(winID, client,SecurityReadAccess);
- if (!pWin) {
- client->errorValue = pPanoramiXWin->info[0].id;
- return (BadWindow);
- }
- stuff->window = winID;
- if (pWin->parent
- && (pWin->parent->drawable.id == PanoramiXWinRoot->info[j].id)) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
- modStuff = (XID *) &stuff[1];
- origStuff = pStuff;
- i = things;
- if (local_mask & CWX) {
- *modStuff++ = *origStuff++ - x_off;
- i--;
- }
- if (local_mask & CWY) {
- *modStuff++ = *origStuff++ - y_off;
- i--;
- }
- for ( ; i; i--)
- *modStuff++ = *origStuff++;
- if (pPanoramiXSib)
- *((XID *) &stuff[1] + sib_position) = pPanoramiXSib->info[j].id;
- stuff->mask = orig_mask;
- result = (*SavedProcVector[X_ConfigureWindow])(client);
- }
- DEALLOCATE_LOCAL(pStuff);
- PANORAMIX_FREE(client);
+ if (Ones(stuff->mask) != len)
+ return BadLength;
+
+ /* because we need the parent */
+ if (!(pWin = (WindowPtr)SecurityLookupIDByType(
+ client, stuff->window, RT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ if (!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ if ((Mask)stuff->mask & CWSibling) {
+ XID tmp;
+ sib_offset = Ones((Mask)stuff->mask & (CWSibling - 1));
+ if ((tmp = *((CARD32 *) &stuff[1] + sib_offset))) {
+ if(!(sib = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_WINDOW, SecurityReadAccess)))
+ return BadWindow;
+ }
+ }
+
+ if(pWin->parent && (pWin->parent == WindowTable[0])) {
+ if ((Mask)stuff->mask & CWX) {
+ x_offset = 0;
+ x = *((CARD32 *)&stuff[1]);
+ }
+ if ((Mask)stuff->mask & CWY) {
+ y_offset = (x_offset == -1) ? 0 : 1;
+ y = *((CARD32 *) &stuff[1] + y_offset);
+ }
+ }
+
+ /* have to go forward or you get expose events before
+ ConfigureNotify events */
+ FOR_NSCREENS_FORWARD(j) {
+ stuff->window = win->info[j].id;
+ if(sib)
+ *((CARD32 *) &stuff[1] + sib_offset) = sib->info[j].id;
+ if(x_offset >= 0)
+ *((CARD32 *) &stuff[1] + x_offset) = x - panoramiXdataPtr[j].x;
+ if(y_offset >= 0)
+ *((CARD32 *) &stuff[1] + y_offset) = y - panoramiXdataPtr[j].y;
+ result = (*SavedProcVector[X_ConfigureWindow])(client);
+ if(result != Success) break;
+ }
+
return (result);
- } else
- return (client->noClientException);
}
-int PanoramiXCirculateWindow(register ClientPtr client)
+int PanoramiXCirculateWindow(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j;
REQUEST(xCirculateWindowReq);
- int j,result;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xCirculateWindowReq);
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->window = pPanoramiXWin->info[j].id;
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS_FORWARD(j) {
+ stuff->window = win->info[j].id;
result = (*SavedProcVector[X_CirculateWindow])(client);
+ if(result != Success) break;
}
+
return (result);
}
-int PanoramiXGetGeometry(register ClientPtr client)
+int PanoramiXGetGeometry(ClientPtr client)
{
xGetGeometryReply rep;
- register DrawablePtr pDraw;
+ DrawablePtr pDraw;
REQUEST(xResourceReq);
REQUEST_SIZE_MATCH(xResourceReq);
@@ -798,1883 +530,1489 @@ int PanoramiXGetGeometry(register ClientPtr client)
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
- rep.root = WindowTable[pDraw->pScreen->myNum]->drawable.id;
+ rep.root = WindowTable[0]->drawable.id;
rep.depth = pDraw->depth;
+ rep.width = pDraw->width;
+ rep.height = pDraw->height;
+ rep.x = rep.y = rep.borderWidth = 0;
- if (stuff->id == PanoramiXWinRoot->info[0].id) {
- xConnSetup *setup = (xConnSetup *) ConnectionInfo;
+ if (stuff->id == rep.root) {
xWindowRoot *root = (xWindowRoot *)
(ConnectionInfo + connBlockScreenStart);
rep.width = root->pixWidth;
rep.height = root->pixHeight;
- } else {
- rep.width = pDraw->width;
- rep.height = pDraw->height;
- }
-
- /* XXX - Because the pixmap-implementation of the multibuffer extension
- * may have the buffer-id's drawable resource value be a pointer
- * to the buffer's window instead of the buffer itself
- * (this happens if the buffer is the displayed buffer),
- * we also have to check that the id matches before we can
- * truly say that it is a DRAWABLE_WINDOW.
- */
-
- if ((pDraw->type == UNDRAWABLE_WINDOW) ||
- ((pDraw->type == DRAWABLE_WINDOW) && (stuff->id == pDraw->id))) {
- register WindowPtr pWin = (WindowPtr)pDraw;
+ } else
+ if ((pDraw->type == UNDRAWABLE_WINDOW) || (pDraw->type == DRAWABLE_WINDOW))
+ {
+ WindowPtr pWin = (WindowPtr)pDraw;
rep.x = pWin->origin.x - wBorderWidth (pWin);
rep.y = pWin->origin.y - wBorderWidth (pWin);
+ if(pWin->parent == WindowTable[0]) {
+ rep.x += panoramiXdataPtr[0].x;
+ rep.y += panoramiXdataPtr[0].y;
+ }
rep.borderWidth = pWin->borderWidth;
- } else { /* DRAWABLE_PIXMAP or DRAWABLE_BUFFER */
- rep.x = rep.y = rep.borderWidth = 0;
}
+
WriteReplyToClient(client, sizeof(xGetGeometryReply), &rep);
return (client->noClientException);
}
+int PanoramiXTranslateCoords(ClientPtr client)
+{
+ INT16 x, y;
+ REQUEST(xTranslateCoordsReq);
-int PanoramiXChangeProperty(ClientPtr client)
-{
- int result, j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- REQUEST(xChangePropertyReq);
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
-
- REQUEST_AT_LEAST_SIZE(xChangePropertyReq);
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->window = pPanoramiXWin->info[j].id;
- result = (* SavedProcVector[X_ChangeProperty])(client);
- if (result != Success) {
- stuff->window = pPanoramiXWin->info[0].id;
- break;
- }
- }
- return (result);
-}
-
-
-int PanoramiXDeleteProperty(ClientPtr client)
-{
- int result, j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- REQUEST(xDeletePropertyReq);
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
-
- REQUEST_SIZE_MATCH(xDeletePropertyReq);
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->window = pPanoramiXWin->info[j].id;
- result = (* SavedProcVector[X_DeleteProperty])(client);
- BREAK_IF(result != Success);
- }
- PANORAMIX_FREE(client);
- return (result);
-}
+ register WindowPtr pWin, pDst;
+ xTranslateCoordsReply rep;
+ REQUEST_SIZE_MATCH(xTranslateCoordsReq);
+ pWin = (WindowPtr)SecurityLookupWindow(stuff->srcWid, client,
+ SecurityReadAccess);
+ if (!pWin)
+ return(BadWindow);
+ pDst = (WindowPtr)SecurityLookupWindow(stuff->dstWid, client,
+ SecurityReadAccess);
+ if (!pDst)
+ return(BadWindow);
+ rep.type = X_Reply;
+ rep.length = 0;
+ rep.sequenceNumber = client->sequence;
+ rep.sameScreen = xTrue;
+ rep.child = None;
-int PanoramiXSendEvent(ClientPtr client)
-{
- int result, j;
- BYTE orig_type;
- Mask orig_eventMask;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- REQUEST(xSendEventReq);
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
-
- REQUEST_SIZE_MATCH(xSendEventReq);
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->destination);
- orig_type = stuff->event.u.u.type;
- orig_eventMask = stuff->eventMask;
- if (!pPanoramiXWin) {
- noPanoramiXExtension = TRUE;
- result = (* SavedProcVector[X_SendEvent])(client);
- noPanoramiXExtension = FALSE;
+ if(pWin == WindowTable[0]) {
+ x = stuff->srcX - panoramiXdataPtr[0].x;
+ y = stuff->srcY - panoramiXdataPtr[0].y;
+ } else {
+ x = pWin->drawable.x + stuff->srcX;
+ y = pWin->drawable.y + stuff->srcY;
}
- else {
- noPanoramiXExtension = FALSE;
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->destination = pPanoramiXWin->info[j].id;
- stuff->eventMask = orig_eventMask;
- stuff->event.u.u.type = orig_type;
- if (!j)
- noPanoramiXExtension = TRUE;
- result = (* SavedProcVector[X_SendEvent])(client);
- noPanoramiXExtension = FALSE;
- }
+ pWin = pDst->firstChild;
+ while (pWin) {
+#ifdef SHAPE
+ BoxRec box;
+#endif
+ if ((pWin->mapped) &&
+ (x >= pWin->drawable.x - wBorderWidth (pWin)) &&
+ (x < pWin->drawable.x + (int)pWin->drawable.width +
+ wBorderWidth (pWin)) &&
+ (y >= pWin->drawable.y - wBorderWidth (pWin)) &&
+ (y < pWin->drawable.y + (int)pWin->drawable.height +
+ wBorderWidth (pWin))
+#ifdef SHAPE
+ /* When a window is shaped, a further check
+ * is made to see if the point is inside
+ * borderSize
+ */
+ && (!wBoundingShape(pWin) ||
+ POINT_IN_REGION(pWin->drawable.pScreen,
+ wBoundingShape(pWin),
+ x - pWin->drawable.x,
+ y - pWin->drawable.y, &box))
+#endif
+ )
+ {
+ rep.child = pWin->drawable.id;
+ pWin = (WindowPtr) NULL;
+ }
+ else
+ pWin = pWin->nextSib;
+ }
+ rep.dstX = x - pDst->drawable.x;
+ rep.dstY = y - pDst->drawable.y;
+ if(pDst == WindowTable[0]) {
+ rep.dstX += panoramiXdataPtr[0].x;
+ rep.dstY += panoramiXdataPtr[0].y;
}
- return (result);
-}
+ WriteReplyToClient(client, sizeof(xTranslateCoordsReply), &rep);
+ return(client->noClientException);
+}
-int PanoramiXCreatePixmap(register ClientPtr client)
+int PanoramiXCreatePixmap(ClientPtr client)
{
- PixmapPtr pMap;
- register DrawablePtr pDraw;
+ PanoramiXRes *refDraw, *newPix;
+ int result = 0, j;
REQUEST(xCreatePixmapReq);
- DepthPtr pDepth;
- int result, j;
- Pixmap pmapID;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXPmap *pPanoramiXPmap;
- PanoramiXPmap *localPmap;
- XID orig_pid;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xCreatePixmapReq);
client->errorValue = stuff->pid;
- localPmap =(PanoramiXPmap *) Xcalloc(sizeof(PanoramiXPmap));
- IF_RETURN(!localPmap, BadAlloc);
-
- pDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!pDraw, BadDrawable);
-
- pPanoramiXWin = (pDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadWindow);
-
- orig_pid = stuff->pid;
- FOR_NSCREENS_OR_ONCE(pPanoramiXPmap, j) {
- pmapID = j ? FakeClientID(client->index) : orig_pid;
- localPmap->info[j].id = pmapID;
- }
- localPmap->FreeMe = FALSE;
- PANORAMIXFIND_LAST(pPanoramiXPmap, PanoramiXPmapRoot);
- pPanoramiXPmap->next = localPmap;
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->pid = localPmap->info[j].id;
- stuff->drawable = pPanoramiXWin->info[j].id;
- result = (* SavedProcVector[X_CreatePixmap])(client);
- BREAK_IF(result != Success);
- }
- if (result != Success) {
- pPanoramiXPmap->next = NULL;
- if (localPmap)
- Xfree(localPmap);
+ if(!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityReadAccess)))
+ return BadDrawable;
+
+ if(!(newPix = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+ return BadAlloc;
+
+ newPix->type = XRT_PIXMAP;
+ newPix->u.pix.shared = FALSE;
+ newPix->info[0].id = stuff->pid;
+ for(j = 1; j < PanoramiXNumScreens; j++)
+ newPix->info[j].id = FakeClientID(client->index);
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->pid = newPix->info[j].id;
+ stuff->drawable = refDraw->info[j].id;
+ result = (*SavedProcVector[X_CreatePixmap])(client);
+ if(result != Success) break;
}
+
+ if (result == Success)
+ AddResource(newPix->info[0].id, XRT_PIXMAP, newPix);
+ else
+ xfree(newPix);
+
return (result);
}
int PanoramiXFreePixmap(ClientPtr client)
{
- PixmapPtr pMap;
- int result, j;
- PanoramiXPmap *pPanoramiXPmap = PanoramiXPmapRoot;
- PanoramiXPmap *pPanoramiXPmapback = NULL;
+ PanoramiXRes *pix;
+ int result = 0, j;
REQUEST(xResourceReq);
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
-
REQUEST_SIZE_MATCH(xResourceReq);
- for (; pPanoramiXPmap && (pPanoramiXPmap->info[0].id != stuff->id);
- pPanoramiXPmap = pPanoramiXPmap->next)
- pPanoramiXPmapback = pPanoramiXPmap;
- if (!pPanoramiXPmap)
- result = (* SavedProcVector[X_FreePixmap])(client);
- else {
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->id = pPanoramiXPmap->info[j].id;
- result = (* SavedProcVector[X_FreePixmap])(client);
- }
- if ((result == Success) && pPanoramiXPmapback &&
- pPanoramiXPmap && pPanoramiXPmap->FreeMe ) {
- pPanoramiXPmapback->next = pPanoramiXPmap->next;
- Xfree(pPanoramiXPmap);
- }
+
+ client->errorValue = stuff->id;
+
+ if(!(pix = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_PIXMAP, SecurityDestroyAccess)))
+ return BadPixmap;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->id = pix->info[j].id;
+ result = (*SavedProcVector[X_FreePixmap])(client);
+ if(result != Success) break;
}
+
+ /* Since ProcFreePixmap is using FreeResource, it will free
+ our resource for us on the last pass through the loop above */
+
return (result);
}
-int PanoramiXCreateGC(register ClientPtr client)
+int PanoramiXCreateGC(ClientPtr client)
{
- int result, j;
- GC *pGC;
- DrawablePtr pDraw;
- unsigned len, i;
+ PanoramiXRes *refDraw;
+ PanoramiXRes *newGC;
+ PanoramiXRes *stip = NULL;
+ PanoramiXRes *tile = NULL;
+ PanoramiXRes *clip = NULL;
REQUEST(xCreateGCReq);
- GContext GCID;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *localGC;
- PanoramiXGC *pPanoramiXGC;
- PanoramiXPmap *pPanoramiXTile = NULL, *pPanoramiXStip = NULL;
- PanoramiXPmap *pPanoramiXClip = NULL;
- int tile_offset, stip_offset, clip_offset;
- XID orig_GC;
+ int tile_offset = 0, stip_offset = 0, clip_offset = 0;
+ int result = 0, len, j;
+ XID tmp;
REQUEST_AT_LEAST_SIZE(xCreateGCReq);
+
client->errorValue = stuff->gc;
- pDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!pDraw, BadDrawable);
- pPanoramiXWin = (pDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
-
- len = client->req_len - (sizeof(xCreateGCReq) >> 2);
- IF_RETURN((len != Ones((Mask)stuff->mask)), BadLength);
- localGC = (PanoramiXGC *) Xcalloc(sizeof(PanoramiXGC));
- IF_RETURN(!localGC, BadAlloc);
- orig_GC = stuff->gc;
- if ((Mask)stuff->mask & GCTile) {
- XID tileID;
+ len = client->req_len - (sizeof(xCreateGCReq) >> 2);
+ if (Ones(stuff->mask) != len)
+ return BadLength;
+
+ if (!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityReadAccess)))
+ return BadDrawable;
+ if ((Mask)stuff->mask & GCTile) {
tile_offset = Ones((Mask)stuff->mask & (GCTile - 1));
- tileID = *((CARD32 *) &stuff[1] + tile_offset);
- if (tileID) {
- pPanoramiXTile = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXTile, tileID);
+ if ((tmp = *((CARD32 *) &stuff[1] + tile_offset))) {
+ if(!(tile = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
if ((Mask)stuff->mask & GCStipple) {
- XID stipID;
-
stip_offset = Ones((Mask)stuff->mask & (GCStipple - 1));
- stipID = *((CARD32 *) &stuff[1] + stip_offset);
- if (stipID) {
- pPanoramiXStip = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXStip, stipID);
+ if ((tmp = *((CARD32 *) &stuff[1] + stip_offset))) {
+ if(!(stip = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
if ((Mask)stuff->mask & GCClipMask) {
- XID clipID;
-
clip_offset = Ones((Mask)stuff->mask & (GCClipMask - 1));
- clipID = *((CARD32 *) &stuff[1] + clip_offset);
- if (clipID) {
- pPanoramiXClip = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXClip, clipID);
+ if ((tmp = *((CARD32 *) &stuff[1] + clip_offset))) {
+ if(!(clip = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
- FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
- GCID = j ? FakeClientID(client->index) : orig_GC;
- localGC->info[j].id = GCID;
- }
- localGC->FreeMe = FALSE;
- PANORAMIXFIND_LAST(pPanoramiXGC, PanoramiXGCRoot);
- pPanoramiXGC->next = localGC;
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->gc = localGC->info[j].id;
- stuff->drawable = pPanoramiXWin->info[j].id;
- if (pPanoramiXTile)
- *((CARD32 *) &stuff[1] + tile_offset) = pPanoramiXTile->info[j].id;
- if (pPanoramiXStip)
- *((CARD32 *) &stuff[1] + stip_offset) = pPanoramiXStip->info[j].id;
- if (pPanoramiXClip)
- *((CARD32 *) &stuff[1] + clip_offset) = pPanoramiXClip->info[j].id;
- result = (* SavedProcVector[X_CreateGC])(client);
- BREAK_IF(result != Success);
- }
- if (result != Success) {
- pPanoramiXGC->next = NULL;
- Xfree(localGC);
+
+ if(!(newGC = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+ return BadAlloc;
+
+ newGC->type = XRT_GC;
+ newGC->info[0].id = stuff->gc;
+ for(j = 1; j < PanoramiXNumScreens; j++)
+ newGC->info[j].id = FakeClientID(client->index);
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->gc = newGC->info[j].id;
+ stuff->drawable = refDraw->info[j].id;
+ if (tile)
+ *((CARD32 *) &stuff[1] + tile_offset) = tile->info[j].id;
+ if (stip)
+ *((CARD32 *) &stuff[1] + stip_offset) = stip->info[j].id;
+ if (clip)
+ *((CARD32 *) &stuff[1] + clip_offset) = clip->info[j].id;
+ result = (*SavedProcVector[X_CreateGC])(client);
+ if(result != Success) break;
}
+
+ if (result == Success)
+ AddResource(newGC->info[0].id, XRT_GC, newGC);
+ else
+ xfree(newGC);
+
return (result);
}
-
int PanoramiXChangeGC(ClientPtr client)
{
- GC *pGC;
+ PanoramiXRes *gc;
+ PanoramiXRes *stip = NULL;
+ PanoramiXRes *tile = NULL;
+ PanoramiXRes *clip = NULL;
REQUEST(xChangeGCReq);
- int result, j;
- unsigned len;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- PanoramiXPmap *pPanoramiXTile = NULL, *pPanoramiXStip = NULL;
- PanoramiXPmap *pPanoramiXClip = NULL;
- int tile_offset, stip_offset, clip_offset;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
+ int tile_offset = 0, stip_offset = 0, clip_offset = 0;
+ int result = 0, len, j;
+ XID tmp;
REQUEST_AT_LEAST_SIZE(xChangeGCReq);
- VERIFY_GC(pGC, stuff->gc, client);
- len = client->req_len - (sizeof(xChangeGCReq) >> 2);
- IF_RETURN((len != Ones((Mask)stuff->mask)), BadLength);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
- if ((Mask)stuff->mask & GCTile) {
- XID tileID;
+
+ len = client->req_len - (sizeof(xChangeGCReq) >> 2);
+ if (Ones(stuff->mask) != len)
+ return BadLength;
+
+ if (!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
- tile_offset = Ones((Mask)stuff->mask & (GCTile -1) );
- tileID = *((CARD32 *) &stuff[1] + tile_offset);
- if (tileID) {
- pPanoramiXTile = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXTile, tileID);
+ if ((Mask)stuff->mask & GCTile) {
+ tile_offset = Ones((Mask)stuff->mask & (GCTile - 1));
+ if ((tmp = *((CARD32 *) &stuff[1] + tile_offset))) {
+ if(!(tile = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
if ((Mask)stuff->mask & GCStipple) {
- XID stipID;
-
- stip_offset = Ones((Mask)stuff->mask & (GCStipple -1 ));
- stipID = *((CARD32 *) &stuff[1] + stip_offset);
- if (stipID) {
- pPanoramiXStip = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXStip, stipID);
+ stip_offset = Ones((Mask)stuff->mask & (GCStipple - 1));
+ if ((tmp = *((CARD32 *) &stuff[1] + stip_offset))) {
+ if(!(stip = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
if ((Mask)stuff->mask & GCClipMask) {
- XID clipID;
-
- clip_offset = Ones((Mask)stuff->mask & (GCClipMask -1));
- clipID = *((CARD32 *) &stuff[1] + clip_offset);
- if (clipID) {
- pPanoramiXClip = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXClip, clipID);
+ clip_offset = Ones((Mask)stuff->mask & (GCClipMask - 1));
+ if ((tmp = *((CARD32 *) &stuff[1] + clip_offset))) {
+ if(!(clip = (PanoramiXRes*) SecurityLookupIDByType(
+ client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
}
}
- FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
- stuff->gc = pPanoramiXGC->info[j].id;
- if (pPanoramiXTile)
- *((CARD32 *) &stuff[1] + tile_offset) = pPanoramiXTile->info[j].id;
- if (pPanoramiXStip)
- *((CARD32 *) &stuff[1] + stip_offset) = pPanoramiXStip->info[j].id;
- if (pPanoramiXClip)
- *((CARD32 *) &stuff[1] + clip_offset) = pPanoramiXClip->info[j].id;
- result = (* SavedProcVector[X_ChangeGC])(client);
- BREAK_IF(result != Success);
- }
- PANORAMIX_FREE(client);
+
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->gc = gc->info[j].id;
+ if (tile)
+ *((CARD32 *) &stuff[1] + tile_offset) = tile->info[j].id;
+ if (stip)
+ *((CARD32 *) &stuff[1] + stip_offset) = stip->info[j].id;
+ if (clip)
+ *((CARD32 *) &stuff[1] + clip_offset) = clip->info[j].id;
+ result = (*SavedProcVector[X_ChangeGC])(client);
+ if(result != Success) break;
+ }
+
return (result);
}
int PanoramiXCopyGC(ClientPtr client)
{
- int j, result;
- PanoramiXGC *pPanoramiXGCSrc = PanoramiXGCRoot;
- PanoramiXGC *pPanoramiXGCDst = PanoramiXGCRoot;
+ PanoramiXRes *srcGC, *dstGC;
+ int result = 0, j;
REQUEST(xCopyGCReq);
REQUEST_SIZE_MATCH(xCopyGCReq);
- PANORAMIXFIND_ID(pPanoramiXGCSrc, stuff->srcGC);
- IF_RETURN(!pPanoramiXGCSrc, BadGC);
- PANORAMIXFIND_ID(pPanoramiXGCDst, stuff->dstGC);
- IF_RETURN(!pPanoramiXGCDst, BadGC);
- FOR_NSCREENS_OR_ONCE(pPanoramiXGCDst, j) {
- stuff->srcGC = pPanoramiXGCSrc->info[j].id;
- stuff->dstGC = pPanoramiXGCDst->info[j].id;
- result = (* SavedProcVector[X_CopyGC])(client);
- BREAK_IF(result != Success);
+
+ if(!(srcGC = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->srcGC, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ if(!(dstGC = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->dstGC, XRT_GC, SecurityWriteAccess)))
+ return BadGC;
+
+ FOR_NSCREENS(j) {
+ stuff->srcGC = srcGC->info[j].id;
+ stuff->dstGC = dstGC->info[j].id;
+ result = (*SavedProcVector[X_CopyGC])(client);
+ if(result != Success) break;
}
+
return (result);
}
int PanoramiXSetDashes(ClientPtr client)
{
- GC *pGC;
+ PanoramiXRes *gc;
+ int result = 0, j;
REQUEST(xSetDashesReq);
- int result, j;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
REQUEST_FIXED_SIZE(xSetDashesReq, stuff->nDashes);
- VERIFY_GC(pGC, stuff->gc, client);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
- FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_SetDashes])(client);
- BREAK_IF(result != Success);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityWriteAccess)))
+ return BadGC;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->gc = gc->info[j].id;
+ result = (*SavedProcVector[X_SetDashes])(client);
+ if(result != Success) break;
}
+
return (result);
}
-int PanoramiXSetClipRectangles(register ClientPtr client)
+int PanoramiXSetClipRectangles(ClientPtr client)
{
- int result;
- register GC *pGC;
+ PanoramiXRes *gc;
+ int result = 0, j;
REQUEST(xSetClipRectanglesReq);
- int j;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
- FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_SetClipRectangles])(client);
- BREAK_IF(result != Success);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityWriteAccess)))
+ return BadGC;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->gc = gc->info[j].id;
+ result = (*SavedProcVector[X_SetClipRectangles])(client);
+ if(result != Success) break;
}
+
return (result);
}
int PanoramiXFreeGC(ClientPtr client)
{
- register GC *pGC;
+ PanoramiXRes *gc;
+ int result = 0, j;
REQUEST(xResourceReq);
- int result, j;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- PanoramiXGC *pPanoramiXGCback = NULL;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xResourceReq);
- for (; pPanoramiXGC && (pPanoramiXGC->info[0].id != stuff->id);
- pPanoramiXGC = pPanoramiXGC->next)
- pPanoramiXGCback = pPanoramiXGC;
- IF_RETURN(!pPanoramiXGC, BadGC);
- FOR_NSCREENS_OR_ONCE(pPanoramiXGC, j) {
- stuff->id = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_FreeGC])(client);
- BREAK_IF(result != Success);
- }
- if ((result == Success) && pPanoramiXGCback &&
- pPanoramiXGC && pPanoramiXGC->FreeMe) {
- pPanoramiXGCback->next = pPanoramiXGC->next;
- if (pPanoramiXGC)
- Xfree(pPanoramiXGC);
- }
- PANORAMIX_FREE(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_GC, SecurityDestroyAccess)))
+ return BadGC;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->id = gc->info[j].id;
+ result = (*SavedProcVector[X_FreeGC])(client);
+ if(result != Success) break;
+ }
+
+ /* Since ProcFreeGC is using FreeResource, it will free
+ our resource for us on the last pass through the loop above */
+
return (result);
}
-int PanoramiXClearToBackground(register ClientPtr client)
+int PanoramiXClearToBackground(ClientPtr client)
{
+ PanoramiXRes *win;
+ int result = 0, j, x, y;
+ Bool isRoot;
REQUEST(xClearAreaReq);
- register WindowPtr pWin;
- int result, j;
- Window winID;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- int orig_x, orig_y;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xClearAreaReq);
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
- IF_RETURN(!pPanoramiXWin, BadWindow);
- orig_x = stuff->x;
- orig_y = stuff->y;
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- winID = pPanoramiXWin->info[j].id;
- pWin = (WindowPtr) SecurityLookupWindow(winID, client, SecurityReadAccess);
- if (!pWin) {
- client->errorValue = pPanoramiXWin->info[0].id;
- return (BadWindow);
- }
- stuff->window = winID;
- if (pWin->drawable.id == PanoramiXWinRoot->info[j].id) {
- stuff->x = orig_x - panoramiXdataPtr[j].x;
- stuff->y = orig_y - panoramiXdataPtr[j].y;
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ x = stuff->x;
+ y = stuff->y;
+ isRoot = (stuff->window == WindowTable[0]->drawable.id);
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->window = win->info[j].id;
+ if(isRoot) {
+ stuff->x = x - panoramiXdataPtr[j].x;
+ stuff->y = y - panoramiXdataPtr[j].y;
}
result = (*SavedProcVector[X_ClearArea])(client);
+ if(result != Success) break;
}
- PANORAMIX_FREE(client);
+
return (result);
}
+/*
+ For Window to Pixmap copies you're screwed since each screen's
+ pixmap will look like what it sees on its screen. Unless the
+ screens overlap and the window lies on each, the two copies
+ will be out of sync. To remedy this we do a GetImage and PutImage
+ in place of the copy. Doing this as a single Image isn't quite
+ correct since it will include the obscured areas but we will
+ have to fix this later. (MArk).
+*/
+
int PanoramiXCopyArea(ClientPtr client)
{
- int j, result;
- Window srcID, dstID;
- DrawablePtr pSrc, pDst;
- GContext GCID;
- GC *pGC;
- PanoramiXWindow *pPanoramiXSrcRoot;
- PanoramiXWindow *pPanoramiXDstRoot;
- PanoramiXWindow *pPanoramiXSrc;
- PanoramiXWindow *pPanoramiXDst;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
+ int j, result = 0, srcx, srcy, dstx, dsty;
+ PanoramiXRes *gc, *src, *dst;
+ Bool srcIsRoot = FALSE;
+ Bool dstIsRoot = FALSE;
+ Bool srcShared, dstShared;
REQUEST(xCopyAreaReq);
- int srcx = stuff->srcX, srcy = stuff->srcY;
- int dstx = stuff->dstX, dsty = stuff->dstY;
REQUEST_SIZE_MATCH(xCopyAreaReq);
- VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, pGC, client);
- if (stuff->dstDrawable != stuff->srcDrawable) {
- VERIFY_DRAWABLE(pSrc, stuff->srcDrawable, client);
- if ((pDst->pScreen != pSrc->pScreen) || (pDst->depth != pSrc->depth)) {
- client->errorValue = stuff->dstDrawable;
- return (BadMatch);
- }
+ if(!(src = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->srcDrawable, XRC_DRAWABLE, SecurityReadAccess)))
+ return BadDrawable;
+
+ srcShared = IS_SHARED_PIXMAP(src);
+
+ if(!(dst = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->dstDrawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ dstShared = IS_SHARED_PIXMAP(dst);
+
+ if(dstShared && srcShared)
+ return (* SavedProcVector[X_CopyArea])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ if((dst->type == XRT_WINDOW) &&
+ (stuff->dstDrawable == WindowTable[0]->drawable.id))
+ dstIsRoot = TRUE;
+ if((src->type == XRT_WINDOW) &&
+ (stuff->srcDrawable == WindowTable[0]->drawable.id))
+ srcIsRoot = TRUE;
+
+ srcx = stuff->srcX; srcy = stuff->srcY;
+ dstx = stuff->dstX; dsty = stuff->dstY;
+ if((dst->type == XRT_PIXMAP) && (src->type == XRT_WINDOW)) {
+ DrawablePtr drawables[MAXSCREENS];
+ DrawablePtr pDst;
+ GCPtr pGC;
+ char *data;
+ int pitch;
+
+ FOR_NSCREENS(j)
+ VERIFY_DRAWABLE(drawables[j], src->info[j].id, client);
+
+ pitch = PixmapBytePad(stuff->width, drawables[0]->depth);
+ if(!(data = xcalloc(1, stuff->height * pitch)))
+ return BadAlloc;
+
+ XineramaGetImageData(drawables, srcx, srcy,
+ stuff->width, stuff->height, ZPixmap, ~0, data, pitch,
+ srcIsRoot);
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->gc = gc->info[j].id;
+ VALIDATE_DRAWABLE_AND_GC(dst->info[j].id, pDst, pGC, client);
+
+ if(drawables[0]->depth != pDst->depth) {
+ client->errorValue = stuff->dstDrawable;
+ xfree(data);
+ return (BadMatch);
+ }
+
+ (*pGC->ops->PutImage) (pDst, pGC, pDst->depth, dstx, dsty,
+ stuff->width, stuff->height,
+ 0, ZPixmap, data);
+
+ if(dstShared) break;
+ }
+
+ xfree(data);
+
+ result = Success;
} else {
- pSrc = pDst;
- }
- pPanoramiXSrcRoot = (pSrc->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- pPanoramiXDstRoot = (pDst->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- pPanoramiXSrc = pPanoramiXSrcRoot;
- pPanoramiXDst = pPanoramiXDstRoot;
- PANORAMIXFIND_ID(pPanoramiXSrc, stuff->srcDrawable);
- IF_RETURN(!pPanoramiXSrc, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXDst, stuff->dstDrawable);
- IF_RETURN(!pPanoramiXDst, BadDrawable);
- GCID = stuff->gc;
- PANORAMIXFIND_ID(pPanoramiXGC, GCID);
- IF_RETURN(!pPanoramiXGC, BadGC);
-
- FOR_NSCREENS_OR_ONCE(pPanoramiXSrc, j) {
- stuff->dstDrawable = pPanoramiXDst->info[j].id;
- stuff->srcDrawable = pPanoramiXSrc->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- if (pPanoramiXSrc == pPanoramiXSrcRoot) {
- stuff->srcX = srcx - panoramiXdataPtr[j].x;
- stuff->srcY = srcy - panoramiXdataPtr[j].y;
+ DrawablePtr pDst = NULL, pSrc = NULL;
+ GCPtr pGC = NULL;
+ RegionPtr pRgn[MAXSCREENS];
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->dstDrawable = dst->info[j].id;
+ stuff->srcDrawable = src->info[j].id;
+ stuff->gc = gc->info[j].id;
+ if (srcIsRoot) {
+ stuff->srcX = srcx - panoramiXdataPtr[j].x;
+ stuff->srcY = srcy - panoramiXdataPtr[j].y;
+ }
+ if (dstIsRoot) {
+ stuff->dstX = dstx - panoramiXdataPtr[j].x;
+ stuff->dstY = dsty - panoramiXdataPtr[j].y;
+ }
+
+ VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, pGC, client);
+ if (stuff->dstDrawable != stuff->srcDrawable) {
+ SECURITY_VERIFY_DRAWABLE(pSrc, stuff->srcDrawable, client,
+ SecurityReadAccess);
+ if ((pDst->pScreen != pSrc->pScreen) ||
+ (pDst->depth != pSrc->depth)) {
+ client->errorValue = stuff->dstDrawable;
+ return (BadMatch);
+ }
+ } else
+ pSrc = pDst;
+
+ pRgn[j] = (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
+ stuff->srcX, stuff->srcY,
+ stuff->width, stuff->height,
+ stuff->dstX, stuff->dstY);
+
+ if(dstShared) {
+ while(j--) pRgn[j] = NULL;
+ break;
+ }
}
- if (pPanoramiXDst == pPanoramiXDstRoot) {
- stuff->dstX = dstx - panoramiXdataPtr[j].x;
- stuff->dstY = dsty - panoramiXdataPtr[j].y;
+
+ if(pGC->graphicsExposures) {
+ ScreenPtr pScreen = pDst->pScreen;
+ RegionRec totalReg;
+ Bool overlap;
+
+ REGION_INIT(pScreen, &totalReg, NullBox, 1);
+ FOR_NSCREENS_BACKWARD(j) {
+ if(pRgn[j]) {
+ if(srcIsRoot) {
+ REGION_TRANSLATE(pScreen, pRgn[j],
+ panoramiXdataPtr[j].x, panoramiXdataPtr[j].y);
+ }
+ REGION_APPEND(pScreen, &totalReg, pRgn[j]);
+ REGION_DESTROY(pScreen, pRgn[j]);
+ }
+ }
+ REGION_VALIDATE(pScreen, &totalReg, &overlap);
+ (*pScreen->SendGraphicsExpose)(
+ client, &totalReg, stuff->dstDrawable, X_CopyArea, 0);
+ REGION_UNINIT(pScreen, &totalReg);
}
- result = (* SavedProcVector[X_CopyArea])(client);
- BREAK_IF(result != Success);
+
+ result = client->noClientException;
}
+
return (result);
}
+
int PanoramiXCopyPlane(ClientPtr client)
{
- int SrcScr = -1, DstScr = -1;
- PixmapPtr pMap = NULL;
- Pixmap pmapID;
- PanoramiXRect SrcRect, DstRect;
- int i, j, k;
- Window srcID, dstID;
- DrawablePtr pSrc, pDst;
- GContext GCID;
- GContext GCIDbase;
- GC *pGC;
- PanoramiXWindow *pPanoramiXSrc;
- PanoramiXWindow *pPanoramiXDst;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- RegionPtr *PanoramiXRgnPtrs;
- RegionPtr *FetchRgnPtrs = NULL;
- RegionPtr pRgn;
+ int j, srcx, srcy, dstx, dsty;
+ PanoramiXRes *gc, *src, *dst;
+ Bool srcIsRoot = FALSE;
+ Bool dstIsRoot = FALSE;
+ Bool srcShared, dstShared;
+ DrawablePtr psrcDraw, pdstDraw = NULL;
+ GCPtr pGC = NULL;
+ RegionPtr pRgn[MAXSCREENS];
REQUEST(xCopyPlaneReq);
- int srcx = stuff->srcX, srcy = stuff->srcY;
- int dstx = stuff->dstX, dsty = stuff->dstY;
- int width = stuff->width, height = stuff->height;
REQUEST_SIZE_MATCH(xCopyPlaneReq);
- VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, pGC, client);
- if (stuff->dstDrawable != stuff->srcDrawable) {
- VERIFY_DRAWABLE(pSrc, stuff->srcDrawable, client);
- if (pDst->pScreen != pSrc->pScreen) {
- client->errorValue = stuff->dstDrawable;
- return (BadMatch);
- }
- } else {
- pSrc = pDst;
- }
+ if(!(src = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->srcDrawable, XRC_DRAWABLE, SecurityReadAccess)))
+ return BadDrawable;
- /*
- * Check to see if stuff->bitPlane has exactly ONE good bit set
- */
+ srcShared = IS_SHARED_PIXMAP(src);
+ if(!(dst = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->dstDrawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
- if(stuff->bitPlane == 0 || (stuff->bitPlane & (stuff->bitPlane - 1)) ||
- (stuff->bitPlane > (1L << (pSrc->depth - 1))))
- {
- client->errorValue = stuff->bitPlane;
- return(BadValue);
- }
-
- pPanoramiXSrc = (pSrc->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- pPanoramiXDst = (pDst->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXSrc, stuff->srcDrawable);
- IF_RETURN(!pPanoramiXSrc, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXDst, stuff->dstDrawable);
- IF_RETURN(!pPanoramiXDst, BadDrawable);
- GCIDbase = stuff->gc;
- PANORAMIXFIND_ID(pPanoramiXGC, GCIDbase);
- IF_RETURN(!pPanoramiXGC, BadGC);
-
- /*
- * Unless both are pixmaps, need to do special things to accomodate
- * being on multiple screens, different screens, etc.
- */
-
- if (pSrc->type != DRAWABLE_PIXMAP) {
- SrcRect.x = pSrc->x + srcx;
- SrcRect.y = pSrc->y + srcy;
- SrcRect.width = width;
- SrcRect.height = height;
- for (SrcScr = PanoramiXNumScreens - 1; SrcScr>=0; SrcScr-- )
- if (RECTA_SUBSUMES_RECTB(panoramiXdataPtr[SrcScr], SrcRect))
- break;
- }
- if (pDst->type != DRAWABLE_PIXMAP) {
- DstRect.x = pDst->x + dstx;
- DstRect.y = pDst->y + dsty;
- DstRect.width = width;
- DstRect.height = height;
- for (DstScr = PanoramiXNumScreens - 1; DstScr>=0; DstScr--)
- if (RECTA_SUBSUMES_RECTB(panoramiXdataPtr[DstScr], DstRect))
- break;
- }
-
- /*
- * If source is on multiple screens, different screen from destination,
- * destination is on multiple screens, or destination is a pixmap,
- * need to get info into local pixmap for subsequent transfer.
- */
-
-
- if ((pSrc->type != DRAWABLE_PIXMAP) &&
- (SrcScr < 0 || DstScr < 0 || SrcScr != DstScr
- || pDst->type == DRAWABLE_PIXMAP)) {
- unsigned char save_alu;
- RegionRec tempReg;
- RegionPtr pCompositeClip;
- PanoramiXPmap *pPanoramiXPmap = PanoramiXPmapRoot;
-
- pMap = (PixmapPtr) (*pSrc->pScreen->CreatePixmap)(pSrc->pScreen,
- width, height, pGC->depth);
- PANORAMIXFIND_LAST(pPanoramiXPmap, PanoramiXPmapRoot);
- pPanoramiXPmap->next =
- (PanoramiXPmap *)Xcalloc(sizeof(PanoramiXPmap));
- pPanoramiXPmap = pPanoramiXPmap->next;
- pmapID = FakeClientID(0);
- AddResource(pmapID, RT_PIXMAP, (pointer)pMap);
- for (j = PanoramiXNumScreens - 1; j>=0; j--)
- pPanoramiXPmap->info[j].id = pmapID;
- tempReg.extents.x1 = 0;
- tempReg.extents.y1 = 0;
- tempReg.extents.x2 = width;
- tempReg.extents.y2 = height;
- tempReg.data = NULL;
- FetchRgnPtrs =
- (RegionPtr *) ALLOCATE_LOCAL(PanoramiXNumScreens * sizeof(RegionPtr));
- i = 0;
- FOR_NSCREENS_OR_ONCE(pPanoramiXSrc, j) {
- if ((SrcScr >= 0) && pPanoramiXSrc)
- j = SrcScr;
- srcID = pPanoramiXSrc->info[j].id;
- pSrc = (DrawablePtr) SecurityLookupIDByClass(client, srcID, RC_DRAWABLE,
- SecurityReadAccess);
- GCID = pPanoramiXGC->info[j].id;
- pGC = (GC *) LookupIDByType(GCID, RT_GC);
- pMap->drawable.pScreen = pSrc->pScreen;
- pGC->pScreen = pSrc->pScreen;
- save_alu = pGC->alu;
- pGC->alu = GXcopy;
- pCompositeClip = ((miPrivGC*)
- (pGC->devPrivates[miGCPrivateIndex].ptr))->pCompositeClip;
- ((miPrivGC*)(pGC->devPrivates[miGCPrivateIndex].ptr))->pCompositeClip =
-&tempReg;
- FetchRgnPtrs[i++] = (*pGC->ops->CopyPlane)(pSrc, (DrawablePtr) pMap,
- pGC, srcx, srcy, width, height, 0, 0, stuff->bitPlane);
- pGC->alu = save_alu;
- ((miPrivGC*) (pGC->devPrivates[miGCPrivateIndex].ptr))->pCompositeClip =
-pCompositeClip;
- if (SrcScr >= 0)
- j = 0;
- }
- }
+ dstShared = IS_SHARED_PIXMAP(dst);
- if (pMap) {
- pSrc = (DrawablePtr) pMap;
- srcx = 0;
- srcy = 0;
- }
- PanoramiXRgnPtrs =
- (RegionPtr *) ALLOCATE_LOCAL(PanoramiXNumScreens * sizeof(RegionPtr));
- k = 0;
- /* if src and dst are entirely on one screen,
- then we only need one simple transfer */
- if ((DstScr >= 0) && (pMap || (SrcScr >=0))) {
- dstID = pPanoramiXDst->info[DstScr].id;
- pDst = (DrawablePtr) SecurityLookupIDByClass(client, dstID, RC_DRAWABLE,
- SecurityReadAccess);
- GCID = pPanoramiXGC->info[DstScr].id;
- pGC = (GC *) LookupIDByType(GCID, RT_GC);
- ValidateGC(pDst, pGC);
- if (pMap) {
- pMap->drawable.pScreen = pDst->pScreen;
- } else {
- srcID = pPanoramiXSrc->info[SrcScr].id;
- if (srcID != dstID) {
- pSrc = (DrawablePtr) SecurityLookupIDByClass(client, srcID, RC_DRAWABLE,
- SecurityReadAccess);
- } else
- pSrc = pDst;
+ if(dstShared && srcShared)
+ return (* SavedProcVector[X_CopyPlane])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ if((dst->type == XRT_WINDOW) &&
+ (stuff->dstDrawable == WindowTable[0]->drawable.id))
+ dstIsRoot = TRUE;
+ if((src->type == XRT_WINDOW) &&
+ (stuff->srcDrawable == WindowTable[0]->drawable.id))
+ srcIsRoot = TRUE;
+
+ srcx = stuff->srcX; srcy = stuff->srcY;
+ dstx = stuff->dstX; dsty = stuff->dstY;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->dstDrawable = dst->info[j].id;
+ stuff->srcDrawable = src->info[j].id;
+ stuff->gc = gc->info[j].id;
+ if (srcIsRoot) {
+ stuff->srcX = srcx - panoramiXdataPtr[j].x;
+ stuff->srcY = srcy - panoramiXdataPtr[j].y;
}
- if (pMap)
- PanoramiXRgnPtrs[k++] = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
- srcx, srcy, width, height, dstx, dsty,
- 1);
- else
- PanoramiXRgnPtrs[k++] = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
- srcx, srcy, width, height, dstx, dsty,
- stuff->bitPlane);
- }else {
- FOR_NSCREENS_OR_ONCE(pPanoramiXDst, j) {
- if (DstScr >= 0) {
- dstID = pPanoramiXDst->info[DstScr].id;
- GCID = pPanoramiXGC->info[DstScr].id;
- } else {
- dstID = pPanoramiXDst->info[j].id;
- GCID = pPanoramiXGC->info[j].id;
+ if (dstIsRoot) {
+ stuff->dstX = dstx - panoramiXdataPtr[j].x;
+ stuff->dstY = dsty - panoramiXdataPtr[j].y;
}
- pDst = (DrawablePtr) SecurityLookupIDByClass(client, dstID, RC_DRAWABLE,
- SecurityReadAccess);
- pGC = (GC *) LookupIDByType(GCID, RT_GC);
- ValidateGC(pDst, pGC);
- if (pMap) {
- pMap->drawable.pScreen = pDst->pScreen;
- } else {
- srcID = pPanoramiXSrc->info[j].id;
- if (srcID != dstID) {
- pSrc = (DrawablePtr) SecurityLookupIDByClass(client, srcID, RC_DRAWABLE,
- SecurityReadAccess);
- } else {
- pSrc = pDst;
+
+ VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pdstDraw, pGC, client);
+ if (stuff->dstDrawable != stuff->srcDrawable) {
+ SECURITY_VERIFY_DRAWABLE(psrcDraw, stuff->srcDrawable, client,
+ SecurityReadAccess);
+ if (pdstDraw->pScreen != psrcDraw->pScreen) {
+ client->errorValue = stuff->dstDrawable;
+ return (BadMatch);
}
+ } else
+ psrcDraw = pdstDraw;
+
+ if(stuff->bitPlane == 0 || (stuff->bitPlane & (stuff->bitPlane - 1)) ||
+ (stuff->bitPlane > (1L << (psrcDraw->depth - 1)))) {
+ client->errorValue = stuff->bitPlane;
+ return(BadValue);
}
- if (pMap)
- PanoramiXRgnPtrs[k++] = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
- srcx, srcy, width, height, dstx, dsty,
- 1);
- else
- PanoramiXRgnPtrs[k++] = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
- srcx, srcy, width, height, dstx, dsty,
- stuff->bitPlane);
- }
- }
-
- if (pMap) {
- for (j = PanoramiXNumScreens - 1; j>=0; j--)
- if (PanoramiXRgnPtrs[j])
- (*pDst->pScreen->RegionDestroy) (PanoramiXRgnPtrs[j]);
- DEALLOCATE_LOCAL(PanoramiXRgnPtrs);
- PanoramiXRgnPtrs = FetchRgnPtrs;
- k = i;
- }
- j = 1;
- i = 0;
- pRgn = PanoramiXRgnPtrs[i];
- while ((j < k) && pRgn && !REGION_NIL(pRgn)) {
- if (PanoramiXRgnPtrs[j]) {
- (*pGC->pScreen->Intersect)(pRgn, pRgn, PanoramiXRgnPtrs[j++]);
- } else {
- pRgn = PanoramiXRgnPtrs[i++];
+
+ pRgn[j] = (*pGC->ops->CopyPlane)(psrcDraw, pdstDraw, pGC,
+ stuff->srcX, stuff->srcY,
+ stuff->width, stuff->height,
+ stuff->dstX, stuff->dstY, stuff->bitPlane);
+
+ if(dstShared) {
+ while(j--) pRgn[j] = NULL;
+ break;
}
}
- for (j = 0 ; j < k; j++) {
- pRgn = PanoramiXRgnPtrs[j];
- GCID = pPanoramiXGC->info[j].id;
- pGC = (GC *) LookupIDByType(GCID, RT_GC);
- if (pGC && pGC->graphicsExposures)
- (*pDst->pScreen->SendGraphicsExpose) (client, pRgn,
- stuff->dstDrawable, X_CopyPlane, 0);
- if (pRgn)
- (*pDst->pScreen->RegionDestroy) (pRgn);
- }
- DEALLOCATE_LOCAL(PanoramiXRgnPtrs);
- if (pMap) {
- PanoramiXPmap *pPanoramiXPmap = PanoramiXPmapRoot;
- PanoramiXPmap *pback = PanoramiXPmapRoot;
-
- for (; pPanoramiXPmap && (pPanoramiXPmap->info[0].id != pmapID);
- pPanoramiXPmap = pPanoramiXPmap->next)
- pback = pPanoramiXPmap;
- FreeResource(pPanoramiXPmap->info[0].id, RT_NONE);
- if (pback) {
- pback->next = pPanoramiXPmap->next;
- Xfree(pPanoramiXPmap);
+
+ if(pGC->graphicsExposures) {
+ ScreenPtr pScreen = pdstDraw->pScreen;
+ RegionRec totalReg;
+ Bool overlap;
+
+ REGION_INIT(pScreen, &totalReg, NullBox, 1);
+ FOR_NSCREENS_BACKWARD(j) {
+ if(pRgn[j]) {
+ REGION_APPEND(pScreen, &totalReg, pRgn[j]);
+ REGION_DESTROY(pScreen, pRgn[j]);
+ }
}
+ REGION_VALIDATE(pScreen, &totalReg, &overlap);
+ (*pScreen->SendGraphicsExpose)(
+ client, &totalReg, stuff->dstDrawable, X_CopyPlane, 0);
+ REGION_UNINIT(pScreen, &totalReg);
}
+
return (client->noClientException);
}
int PanoramiXPolyPoint(ClientPtr client)
{
- int result, npoint, i, j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr locDraw;
- int x_off = 0, y_off = 0;
+ PanoramiXRes *gc, *draw;
+ int result = 0, npoint, j;
xPoint *origPts;
- xPoint *origPtr, *modPtr;
+ Bool isRoot;
REQUEST(xPolyPointReq);
REQUEST_AT_LEAST_SIZE(xPolyPointReq);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!locDraw, BadDrawable);
- pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, locDraw->id);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolyPoint])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
npoint = ((client->req_len << 2) - sizeof(xPolyPointReq)) >> 2;
if (npoint > 0) {
origPts = (xPoint *) ALLOCATE_LOCAL(npoint * sizeof(xPoint));
memcpy((char *) origPts, (char *) &stuff[1], npoint * sizeof(xPoint));
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- if (pPanoramiXWin == PanoramiXWinRoot) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }else {
- if ( (locDraw->type == DRAWABLE_PIXMAP) &&
- /* add special case check for root window */
- (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
- }
- modPtr = (xPoint *) &stuff[1];
- origPtr = origPts;
- for (i = npoint; i; i--) {
- modPtr->x = origPtr->x - x_off;
- modPtr++->y = origPtr++->y - y_off;
- }
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_PolyPoint])(client);
- BREAK_IF(result != Success);
+ FOR_NSCREENS_FORWARD(j){
+
+ if(j) memcpy(&stuff[1], origPts, npoint * sizeof(xPoint));
+
+ if (isRoot) {
+ int x_off = panoramiXdataPtr[j].x;
+ int y_off = panoramiXdataPtr[j].y;
+
+ if(x_off || y_off) {
+ xPoint *pnts = (xPoint*)&stuff[1];
+ int i = (stuff->coordMode==CoordModePrevious) ? 1 : npoint;
+
+ while(i--) {
+ pnts->x -= x_off;
+ pnts->y -= y_off;
+ pnts++;
+ }
+ }
+ }
+
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_PolyPoint])(client);
+ if(result != Success) break;
}
DEALLOCATE_LOCAL(origPts);
return (result);
- }else
+ } else
return (client->noClientException);
-
}
int PanoramiXPolyLine(ClientPtr client)
{
- int result, npoint, i, j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr locDraw;
- int x_off = 0, y_off = 0;
+ PanoramiXRes *gc, *draw;
+ int result = 0, npoint, j;
xPoint *origPts;
- xPoint *origPtr, *modPtr;
+ Bool isRoot;
REQUEST(xPolyLineReq);
REQUEST_AT_LEAST_SIZE(xPolyLineReq);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!locDraw, BadDrawable);
- pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, locDraw->id);
- /* In the case of Multibuffering, we need to make sure the drawable
- isn't really a pixmap associated to a drawable */
- if (!pPanoramiXWin && (stuff->drawable != locDraw->id)) {
- pPanoramiXWin = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- }
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolyLine])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
npoint = ((client->req_len << 2) - sizeof(xPolyLineReq)) >> 2;
if (npoint > 0){
origPts = (xPoint *) ALLOCATE_LOCAL(npoint * sizeof(xPoint));
memcpy((char *) origPts, (char *) &stuff[1], npoint * sizeof(xPoint));
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- if (pPanoramiXWin == PanoramiXWinRoot) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }else {
- if ( (locDraw->type == DRAWABLE_PIXMAP) &&
- /* add special case check for root window */
- (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
- }
- modPtr = (xPoint *) &stuff[1];
- origPtr = origPts;
- for (i = npoint; i; i--) {
- modPtr->x = origPtr->x - x_off;
- modPtr++->y = origPtr++->y - y_off;
- }
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_PolyLine])(client);
- BREAK_IF(result != Success);
+ FOR_NSCREENS_FORWARD(j){
+
+ if(j) memcpy(&stuff[1], origPts, npoint * sizeof(xPoint));
+
+ if (isRoot) {
+ int x_off = panoramiXdataPtr[j].x;
+ int y_off = panoramiXdataPtr[j].y;
+
+ if(x_off || y_off) {
+ xPoint *pnts = (xPoint*)&stuff[1];
+ int i = (stuff->coordMode==CoordModePrevious) ? 1 : npoint;
+
+ while(i--) {
+ pnts->x -= x_off;
+ pnts->y -= y_off;
+ pnts++;
+ }
+ }
+ }
+
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_PolyLine])(client);
+ if(result != Success) break;
}
DEALLOCATE_LOCAL(origPts);
return (result);
- }else
+ } else
return (client->noClientException);
}
int PanoramiXPolySegment(ClientPtr client)
{
- int result, nsegs, i, j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr locDraw;
- int x_off = 0, y_off = 0;
+ int result = 0, nsegs, i, j;
+ PanoramiXRes *gc, *draw;
xSegment *origSegs;
- xSegment *origPtr, *modPtr;
+ Bool isRoot;
REQUEST(xPolySegmentReq);
REQUEST_AT_LEAST_SIZE(xPolySegmentReq);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!locDraw, BadDrawable);
- pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- /* In the case of Multibuffering, we need to make sure the drawable
- isn't really a pixmap associated to a drawable */
- if (!pPanoramiXWin && (stuff->drawable != locDraw->id)) {
- pPanoramiXWin = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- }
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolySegment])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
nsegs = (client->req_len << 2) - sizeof(xPolySegmentReq);
- IF_RETURN((nsegs & 4), BadLength);
+ if(nsegs & 4) return BadLength;
nsegs >>= 3;
if (nsegs > 0) {
- origSegs = (xSegment *) ALLOCATE_LOCAL(nsegs * sizeof(xSegment));
- memcpy((char *) origSegs, (char *) &stuff[1], nsegs *
-sizeof(xSegment));
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- if (pPanoramiXWin == PanoramiXWinRoot) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }else {
- if ( (locDraw->type == DRAWABLE_PIXMAP) &&
- /* add special case check for root window */
- (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
- }
- modPtr = (xSegment *) &stuff[1];
- origPtr = origSegs;
- for (i = nsegs; i; i--) {
- modPtr->x1 = origPtr->x1 - x_off;
- modPtr->y1 = origPtr->y1 - y_off;
- modPtr->x2 = origPtr->x2 - x_off;
- modPtr++->y2 = origPtr++->y2 - y_off;
- }
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_PolySegment])(client);
- BREAK_IF(result != Success);
+ origSegs = (xSegment *) ALLOCATE_LOCAL(nsegs * sizeof(xSegment));
+ memcpy((char *) origSegs, (char *) &stuff[1], nsegs * sizeof(xSegment));
+ FOR_NSCREENS_FORWARD(j){
+
+ if(j) memcpy(&stuff[1], origSegs, nsegs * sizeof(xSegment));
+
+ if (isRoot) {
+ int x_off = panoramiXdataPtr[j].x;
+ int y_off = panoramiXdataPtr[j].y;
+
+ if(x_off || y_off) {
+ xSegment *segs = (xSegment*)&stuff[1];
+
+ for (i = nsegs; i--; segs++) {
+ segs->x1 -= x_off;
+ segs->x2 -= x_off;
+ segs->y1 -= y_off;
+ segs->y2 -= y_off;
+ }
+ }
+ }
+
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_PolySegment])(client);
+ if(result != Success) break;
}
- DEALLOCATE_LOCAL(origSegs);
- return (result);
- }else
+ DEALLOCATE_LOCAL(origSegs);
+ return (result);
+ } else
return (client->noClientException);
}
int PanoramiXPolyRectangle(ClientPtr client)
{
- int result, nrects, i, j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr locDraw;
- int x_off = 0, y_off = 0;
+ int result = 0, nrects, i, j;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
xRectangle *origRecs;
- xRectangle *origPtr, *modPtr;
REQUEST(xPolyRectangleReq);
REQUEST_AT_LEAST_SIZE(xPolyRectangleReq);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!locDraw, BadDrawable);
- pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolyRectangle])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
nrects = (client->req_len << 2) - sizeof(xPolyRectangleReq);
- IF_RETURN((nrects & 4), BadLength);
+ if(nrects & 4) return BadLength;
nrects >>= 3;
if (nrects > 0){
- origRecs = (xRectangle *) ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
- memcpy((char *) origRecs, (char *) &stuff[1], nrects *
-sizeof(xRectangle));
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- if (pPanoramiXWin == PanoramiXWinRoot) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }else {
- if ( (locDraw->type == DRAWABLE_PIXMAP) &&
- /* add special case check for root window */
- (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
- }
- modPtr = (xRectangle *) &stuff[1];
- origPtr = origRecs;
- for (i = nrects; i; i--) {
- modPtr->x = origPtr->x - x_off;
- modPtr->y = origPtr->y - y_off;
- modPtr->width = origPtr->width - x_off;
- modPtr++->height = origPtr++->height - y_off;
+ origRecs = (xRectangle *) ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
+ memcpy((char *)origRecs,(char *)&stuff[1],nrects * sizeof(xRectangle));
+ FOR_NSCREENS_FORWARD(j){
+
+ if(j) memcpy(&stuff[1], origRecs, nrects * sizeof(xRectangle));
+
+ if (isRoot) {
+ int x_off = panoramiXdataPtr[j].x;
+ int y_off = panoramiXdataPtr[j].y;
+
+
+ if(x_off || y_off) {
+ xRectangle *rects = (xRectangle *) &stuff[1];
+
+ for (i = nrects; i--; rects++) {
+ rects->x -= x_off;
+ rects->y -= y_off;
+ }
+ }
+ }
+
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_PolyRectangle])(client);
+ if(result != Success) break;
}
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_PolyRectangle])(client);
- BREAK_IF(result != Success);
- }
- DEALLOCATE_LOCAL(origRecs);
- return (result);
- }else
+ DEALLOCATE_LOCAL(origRecs);
+ return (result);
+ } else
return (client->noClientException);
}
int PanoramiXPolyArc(ClientPtr client)
{
- int result, narcs, i, j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr locDraw;
- GCPtr locGC;
- int x_off = 0, y_off = 0;
+ int result = 0, narcs, i, j;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
xArc *origArcs;
- xArc *origPtr, *modPtr;
REQUEST(xPolyArcReq);
REQUEST_AT_LEAST_SIZE(xPolyArcReq);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!locDraw, BadDrawable);
- pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot :
-PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolyArc])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
narcs = (client->req_len << 2) - sizeof(xPolyArcReq);
- IF_RETURN((narcs % sizeof(xArc)), BadLength);
+ if(narcs % sizeof(xArc)) return BadLength;
narcs /= sizeof(xArc);
if (narcs > 0){
- origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
- memcpy((char *) origArcs, (char *) &stuff[1], narcs * sizeof(xArc));
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- if (pPanoramiXWin == PanoramiXWinRoot) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }else {
- if ( (locDraw->type == DRAWABLE_PIXMAP) &&
- /* add special case check for root window */
- (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
- }
- modPtr = (xArc *) &stuff[1];
- origPtr = origArcs;
- for (i = narcs; i; i--) {
- modPtr->x = origPtr->x - x_off;
- modPtr++->y = origPtr++->y - y_off;
+ origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
+ memcpy((char *) origArcs, (char *) &stuff[1], narcs * sizeof(xArc));
+ FOR_NSCREENS_FORWARD(j){
+
+ if(j) memcpy(&stuff[1], origArcs, narcs * sizeof(xArc));
+
+ if (isRoot) {
+ int x_off = panoramiXdataPtr[j].x;
+ int y_off = panoramiXdataPtr[j].y;
+
+ if(x_off || y_off) {
+ xArc *arcs = (xArc *) &stuff[1];
+
+ for (i = narcs; i--; arcs++) {
+ arcs->x -= x_off;
+ arcs->y -= y_off;
+ }
+ }
+ }
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_PolyArc])(client);
+ if(result != Success) break;
}
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_PolyArc])(client);
- BREAK_IF(result != Success);
- }
- DEALLOCATE_LOCAL(origArcs);
- return (result);
- }else
+ DEALLOCATE_LOCAL(origArcs);
+ return (result);
+ } else
return (client->noClientException);
}
int PanoramiXFillPoly(ClientPtr client)
{
- int result, count, i, j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr locDraw;
- GCPtr locGC;
- int x_off = 0, y_off = 0;
+ int result = 0, count, j;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
DDXPointPtr locPts;
- DDXPointPtr origPts, modPts;
REQUEST(xFillPolyReq);
REQUEST_AT_LEAST_SIZE(xFillPolyReq);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!locDraw, BadDrawable);
- pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_FillPoly])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
count = ((client->req_len << 2) - sizeof(xFillPolyReq)) >> 2;
if (count > 0){
- locPts = (DDXPointPtr) ALLOCATE_LOCAL(count * sizeof(DDXPointRec));
- memcpy((char *) locPts, (char *) &stuff[1], count *
-sizeof(DDXPointRec));
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- if (pPanoramiXWin == PanoramiXWinRoot) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }else {
- if ( (locDraw->type == DRAWABLE_PIXMAP) &&
- /* add special case check for root window */
- (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
- }
- modPts = (DDXPointPtr) &stuff[1];
- origPts = locPts;
- for (i = count; i; i--) {
- modPts->x = origPts->x - x_off;
- modPts++->y = origPts++->y - y_off;
+ locPts = (DDXPointPtr) ALLOCATE_LOCAL(count * sizeof(DDXPointRec));
+ memcpy((char *)locPts, (char *)&stuff[1], count * sizeof(DDXPointRec));
+ FOR_NSCREENS_FORWARD(j){
+
+ if(j) memcpy(&stuff[1], locPts, count * sizeof(DDXPointRec));
+
+ if (isRoot) {
+ int x_off = panoramiXdataPtr[j].x;
+ int y_off = panoramiXdataPtr[j].y;
+
+ if(x_off || y_off) {
+ DDXPointPtr pnts = (DDXPointPtr)&stuff[1];
+ int i = (stuff->coordMode==CoordModePrevious) ? 1 : count;
+
+ while(i--) {
+ pnts->x -= x_off;
+ pnts->y -= y_off;
+ pnts++;
+ }
+ }
+ }
+
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_FillPoly])(client);
+ if(result != Success) break;
}
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_FillPoly])(client);
- BREAK_IF(result != Success);
- }
- DEALLOCATE_LOCAL(locPts);
- return (result);
- }else
+ DEALLOCATE_LOCAL(locPts);
+ return (result);
+ } else
return (client->noClientException);
}
int PanoramiXPolyFillRectangle(ClientPtr client)
{
- int result, things, i, j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr locDraw;
- GCPtr locGC;
- int x_off = 0, y_off = 0;
- xRectangle *origThings;
- xRectangle *origPtr, *modPtr;
+ int result = 0, things, i, j;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
+ xRectangle *origRects;
REQUEST(xPolyFillRectangleReq);
REQUEST_AT_LEAST_SIZE(xPolyFillRectangleReq);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!locDraw, BadDrawable);
- pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot :
-PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolyFillRectangle])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
things = (client->req_len << 2) - sizeof(xPolyFillRectangleReq);
- IF_RETURN((things & 4), BadLength);
+ if(things & 4) return BadLength;
things >>= 3;
if (things > 0){
- origThings = (xRectangle *) ALLOCATE_LOCAL(things * sizeof(xRectangle));
- memcpy((char *) origThings, (char *)&stuff[1], things *
-sizeof(xRectangle));
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- if (pPanoramiXWin == PanoramiXWinRoot) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }else {
- if ( (locDraw->type == DRAWABLE_PIXMAP) &&
- /* add special case check for root window */
- (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
+ origRects = (xRectangle *) ALLOCATE_LOCAL(things * sizeof(xRectangle));
+ memcpy((char*)origRects,(char*)&stuff[1], things * sizeof(xRectangle));
+ FOR_NSCREENS_FORWARD(j){
+
+ if(j) memcpy(&stuff[1], origRects, things * sizeof(xRectangle));
+
+ if (isRoot) {
+ int x_off = panoramiXdataPtr[j].x;
+ int y_off = panoramiXdataPtr[j].y;
+
+ if(x_off || y_off) {
+ xRectangle *rects = (xRectangle *) &stuff[1];
+
+ for (i = things; i--; rects++) {
+ rects->x -= x_off;
+ rects->y -= y_off;
+ }
+ }
+ }
+
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_PolyFillRectangle])(client);
+ if(result != Success) break;
}
- modPtr = (xRectangle *) &stuff[1];
- origPtr = origThings;
- for (i = things; i; i--) {
- modPtr->x = origPtr->x - x_off;
- modPtr++->y = origPtr++->y - y_off;
- }
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_PolyFillRectangle])(client);
- BREAK_IF(result != Success);
- }
- DEALLOCATE_LOCAL(origThings);
- return (result);
- }else
+ DEALLOCATE_LOCAL(origRects);
+ return (result);
+ } else
return (client->noClientException);
}
int PanoramiXPolyFillArc(ClientPtr client)
{
- int result, arcs, i, j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr locDraw;
- GCPtr locGC;
- int x_off = 0, y_off = 0;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
+ int result = 0, narcs, i, j;
xArc *origArcs;
- xArc *origPtr, *modPtr;
REQUEST(xPolyFillArcReq);
REQUEST_AT_LEAST_SIZE(xPolyFillArcReq);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!locDraw, BadDrawable);
- pPanoramiXWin = (locDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot :
-PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
- arcs = (client->req_len << 2) - sizeof(xPolyFillArcReq);
- IF_RETURN((arcs % sizeof(xArc)), BadLength);
- arcs /= sizeof(xArc);
- if (arcs > 0) {
- origArcs = (xArc *) ALLOCATE_LOCAL(arcs * sizeof(xArc));
- memcpy((char *) origArcs, (char *)&stuff[1], arcs * sizeof(xArc));
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- if (pPanoramiXWin == PanoramiXWinRoot) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }else {
- if ( (locDraw->type == DRAWABLE_PIXMAP) &&
- /* add special case check for root window */
- (locDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- x_off = panoramiXdataPtr[j].x;
- y_off = panoramiXdataPtr[j].y;
- }
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolyFillArc])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
+ narcs = (client->req_len << 2) - sizeof(xPolyFillArcReq);
+ IF_RETURN((narcs % sizeof(xArc)), BadLength);
+ narcs /= sizeof(xArc);
+ if (narcs > 0) {
+ origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
+ memcpy((char *) origArcs, (char *)&stuff[1], narcs * sizeof(xArc));
+ FOR_NSCREENS_FORWARD(j){
+
+ if(j) memcpy(&stuff[1], origArcs, narcs * sizeof(xArc));
+
+ if (isRoot) {
+ int x_off = panoramiXdataPtr[j].x;
+ int y_off = panoramiXdataPtr[j].y;
+
+ if(x_off || y_off) {
+ xArc *arcs = (xArc *) &stuff[1];
+
+ for (i = narcs; i--; arcs++) {
+ arcs->x -= x_off;
+ arcs->y -= y_off;
+ }
+ }
+ }
+
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_PolyFillArc])(client);
+ if(result != Success) break;
}
- modPtr = (xArc *) &stuff[1];
- origPtr = origArcs;
- for (i = arcs; i; i--) {
- modPtr->x = origPtr->x - x_off;
- modPtr++->y = origPtr++->y - y_off;
- }
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_PolyFillArc])(client);
- BREAK_IF(result != Success);
- }
- DEALLOCATE_LOCAL(origArcs);
- return (result);
- }else
+ DEALLOCATE_LOCAL(origArcs);
+ return (result);
+ } else
return (client->noClientException);
}
-/* 64-bit server notes: the protocol restricts padding of images to
- * 8-, 16-, or 32-bits. We would like to have 64-bits for the server
- * to use internally. Removes need for internal alignment checking.
- * All of the PutImage functions could be changed individually, but
- * as currently written, they call other routines which require things
- * to be 64-bit padded on scanlines, so we changed things here.
- * If an image would be padded differently for 64- versus 32-, then
- * copy each scanline to a 64-bit padded scanline.
- * Also, we need to make sure that the image is aligned on a 64-bit
- * boundary, even if the scanlines are padded to our satisfaction.
- */
-
-int PanoramiXPutImage(register ClientPtr client)
+int PanoramiXPutImage(ClientPtr client)
{
- register GC *pGC;
- register DrawablePtr pDraw;
- long lengthProto, /* length of scanline protocl padded */
- length; /* length of scanline server padded */
- char *tmpImage;
- int j;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXWindow *pPanoramiXRoot;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- int orig_x, orig_y;
- int result;
-
-
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
+ int j, result = 0, orig_x, orig_y;
REQUEST(xPutImageReq);
REQUEST_AT_LEAST_SIZE(xPutImageReq);
- pDraw = (DrawablePtr) SecurityLookupIDByClass(client, stuff->drawable,
-RC_DRAWABLE,
- SecurityReadAccess);
- IF_RETURN(!pDraw, BadDrawable);
- pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- pPanoramiXWin = pPanoramiXRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin,BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PutImage])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
orig_x = stuff->dstX;
orig_y = stuff->dstY;
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- if (pPanoramiXWin == pPanoramiXRoot) {
+ FOR_NSCREENS_BACKWARD(j){
+ if (isRoot) {
stuff->dstX = orig_x - panoramiXdataPtr[j].x;
stuff->dstY = orig_y - panoramiXdataPtr[j].y;
- }
- if (pDraw->type == DRAWABLE_PIXMAP) {
- if (stuff->width > panoramiXdataPtr[j].width)
- stuff->dstX = orig_x - panoramiXdataPtr[j].x;
- if (stuff->height > panoramiXdataPtr[j].height)
- stuff->dstY = orig_y - panoramiXdataPtr[j].y;
- }
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- result = (* SavedProcVector[X_PutImage])(client);
- }
- return(result);
+ }
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ result = (* SavedProcVector[X_PutImage])(client);
+ if(result != Success) break;
+ }
+ return (result);
}
-typedef struct _SrcParts{
- int x1, y1, x2, y2, width, ByteWidth;
- char *buf;
-} SrcPartsRec;
-
-
-int PanoramiXGetImage(register ClientPtr client)
+int PanoramiXGetImage(ClientPtr client)
{
- register DrawablePtr pDraw;
- int nlines, linesPerBuf;
- register int height, linesDone;
- long widthBytesLine, length;
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- long widthBytesLineProto, lengthProto;
- char *tmpImage;
-#endif
- Mask plane;
- char *pBuf;
+ DrawablePtr drawables[MAXSCREENS];
+ DrawablePtr pDraw;
+ PanoramiXRes *draw;
xGetImageReply xgi;
- int j, k, ScrNum;
- DrawablePtr locDraw;
- SrcPartsRec srcParts;
- BoxRec SrcBox;
- char *BufPtr, *PartPtr;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
+ Bool isRoot;
+ char *pBuf;
+ int i, x, y, w, h, format;
+ Mask plane = 0, planemask;
+ int linesDone, nlines, linesPerBuf;
+ long widthBytesLine, length;
REQUEST(xGetImageReq);
- height = stuff->height;
REQUEST_SIZE_MATCH(xGetImageReq);
+
if ((stuff->format != XYPixmap) && (stuff->format != ZPixmap)) {
client->errorValue = stuff->format;
return(BadValue);
}
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(draw->type == XRT_PIXMAP)
+ return (*SavedProcVector[X_GetImage])(client);
+
VERIFY_DRAWABLE(pDraw, stuff->drawable, client);
- ScrNum = 0;
- if (stuff->drawable == PanoramiXWinRoot->info[0].id) {
- for (j = 0; j <= (PanoramiXNumScreens - 1); j++) {
- ScrNum = j;
- VERIFY_DRAWABLE(pDraw, pPanoramiXWin->info[ScrNum].id, client);
- if (stuff->x < panoramiXdataPtr[ScrNum].x &&
- stuff->y < panoramiXdataPtr[ScrNum].y )
- break;
- }
- }
- if (pDraw->type == DRAWABLE_WINDOW) {
- if (!((WindowPtr) pDraw)->realized /* Check for viewable */
- || pDraw->x + stuff->x < 0 /* Check for on screen */
- || pDraw->x + stuff->x + (int)stuff->width > PanoramiXPixWidth
- || pDraw->y + stuff->y < 0
- || pDraw->y + stuff->y + height > PanoramiXPixHeight
- || stuff->x < - wBorderWidth((WindowPtr)pDraw) /* Inside border */
- || stuff->x + (int)stuff->width >
- wBorderWidth((WindowPtr)pDraw) + (int) pDraw->width
- + panoramiXdataPtr[ScrNum].x
- || stuff->y < -wBorderWidth((WindowPtr)pDraw)
- || stuff->y + height >
- wBorderWidth ((WindowPtr)pDraw) + (int) pDraw->height
- + panoramiXdataPtr[ScrNum].y)
+
+ if(!((WindowPtr)pDraw)->realized)
+ return(BadMatch);
+
+ x = stuff->x;
+ y = stuff->y;
+ w = stuff->width;
+ h = stuff->height;
+ format = stuff->format;
+ planemask = stuff->planeMask;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
+ if(isRoot) {
+ if( /* check for being onscreen */
+ x < 0 || x + w > PanoramiXPixWidth ||
+ y < 0 || y + h > PanoramiXPixHeight )
return(BadMatch);
- VERIFY_DRAWABLE(pDraw, stuff->drawable, client);
- xgi.visual = wVisual (((WindowPtr) pDraw));
- pPanoramiXWin = PanoramiXWinRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadWindow);
} else {
- if (stuff->x < 0 || stuff->x + (int)stuff->width > pDraw->width
- || stuff->y < 0 || stuff->y + height > pDraw->height)
+ if( /* check for being onscreen */
+ panoramiXdataPtr[0].x + pDraw->x + x < 0 ||
+ panoramiXdataPtr[0].x + pDraw->x + x + w > PanoramiXPixWidth ||
+ panoramiXdataPtr[0].y + pDraw->y + y < 0 ||
+ panoramiXdataPtr[0].y + pDraw->y + y + h > PanoramiXPixHeight ||
+ /* check for being inside of border */
+ x < - wBorderWidth((WindowPtr)pDraw) ||
+ x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
+ y < -wBorderWidth((WindowPtr)pDraw) ||
+ y + h > wBorderWidth ((WindowPtr)pDraw) + (int)pDraw->height)
return(BadMatch);
- xgi.visual = None;
}
+
+ drawables[0] = pDraw;
+ for(i = 1; i < PanoramiXNumScreens; i++)
+ VERIFY_DRAWABLE(drawables[i], draw->info[i].id, client);
+
+ xgi.visual = wVisual (((WindowPtr) pDraw));
xgi.type = X_Reply;
xgi.sequenceNumber = client->sequence;
xgi.depth = pDraw->depth;
- if (stuff->format == ZPixmap) {
- widthBytesLine = PixmapBytePad(stuff->width, pDraw->depth);
- length = widthBytesLine * height;
+ if(format == ZPixmap) {
+ widthBytesLine = PixmapBytePad(w, pDraw->depth);
+ length = widthBytesLine * h;
+
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- widthBytesLineProto = PixmapBytePadProto(stuff->width, pDraw->depth);
- lengthProto = widthBytesLineProto * height;
-#endif
} else {
- widthBytesLine = BitmapBytePad(stuff->width);
+ widthBytesLine = BitmapBytePad(w);
plane = ((Mask)1) << (pDraw->depth - 1);
/* only planes asked for */
- length = widthBytesLine * height *
- Ones(stuff->planeMask & (plane | (plane - 1)));
+ length = widthBytesLine * h *
+ Ones(planemask & (plane | (plane - 1)));
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- widthBytesLineProto = BitmapBytePadProto(stuff->width);
- lengthProto = widthBytesLineProto * height *
- Ones(stuff->planeMask & (plane | (plane - 1)));
-#endif
}
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- xgi.length = (lengthProto + 3) >> 2;
-#else
xgi.length = (length + 3) >> 2;
-#endif
- if (widthBytesLine == 0 || height == 0) {
+ if (widthBytesLine == 0 || h == 0)
linesPerBuf = 0;
- } else if (widthBytesLine >= IMAGE_BUFSIZE) {
+ else if (widthBytesLine >= XINERAMA_IMAGE_BUFSIZE)
linesPerBuf = 1;
- } else {
- linesPerBuf = IMAGE_BUFSIZE / widthBytesLine;
- if (linesPerBuf > height)
- linesPerBuf = height;
+ else {
+ linesPerBuf = XINERAMA_IMAGE_BUFSIZE / widthBytesLine;
+ if (linesPerBuf > h)
+ linesPerBuf = h;
}
length = linesPerBuf * widthBytesLine;
- if (linesPerBuf < height) {
-
- /*
- * Have to make sure intermediate buffers don't need padding
- */
-
- while ((linesPerBuf > 1)
- && (length & ((1 << LOG2_BYTES_PER_SCANLINE_PAD)-1))) {
- linesPerBuf--;
- length -= widthBytesLine;
- }
- while (length & ((1 << LOG2_BYTES_PER_SCANLINE_PAD)-1)) {
- linesPerBuf++;
- length += widthBytesLine;
- }
- }
- IF_RETURN((!(pBuf = (char *) ALLOCATE_LOCAL(length))), BadAlloc);
-
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- /*
- * Check for protocol/server padding differences
- */
-
- if (widthBytesLine != widthBytesLineProto)
- if (!(tmpImage = (char *) ALLOCATE_LOCAL(length))) {
- DEALLOCATE_LOCAL(pBuf);
- return (BadAlloc);
- }
-#endif
+ if(!(pBuf = xalloc(length)))
+ return (BadAlloc);
WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);
if (linesPerBuf == 0) {
-
- /*
- * Nothing to do
- */
-
- } else if (stuff->format == ZPixmap) {
+ /* nothing to do */
+ }
+ else if (format == ZPixmap) {
linesDone = 0;
- while (height - linesDone > 0) {
- nlines = min(linesPerBuf, height - linesDone);
- if (pDraw->type == DRAWABLE_WINDOW) {
- SrcBox.x1 = pDraw->x + stuff->x;
- SrcBox.y1 = pDraw->y + stuff->y + linesDone;
- SrcBox.x2 = SrcBox.x1 + stuff->width;
- SrcBox.y2 = SrcBox.y1 + nlines;
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
-
- /*
- * If it isn't even on this screen, just continue.
- */
+ while (h - linesDone > 0) {
+ nlines = min(linesPerBuf, h - linesDone);
- if ((SrcBox.x1 >= panoramiXdataPtr[j].x + panoramiXdataPtr[j].width)
- || (SrcBox.x2 <= panoramiXdataPtr[j].x)
- || (SrcBox.y1 >= panoramiXdataPtr[j].y+panoramiXdataPtr[j].height)
- || (SrcBox.y2 <= panoramiXdataPtr[j].y))
- continue;
-
- srcParts.x1 = max(SrcBox.x1 - panoramiXdataPtr[j].x, 0);
- srcParts.x2 = min(SrcBox.x2 - panoramiXdataPtr[j].x,
- panoramiXdataPtr[j].width);
- srcParts.y1 = max(SrcBox.y1 - panoramiXdataPtr[j].y, 0);
- srcParts.y2 = min(SrcBox.y2 - panoramiXdataPtr[j].y,
- panoramiXdataPtr[j].height);
- srcParts.width = srcParts.x2 - srcParts.x1;
- srcParts.ByteWidth = PixmapBytePad(srcParts.width,pDraw->depth);
- srcParts.buf = (char *) Xalloc(nlines * srcParts.ByteWidth);
- locDraw = (DrawablePtr) SecurityLookupIDByClass(client,
- pPanoramiXWin->info[j].id,
- RC_DRAWABLE,
- SecurityReadAccess);
- (*pDraw->pScreen->GetImage)(locDraw,
- srcParts.x1 - locDraw->x,
- srcParts.y1 - locDraw->y,
- srcParts.width,
- srcParts.y2 - srcParts.y1,
- stuff->format,
- (unsigned long)stuff->planeMask,
- srcParts.buf);
- BufPtr = pBuf
- + srcParts.x1 - stuff->x - (pDraw->x - panoramiXdataPtr[j].x)
- + widthBytesLine * (srcParts.y1 - stuff->y
- - (pDraw->y + linesDone - panoramiXdataPtr[j].y));
- PartPtr = srcParts.buf;
- for (k = (srcParts.y2 - srcParts.y1); k; k--) {
- bcopy(PartPtr, BufPtr, srcParts.width);
- BufPtr += widthBytesLine;
- PartPtr += srcParts.ByteWidth;
- }
- Xfree(srcParts.buf);
- }
- } else {
- (*pDraw->pScreen->GetImage) (pDraw, stuff->x, stuff->y + linesDone,
- stuff->width, nlines, stuff->format,
- (unsigned long)stuff->planeMask, pBuf);
- }
-
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- /*
- * For 64-bit server, convert image to pad to 32 bits
- */
-
- if ( widthBytesLine != widthBytesLineProto ) {
- register char * bufPtr, * protoPtr;
- register int i;
-
- bzero(tmpImage,length);
-
- for (i = 0, bufPtr = pBuf, protoPtr = tmpImage; i < nlines;
- bufPtr += widthBytesLine, protoPtr += widthBytesLineProto,
- i++)
- memmove(protoPtr,bufPtr,widthBytesLineProto);
-
- /*
- * Note this is NOT a call to WriteSwappedDataToClient,
- * as we do NOT byte swap
- */
-
- (void)WriteToClient(client,
- (int)(nlines * widthBytesLineProto), tmpImage);
- } else
-#endif
- {
+ if(pDraw->depth == 1)
+ bzero(pBuf, nlines * widthBytesLine);
- /*
- * Note this is NOT a call to WriteSwappedDataToClient,
- * as we do NOT byte swap
- */
+ XineramaGetImageData(drawables, x, y + linesDone, w, nlines,
+ format, planemask, pBuf, widthBytesLine, isRoot);
- (void)WriteToClient(client,
- (int)(nlines * widthBytesLine), pBuf);
- }
+ (void)WriteToClient(client,
+ (int)(nlines * widthBytesLine),
+ pBuf);
linesDone += nlines;
}
- } else { /* XYPixmap */
+ } else { /* XYPixmap */
for (; plane; plane >>= 1) {
- if (stuff->planeMask & plane) {
+ if (planemask & plane) {
linesDone = 0;
- while (height - linesDone > 0) {
- nlines = min(linesPerBuf, height - linesDone);
- (*pDraw->pScreen->GetImage) (pDraw,
- stuff->x,
- stuff->y + linesDone,
- stuff->width,
- nlines,
- stuff->format,
- (unsigned long)plane,
- pBuf);
-
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- /*
- * For 64-bit server, convert image to pad to 32 bits
- */
-
- if (widthBytesLine != widthBytesLineProto) {
- register char * bufPtr, * protoPtr;
- register int i;
-
- bzero(tmpImage, length);
-
- for (i = 0,bufPtr = pBuf,protoPtr =tmpImage; i < nlines;
- bufPtr += widthBytesLine,
- protoPtr += widthBytesLineProto,
- i++)
- bcopy(bufPtr, protoPtr, widthBytesLineProto);
-
- /*
- * Note: NOT a call to WriteSwappedDataToClient,
- * as we do NOT byte swap
- */
-
- (void)WriteToClient(client,
- (int)(nlines * widthBytesLineProto), tmpImage);
- } else
-#endif
- {
+ while (h - linesDone > 0) {
+ nlines = min(linesPerBuf, h - linesDone);
- /*
- * Note: NOT a call to WriteSwappedDataToClient,
- * as we do NOT byte swap
- */
+ bzero(pBuf, nlines * widthBytesLine);
+
+ XineramaGetImageData(drawables, x, y + linesDone, w,
+ nlines, format, plane, pBuf,
+ widthBytesLine, isRoot);
+
+ (void)WriteToClient(client,
+ (int)(nlines * widthBytesLine),
+ pBuf);
- (void)WriteToClient(client,
- (int)(nlines * widthBytesLine), pBuf);
- }
linesDone += nlines;
}
}
}
}
- DEALLOCATE_LOCAL(pBuf);
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- if (widthBytesLine != widthBytesLineProto)
- DEALLOCATE_LOCAL(tmpImage);
-#endif
+ xfree(pBuf);
return (client->noClientException);
}
+/* The text stuff should be rewritten so that duplication happens
+ at the GlyphBlt level. That is, loading the font and getting
+ the glyphs should only happen once */
+
int
-PanoramiXPolyText8(register ClientPtr client)
+PanoramiXPolyText8(ClientPtr client)
{
- int result, j;
-
- PanoramiXWindow *pPanoramiXRoot;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr pDraw;
- PixmapPtr pPixmap;
- GC *pGC;
- int orig_x, orig_y;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
+ int result = 0, j;
+ int orig_x, orig_y;
REQUEST(xPolyTextReq);
- VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
- pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- pPanoramiXWin = pPanoramiXRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- /* In the case of Multibuffering, we need to make sure the drawable
- isn't really a pixmap associated to a drawable */
- if (!pPanoramiXWin && (stuff->drawable != pDraw->id)) {
- pPanoramiXWin = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- }
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+ REQUEST_AT_LEAST_SIZE(xPolyTextReq);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolyText8])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
orig_x = stuff->x;
orig_y = stuff->y;
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- stuff->x = orig_x;
- stuff->y = orig_y;
- if (pPanoramiXWin == pPanoramiXRoot) {
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ if (isRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
- } else {
- if ( (pDraw->type == DRAWABLE_PIXMAP) &&
- /* special case root window bitmap */
- (pDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- stuff->x = orig_x - panoramiXdataPtr[j].x;
- stuff->y = orig_y - panoramiXdataPtr[j].y;
- }
}
- if (!j)
- noPanoramiXExtension = TRUE;
result = (*SavedProcVector[X_PolyText8])(client);
- noPanoramiXExtension = FALSE;
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
return (result);
}
int
-PanoramiXPolyText16(register ClientPtr client)
+PanoramiXPolyText16(ClientPtr client)
{
- int result, j;
-
- PanoramiXWindow *pPanoramiXRoot;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr pDraw;
- GC *pGC;
- int orig_x, orig_y;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
+ int result = 0, j;
+ int orig_x, orig_y;
REQUEST(xPolyTextReq);
- VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
- pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- pPanoramiXWin = pPanoramiXRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- /* In the case of Multibuffering, we need to make sure the drawable
- isn't really a pixmap associated to a drawable */
- if (!pPanoramiXWin && (stuff->drawable != pDraw->id)) {
- pPanoramiXWin = PanoramiXPmapRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- }
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+ REQUEST_AT_LEAST_SIZE(xPolyTextReq);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_PolyText16])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
orig_x = stuff->x;
orig_y = stuff->y;
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- stuff->x = orig_x;
- stuff->y = orig_y;
- if (pPanoramiXWin == pPanoramiXRoot) {
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ if (isRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
- } else {
- if ( (pDraw->type == DRAWABLE_PIXMAP) &&
- /* special case root window bitmap */
- (pDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- stuff->x = orig_x - panoramiXdataPtr[j].x;
- stuff->y = orig_y - panoramiXdataPtr[j].y;
- }
}
- if (!j)
- noPanoramiXExtension = TRUE;
result = (*SavedProcVector[X_PolyText16])(client);
- noPanoramiXExtension = FALSE;
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
return (result);
}
-
int PanoramiXImageText8(ClientPtr client)
{
- int result, j;
- PanoramiXWindow *pPanoramiXRoot;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr pDraw;
- GCPtr pGC;
+ int result = 0, j;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
int orig_x, orig_y;
REQUEST(xImageTextReq);
- VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
- pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- pPanoramiXWin = pPanoramiXRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+ REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_ImageText8])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
orig_x = stuff->x;
orig_y = stuff->y;
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- if (pPanoramiXWin == pPanoramiXRoot) {
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ if (isRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
- }else {
- if ( (pDraw->type == DRAWABLE_PIXMAP) &&
- /* special case root window bitmap */
- (pDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- stuff->x = orig_x - panoramiXdataPtr[j].x;
- stuff->y = orig_y - panoramiXdataPtr[j].y;
- }
}
result = (*SavedProcVector[X_ImageText8])(client);
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
return (result);
}
@@ -2682,249 +2020,217 @@ int PanoramiXImageText8(ClientPtr client)
int PanoramiXImageText16(ClientPtr client)
{
- int result, j;
- PanoramiXWindow *pPanoramiXRoot;
- PanoramiXWindow *pPanoramiXWin;
- PanoramiXGC *pPanoramiXGC = PanoramiXGCRoot;
- DrawablePtr pDraw;
- GCPtr pGC;
+ int result = 0, j;
+ PanoramiXRes *gc, *draw;
+ Bool isRoot;
int orig_x, orig_y;
REQUEST(xImageTextReq);
- VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, pGC, client);
- pPanoramiXRoot = (pDraw->type == DRAWABLE_PIXMAP)
- ? PanoramiXPmapRoot : PanoramiXWinRoot;
- pPanoramiXWin = pPanoramiXRoot;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->drawable);
- IF_RETURN(!pPanoramiXWin, BadDrawable);
- PANORAMIXFIND_ID(pPanoramiXGC, stuff->gc);
- IF_RETURN(!pPanoramiXGC, BadGC);
+ REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars << 1);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(IS_SHARED_PIXMAP(draw))
+ return (*SavedProcVector[X_ImageText16])(client);
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
orig_x = stuff->x;
orig_y = stuff->y;
- FOR_NSCREENS_OR_ONCE((pPanoramiXWin && pPanoramiXGC), j) {
- stuff->drawable = pPanoramiXWin->info[j].id;
- stuff->gc = pPanoramiXGC->info[j].id;
- if (pPanoramiXWin == pPanoramiXRoot) {
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ if (isRoot) {
stuff->x = orig_x - panoramiXdataPtr[j].x;
stuff->y = orig_y - panoramiXdataPtr[j].y;
- }else {
- if ( (pDraw->type == DRAWABLE_PIXMAP) &&
- /* special case root window bitmap */
- (pDraw->width == (panoramiXdataPtr[PanoramiXNumScreens-1].x +
- panoramiXdataPtr[PanoramiXNumScreens-1].width)) ) {
- stuff->x = orig_x - panoramiXdataPtr[j].x;
- stuff->y = orig_y - panoramiXdataPtr[j].y;
- }
}
result = (*SavedProcVector[X_ImageText16])(client);
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
return (result);
}
-int PanoramiXCreateColormap(register ClientPtr client)
-{
- VisualPtr pVisual;
- ColormapPtr pmap;
- Colormap mid;
- register WindowPtr pWin;
- ScreenPtr pScreen;
- DepthPtr pDepth;
+int PanoramiXCreateColormap(ClientPtr client)
+{
+ PanoramiXRes *win, *newCmap;
+ int result = 0, j, orig_visual;
REQUEST(xCreateColormapReq);
- int i, result;
- int vid_index, class_index;
- int this_vid_index, this_class_index, this_depth;
- int j = 0;
- VisualID orig_visual;
- Colormap cmapID;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXCmap *localCmap;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
- short VisualClass;
- Bool ClassKnown;
- Bool FoundIt = FALSE;
-
REQUEST_SIZE_MATCH(xCreateColormapReq);
- mid = stuff->mid;
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->window, XRT_WINDOW, SecurityReadAccess)))
+ return BadWindow;
+
+ if(!stuff->visual || (stuff->visual > 255))
+ return BadValue;
+
+ if(!(newCmap = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+ return BadAlloc;
+
+ newCmap->type = XRT_COLORMAP;
+ newCmap->info[0].id = stuff->mid;
+ for(j = 1; j < PanoramiXNumScreens; j++)
+ newCmap->info[j].id = FakeClientID(client->index);
+
orig_visual = stuff->visual;
- j = 0;
- PANORAMIXFIND_ID(pPanoramiXWin, stuff->window);
- if (pPanoramiXWin) {
- localCmap = (PanoramiXCmap *)Xcalloc(sizeof(PanoramiXCmap));
- IF_RETURN(!localCmap, BadAlloc);
- } else {
- return BadWindow;
- }
- for (j = 0; j <= PanoramiXNumScreens - 1; j++) {
- cmapID = j ? FakeClientID(client->index) : mid;
- localCmap->info[j].id = cmapID;
- }
- localCmap->FreeMe = FALSE;
- PANORAMIXFIND_LAST(pPanoramiXCmap, PanoramiXCmapRoot);
- pPanoramiXCmap->next = localCmap;
-
- /* Use Screen 0 to get the matching Visual ID */
- pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
- SecurityReadAccess);
- if ( stuff->visual != CopyFromParent)
- {
- /* Find the correct visual for screen 0 */
- for (class_index = 0; class_index < PanoramiXColorDepthTable[0].numVisuals;
-class_index++)
- {
- for (j = 0; j < PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index
-].numDepths; j++ )
- {
- pDepth = (DepthPtr) &pWin->drawable.pScreen->allowedDepths[j];
- for (vid_index = 0; vid_index < PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index].vmap[pDepth->depth].numVids; vid_index++)
- {
- if ( stuff->visual == PanoramiXColorDepthTable[0].panoramiXScreenMap[class_index].vmap[pDepth->depth].vid[vid_index] )
- {
- this_class_index = class_index;
- this_vid_index = vid_index;
- this_depth = pDepth->depth;
- FoundIt = TRUE;
- break;
- }
- }
- }
- }
- }
- if (!pWin)
- return(BadWindow);
- pScreen = pWin->drawable.pScreen;
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin, j) {
- stuff->mid = localCmap->info[j].id;
- stuff->window = pPanoramiXWin->info[j].id;
- /* Look for the matching visual class, and use its
- visual id for creating this colormap. */
- if ( orig_visual != CopyFromParent && FoundIt )
- {
- stuff->visual = PanoramiXColorDepthTable[j].panoramiXScreenMap[this_class_index].vmap[this_depth].vid[this_vid_index];
- }
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->mid = newCmap->info[j].id;
+ stuff->window = win->info[j].id;
+ stuff->visual = PanoramiXVisualTable[(orig_visual * MAXSCREENS) + j];
result = (* SavedProcVector[X_CreateColormap])(client);
- BREAK_IF(result != Success);
- }
- if (result != Success) {
- pPanoramiXCmap->next = NULL ;
- if (localCmap)
- Xfree(localCmap);
+ if(result != Success) break;
}
+
+ if (result == Success)
+ AddResource(newCmap->info[0].id, XRT_COLORMAP, newCmap);
+ else
+ xfree(newCmap);
+
return (result);
}
int PanoramiXFreeColormap(ClientPtr client)
{
- ColormapPtr pmap;
+ PanoramiXRes *cmap;
+ int result = 0, j;
REQUEST(xResourceReq);
- int result, j;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
- PanoramiXCmap *pPanoramiXCmapback = NULL;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
REQUEST_SIZE_MATCH(xResourceReq);
- for (; pPanoramiXCmap && (pPanoramiXCmap->info[0].id != stuff->id);
- pPanoramiXCmap = pPanoramiXCmap->next)
- pPanoramiXCmapback = pPanoramiXCmap;
- IF_RETURN(!pPanoramiXCmap, BadColor);
- FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
- stuff->id = pPanoramiXCmap->info[j].id;
+ client->errorValue = stuff->id;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_COLORMAP, SecurityDestroyAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->id = cmap->info[j].id;
result = (* SavedProcVector[X_FreeColormap])(client);
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
- if ((result == Success) && pPanoramiXCmapback &&
- pPanoramiXCmap && pPanoramiXCmap->FreeMe) {
- pPanoramiXCmapback->next = pPanoramiXCmap->next;
- Xfree(pPanoramiXCmap);
+
+ /* Since ProcFreeColormap is using FreeResource, it will free
+ our resource for us on the last pass through the loop above */
+
+ return (result);
+}
+
+
+int
+PanoramiXCopyColormapAndFree(ClientPtr client)
+{
+ PanoramiXRes *cmap, *newCmap;
+ int result = 0, j;
+ REQUEST(xCopyColormapAndFreeReq);
+
+ REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);
+
+ client->errorValue = stuff->srcCmap;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->srcCmap, XRT_COLORMAP,
+ SecurityReadAccess | SecurityWriteAccess)))
+ return BadColor;
+
+ if(!(newCmap = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+ return BadAlloc;
+
+ newCmap->type = XRT_COLORMAP;
+ newCmap->info[0].id = stuff->mid;
+ for(j = 1; j < PanoramiXNumScreens; j++)
+ newCmap->info[j].id = FakeClientID(client->index);
+
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->srcCmap = cmap->info[j].id;
+ stuff->mid = newCmap->info[j].id;
+ result = (* SavedProcVector[X_CopyColormapAndFree])(client);
+ if(result != Success) break;
}
- PANORAMIX_FREE(client);
+
+ if (result == Success)
+ AddResource(newCmap->info[0].id, XRT_COLORMAP, newCmap);
+ else
+ xfree(newCmap);
+
return (result);
}
-int PanoramiXInstallColormap(register ClientPtr client)
+int PanoramiXInstallColormap(ClientPtr client)
{
- ColormapPtr pcmp;
REQUEST(xResourceReq);
- int result, j;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
+ int result = 0, j;
+ PanoramiXRes *cmap;
REQUEST_SIZE_MATCH(xResourceReq);
- PANORAMIXFIND_ID(pPanoramiXCmap, stuff->id);
- IF_RETURN(!pPanoramiXCmap, BadColor);
- FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
- stuff->id = pPanoramiXCmap->info[j].id;
+
+ client->errorValue = stuff->id;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_COLORMAP, SecurityReadAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->id = cmap->info[j].id;
result = (* SavedProcVector[X_InstallColormap])(client);
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
return (result);
}
-int PanoramiXUninstallColormap(register ClientPtr client)
+int PanoramiXUninstallColormap(ClientPtr client)
{
- ColormapPtr pcmp;
REQUEST(xResourceReq);
- int result, j;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
-
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
+ int result = 0, j;
+ PanoramiXRes *cmap;
REQUEST_SIZE_MATCH(xResourceReq);
- PANORAMIXFIND_ID(pPanoramiXCmap, stuff->id);
- IF_RETURN(!pPanoramiXCmap, BadColor);
- FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
- stuff->id = pPanoramiXCmap->info[j].id;
+
+ client->errorValue = stuff->id;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->id, XRT_COLORMAP, SecurityReadAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->id = cmap->info[j].id;
result = (* SavedProcVector[X_UninstallColormap])(client);
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
- PANORAMIX_FREE(client);
return (result);
}
int PanoramiXAllocColor(ClientPtr client)
{
- int result, j;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
+ int result = 0, j;
+ PanoramiXRes *cmap;
REQUEST(xAllocColorReq);
REQUEST_SIZE_MATCH(xAllocColorReq);
- PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
- if (!pPanoramiXCmap){
- noPanoramiXExtension = TRUE;
+
+ client->errorValue = stuff->cmap;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->cmap = cmap->info[j].id;
result = (* SavedProcVector[X_AllocColor])(client);
- noPanoramiXExtension = FALSE;
- }else {
- FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
- stuff->cmap = pPanoramiXCmap->info[j].id;
- if (!j)
- noPanoramiXExtension = TRUE;
- result = (* SavedProcVector[X_AllocColor])(client);
- noPanoramiXExtension = FALSE;
- BREAK_IF(result != Success);
- }
+ if(result != Success) break;
}
return (result);
}
@@ -2932,20 +2238,22 @@ int PanoramiXAllocColor(ClientPtr client)
int PanoramiXAllocNamedColor(ClientPtr client)
{
- int result, j;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
+ int result = 0, j;
+ PanoramiXRes *cmap;
REQUEST(xAllocNamedColorReq);
REQUEST_FIXED_SIZE(xAllocNamedColorReq, stuff->nbytes);
- PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
- IF_RETURN(!pPanoramiXCmap, BadColor);
- FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
- stuff->cmap = pPanoramiXCmap->info[j].id;
- if (!j)
- noPanoramiXExtension = TRUE;
+
+ client->errorValue = stuff->cmap;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->cmap = cmap->info[j].id;
result = (* SavedProcVector[X_AllocNamedColor])(client);
- noPanoramiXExtension = FALSE;
- BREAK_IF(result != Success);
+ if(result != Success) break;
}
return (result);
}
@@ -2953,82 +2261,114 @@ int PanoramiXAllocNamedColor(ClientPtr client)
int PanoramiXAllocColorCells(ClientPtr client)
{
- int result, j;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
+ int result = 0, j;
+ PanoramiXRes *cmap;
REQUEST(xAllocColorCellsReq);
REQUEST_SIZE_MATCH(xAllocColorCellsReq);
- PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
- if (!pPanoramiXCmap) {
- noPanoramiXExtension = TRUE;
+
+ client->errorValue = stuff->cmap;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->cmap = cmap->info[j].id;
result = (* SavedProcVector[X_AllocColorCells])(client);
- noPanoramiXExtension = FALSE;
- }else {
- FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
- stuff->cmap = pPanoramiXCmap->info[j].id;
- if (!j)
- noPanoramiXExtension = TRUE;
- result = (* SavedProcVector[X_AllocColorCells])(client);
- noPanoramiXExtension = FALSE;
- /* Because id's are eventually searched for in
- some client list, we don't check for success
- on fake id's last id will be real, we really
- only care about results related to real id's
- BREAK_IF(result != Success);
- */
- }
+ if(result != Success) break;
}
return (result);
}
-int PanoramiXFreeColors(register ClientPtr client)
+int PanoramiXAllocColorPlanes(ClientPtr client)
{
- int result, j;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
- REQUEST(xFreeColorsReq);
+ int result = 0, j;
+ PanoramiXRes *cmap;
+ REQUEST(xAllocColorPlanesReq);
- PanoramiXGC *pPanoramiXFreeGC;
- PanoramiXGC *pPanoramiXFreeGCback = NULL;
- PanoramiXWindow *pPanoramiXFreeWin;
- PanoramiXWindow *pPanoramiXFreeWinback = NULL;
- PanoramiXCmap *pPanoramiXFreeCmap;
- PanoramiXCmap *pPanoramiXFreeCmapback = NULL;
- PanoramiXPmap *pPanoramiXFreePmap;
- PanoramiXPmap *pPanoramiXFreePmapback = NULL;
+ REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
+
+ client->errorValue = stuff->cmap;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->cmap = cmap->info[j].id;
+ result = (* SavedProcVector[X_AllocColorPlanes])(client);
+ if(result != Success) break;
+ }
+ return (result);
+}
+
+
+
+int PanoramiXFreeColors(ClientPtr client)
+{
+ int result = 0, j;
+ PanoramiXRes *cmap;
+ REQUEST(xFreeColorsReq);
REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
- PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
- IF_RETURN(!pPanoramiXCmap, BadColor);
- FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
- stuff->cmap = pPanoramiXCmap->info[j].id;
+
+ client->errorValue = stuff->cmap;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j) {
+ stuff->cmap = cmap->info[j].id;
result = (* SavedProcVector[X_FreeColors])(client);
- /* Because id's are eventually searched for in
- some client list, we don't check for success
- on fake id's last id will be real, we really
- only care about results related to real id's */
}
- PANORAMIX_FREE(client);
return (result);
}
int PanoramiXStoreColors(ClientPtr client)
{
- int result, j;
- PanoramiXCmap *pPanoramiXCmap = PanoramiXCmapRoot;
+ int result = 0, j;
+ PanoramiXRes *cmap;
REQUEST(xStoreColorsReq);
REQUEST_AT_LEAST_SIZE(xStoreColorsReq);
- PANORAMIXFIND_ID(pPanoramiXCmap, stuff->cmap);
- if (!pPanoramiXCmap)
+
+ client->errorValue = stuff->cmap;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->cmap = cmap->info[j].id;
result = (* SavedProcVector[X_StoreColors])(client);
- else {
- FOR_NSCREENS_OR_ONCE(pPanoramiXCmap, j) {
- stuff->cmap = pPanoramiXCmap->info[j].id;
- result = (* SavedProcVector[X_StoreColors])(client);
- BREAK_IF(result != Success);
- }
+ if(result != Success) break;
+ }
+ return (result);
+}
+
+
+int PanoramiXStoreNamedColor(ClientPtr client)
+{
+ int result = 0, j;
+ PanoramiXRes *cmap;
+ REQUEST(xStoreNamedColorReq);
+
+ REQUEST_FIXED_SIZE(xStoreNamedColorReq, stuff->nbytes);
+
+ client->errorValue = stuff->cmap;
+
+ if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+ return BadColor;
+
+ FOR_NSCREENS_BACKWARD(j){
+ stuff->cmap = cmap->info[j].id;
+ result = (* SavedProcVector[X_StoreNamedColor])(client);
+ if(result != Success) break;
}
return (result);
}
diff --git a/Xext/security.c b/Xext/security.c
index c2db8f4dd..9af380dd6 100644
--- a/Xext/security.c
+++ b/Xext/security.c
@@ -24,6 +24,7 @@ used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group.
*/
+/* $XFree86: xc/programs/Xserver/Xext/security.c,v 1.11 2002/05/31 18:45:53 dawes Exp $ */
#include "dixstruct.h"
#include "extnsionst.h"
@@ -50,7 +51,7 @@ extern unsigned char LbxReqCode;
#ifndef DEFAULTPOLICYFILE
# define DEFAULTPOLICYFILE NULL
#endif
-#ifdef WIN32
+#if defined(WIN32) || defined(__CYGWIN__)
#include <X11/Xos.h>
#undef index
#endif
@@ -82,9 +83,6 @@ int (*SwappedUntrustedProcVector[256])(
#endif
);
-extern int ProcBadRequest();
-
-
/* SecurityAudit
*
* Arguments:
@@ -150,7 +148,7 @@ SecurityDeleteAuthorization(value, id)
/* send revoke events */
- while (pEventClient = pAuth->eventClients)
+ while ((pEventClient = pAuth->eventClients))
{
/* send revocation event event */
ClientPtr client = rClient(pEventClient);
@@ -318,7 +316,7 @@ static int
ProcSecurityQueryVersion(client)
ClientPtr client;
{
- REQUEST(xSecurityQueryVersionReq);
+ /* REQUEST(xSecurityQueryVersionReq); */
xSecurityQueryVersionReply rep;
/* paranoia: this "can't happen" because this extension is hidden
@@ -395,7 +393,6 @@ ProcSecurityGenerateAuthorization(client)
Bool removeAuth = FALSE; /* if bailout, call RemoveAuthorization? */
SecurityAuthorizationPtr pAuth = NULL; /* auth we are creating */
int err; /* error to return from this function */
- int status; /* return value from os functions */
XID authId; /* authorization ID assigned by os layer */
xSecurityGenerateAuthorizationReply rep; /* reply struct */
unsigned int trustLevel; /* trust level of new auth */
@@ -788,7 +785,7 @@ SecurityCheckDeviceAccess(client, dev, fromRequest)
Bool untrusted_got_event;
Bool found_event_window;
Mask eventmask;
- int reqtype;
+ int reqtype = 0;
/* trusted clients always allowed to do anything */
if (client->trustLevel == XSecurityClientTrusted)
@@ -1361,8 +1358,11 @@ SecurityFreePropertyAccessList()
}
} /* SecurityFreePropertyAccessList */
-
+#ifndef __UNIXOS2__
#define SecurityIsWhitespace(c) ( (c == ' ') || (c == '\t') || (c == '\n') )
+#else
+#define SecurityIsWhitespace(c) ( (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') )
+#endif
static char *
SecuritySkipWhitespace(p)
@@ -1441,7 +1441,6 @@ SecurityParsePropertyAccessRule(p)
char action = SecurityDefaultAction;
char readAction, writeAction, destroyAction;
PropertyAccessPtr pacl, prev, cur;
- ATOM atom;
char *mustHaveProperty = NULL;
char *mustHaveValue = NULL;
Bool invalid;
@@ -1641,7 +1640,11 @@ SecurityLoadPropertyAccessList()
if (!SecurityPolicyFile)
return;
+#ifndef __UNIXOS2__
f = fopen(SecurityPolicyFile, "r");
+#else
+ f = fopen((char*)__XOS2RedirRoot(SecurityPolicyFile), "r");
+#endif
if (!f)
{
ErrorF("error opening security policy file %s\n",
@@ -1969,7 +1972,7 @@ SecurityExtensionInit()
SecurityEventBase = extEntry->eventBase;
EventSwapVector[SecurityEventBase + XSecurityAuthorizationRevoked] =
- SwapSecurityAuthorizationRevokedEvent;
+ (EventSwapPtr)SwapSecurityAuthorizationRevokedEvent;
/* initialize untrusted proc vectors */
diff --git a/Xext/shape.c b/Xext/shape.c
index bff7d2502..7bd161dcc 100644
--- a/Xext/shape.c
+++ b/Xext/shape.c
@@ -1,3 +1,4 @@
+/* $XFree86: xc/programs/Xserver/Xext/shape.c,v 3.16 2001/12/14 19:58:50 dawes Exp $ */
/************************************************************
Copyright 1989, 1998 The Open Group
@@ -27,7 +28,6 @@ in this Software without prior written authorization from The Open Group.
/* $Xorg: shape.c,v 1.4 2001/02/09 02:04:32 xorgcvs Exp $ */
#define NEED_REPLIES
#define NEED_EVENTS
-#include <stdio.h>
#include "X.h"
#include "Xproto.h"
#include "misc.h"
@@ -43,26 +43,101 @@ in this Software without prior written authorization from The Open Group.
#include "shapestr.h"
#include "regionstr.h"
#include "gcstruct.h"
+#ifdef EXTMODULE
+#include "xf86_ansic.h"
+#endif
+
+typedef RegionPtr (*CreateDftPtr)(
+#if NeedNestedPrototypes
+ WindowPtr /* pWin */
+#endif
+ );
+
+static int ShapeFreeClient(
+#if NeedFunctionPrototypes
+ pointer /* data */,
+ XID /* id */
+#endif
+ );
+static int ShapeFreeEvents(
+#if NeedFunctionPrototypes
+ pointer /* data */,
+ XID /* id */
+#endif
+ );
+static void SendShapeNotify(
+#if NeedFunctionPrototypes
+ WindowPtr /* pWin */,
+ int /* which */
+#endif
+ );
+static void ShapeResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* extEntry */
+#endif
+ );
+static void SShapeNotifyEvent(
+#if NeedFunctionPrototypes
+ xShapeNotifyEvent * /* from */,
+ xShapeNotifyEvent * /* to */
+#endif
+ );
+static int
+RegionOperate (
+#if NeedFunctionPrototypes
+ ClientPtr /* client */,
+ WindowPtr /* pWin */,
+ int /* kind */,
+ RegionPtr * /* destRgnp */,
+ RegionPtr /* srcRgn */,
+ int /* op */,
+ int /* xoff */,
+ int /* yoff */,
+ CreateDftPtr /* create */
+#endif
+ );
+
+#if NeedFunctionPrototypes
+#define CREATE_PROC(func) RegionPtr func(WindowPtr /* pWin */)
+#else
+#define CREATE_PROC(func) RegionPtr func(/* WindowPtr pWin */)
+#endif
+
+static CREATE_PROC(CreateBoundingShape);
+static CREATE_PROC(CreateClipShape);
+
+#undef CREATE_PROC
+
+static DISPATCH_PROC(ProcShapeCombine);
+static DISPATCH_PROC(ProcShapeDispatch);
+static DISPATCH_PROC(ProcShapeGetRectangles);
+static DISPATCH_PROC(ProcShapeInputSelected);
+static DISPATCH_PROC(ProcShapeMask);
+static DISPATCH_PROC(ProcShapeOffset);
+static DISPATCH_PROC(ProcShapeQueryExtents);
+static DISPATCH_PROC(ProcShapeQueryVersion);
+static DISPATCH_PROC(ProcShapeRectangles);
+static DISPATCH_PROC(ProcShapeSelectInput);
+static DISPATCH_PROC(SProcShapeCombine);
+static DISPATCH_PROC(SProcShapeDispatch);
+static DISPATCH_PROC(SProcShapeGetRectangles);
+static DISPATCH_PROC(SProcShapeInputSelected);
+static DISPATCH_PROC(SProcShapeMask);
+static DISPATCH_PROC(SProcShapeOffset);
+static DISPATCH_PROC(SProcShapeQueryExtents);
+static DISPATCH_PROC(SProcShapeQueryVersion);
+static DISPATCH_PROC(SProcShapeRectangles);
+static DISPATCH_PROC(SProcShapeSelectInput);
#ifdef PANORAMIX
#include "panoramiX.h"
+#include "panoramiXsrv.h"
#endif
-static int ShapeFreeClient(), ShapeFreeEvents();
-static void SendShapeNotify();
-static int ProcShapeDispatch(), SProcShapeDispatch();
-static void ShapeResetProc(), SShapeNotifyEvent();
-
static unsigned char ShapeReqCode = 0;
static int ShapeEventBase = 0;
static RESTYPE ClientType, EventType; /* resource types for event masks */
-#ifdef PANORAMIX
-extern int PanoramiXNumScreens;
-extern Bool noPanoramiXExtension;
-extern PanoramiXWindow *PanoramiXWinRoot;
-extern PanoramiXPmap *PanoramiXPmapRoot;
-#endif
/*
* each window has a list of clients requesting
* ShapeNotify events. Each client has a resource
@@ -91,7 +166,7 @@ typedef struct _ShapeEvent {
void
ShapeExtensionInit()
{
- ExtensionEntry *extEntry, *AddExtension();
+ ExtensionEntry *extEntry;
ClientType = CreateNewResourceType(ShapeFreeClient);
EventType = CreateNewResourceType(ShapeFreeEvents);
@@ -102,7 +177,7 @@ ShapeExtensionInit()
{
ShapeReqCode = (unsigned char)extEntry->base;
ShapeEventBase = extEntry->eventBase;
- EventSwapVector[ShapeEventBase] = SShapeNotifyEvent;
+ EventSwapVector[ShapeEventBase] = (EventSwapPtr) SShapeNotifyEvent;
}
}
@@ -113,7 +188,7 @@ ExtensionEntry *extEntry;
{
}
-static
+static int
RegionOperate (client, pWin, kind, destRgnp, srcRgn, op, xoff, yoff, create)
ClientPtr client;
WindowPtr pWin;
@@ -121,7 +196,7 @@ RegionOperate (client, pWin, kind, destRgnp, srcRgn, op, xoff, yoff, create)
RegionPtr *destRgnp, srcRgn;
int op;
int xoff, yoff;
- RegionPtr (*create)(); /* creates a reasonable *destRgnp */
+ CreateDftPtr create; /* creates a reasonable *destRgnp */
{
ScreenPtr pScreen = pWin->drawable.pScreen;
@@ -133,7 +208,31 @@ RegionOperate (client, pWin, kind, destRgnp, srcRgn, op, xoff, yoff, create)
REGION_DESTROY(pScreen, srcRgn);
return Success;
}
- switch (op) {
+
+ /* May/30/2001:
+ * The shape.PS specs say if src is None, existing shape is to be
+ * removed (and so the op-code has no meaning in such removal);
+ * see shape.PS, page 3, ShapeMask.
+ */
+ if (srcRgn == NULL) {
+ if (*destRgnp != NULL) {
+ REGION_DESTROY (pScreen, *destRgnp);
+ *destRgnp = 0;
+ /* go on to remove shape and generate ShapeNotify */
+ }
+ else {
+ /* May/30/2001:
+ * The target currently has no shape in effect, so nothing to
+ * do here. The specs say that ShapeNotify is generated whenever
+ * the client region is "modified"; since no modification is done
+ * here, we do not generate that event. The specs does not say
+ * "it is an error to request removal when there is no shape in
+ * effect", so we return good status.
+ */
+ return Success;
+ }
+ }
+ else switch (op) {
case ShapeSet:
if (*destRgnp)
REGION_DESTROY(pScreen, *destRgnp);
@@ -204,7 +303,6 @@ static int
ProcShapeQueryVersion (client)
register ClientPtr client;
{
- REQUEST(xShapeQueryVersionReq);
xShapeQueryVersionReply rep;
register int n;
@@ -228,42 +326,8 @@ ProcShapeQueryVersion (client)
* ProcShapeRectangles
*
*****************/
-#ifdef PANORAMIX
-static int
-ProcPanoramiXShapeRectangles (client)
- register ClientPtr client;
-{
- WindowPtr pWin;
- ScreenPtr pScreen;
- REQUEST(xShapeRectanglesReq);
- xRectangle *prects;
- int nrects, ctype;
- RegionPtr srcRgn;
- RegionPtr *destRgn;
- RegionPtr (*createDefault)();
- int destBounding;
-
- register int result;
- int j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
-
- REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
- PANORAMIXFIND_ID(pPanoramiXWin,stuff->dest);
- IF_RETURN(!pPanoramiXWin, BadRequest);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin , j) {
- stuff->dest = pPanoramiXWin->info[j].id;
- result = ProcShapeRectangles (client);
- BREAK_IF(result != Success);
- }
- return (result);
-}
-#endif
-#ifdef PANORAMIX
-int
-#else
static int
-#endif
ProcShapeRectangles (client)
register ClientPtr client;
{
@@ -274,7 +338,7 @@ ProcShapeRectangles (client)
int nrects, ctype;
RegionPtr srcRgn;
RegionPtr *destRgn;
- RegionPtr (*createDefault)();
+ CreateDftPtr createDefault;
int destBounding;
REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
@@ -324,49 +388,37 @@ ProcShapeRectangles (client)
stuff->xOff, stuff->yOff, createDefault);
}
-/**************
- * ProcShapeMask
- **************/
-
#ifdef PANORAMIX
static int
-ProcPanoramiXShapeMask (client)
+ProcPanoramiXShapeRectangles (client)
register ClientPtr client;
{
- WindowPtr pWin;
- ScreenPtr pScreen;
- REQUEST(xShapeMaskReq);
- RegionPtr srcRgn;
- RegionPtr *destRgn;
- PixmapPtr pPixmap;
- RegionPtr (*createDefault)();
- int destBounding;
+ REQUEST(xShapeRectanglesReq);
+ PanoramiXRes *win;
+ int j, result = 0;
- register int result;
- int j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
- PanoramiXPmap *pPmap = PanoramiXPmapRoot;
+ REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
- REQUEST_SIZE_MATCH (xShapeMaskReq);
- PANORAMIXFIND_ID(pPanoramiXWin,stuff->dest);
- IF_RETURN(!pPanoramiXWin, BadRequest);
- PANORAMIXFIND_ID(pPmap, stuff->src);
- IF_RETURN(!pPmap, BadRequest);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin , j) {
- stuff->dest = pPanoramiXWin->info[j].id;
- stuff->src = pPmap->info[j].id;
- result = ProcShapeMask (client);
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS(j) {
+ stuff->dest = win->info[j].id;
+ result = ProcShapeRectangles (client);
BREAK_IF(result != Success);
}
return (result);
}
#endif
-#ifdef PANORAMIX
-int
-#else
+
+/**************
+ * ProcShapeMask
+ **************/
+
+
static int
-#endif
ProcShapeMask (client)
register ClientPtr client;
{
@@ -376,7 +428,7 @@ ProcShapeMask (client)
RegionPtr srcRgn;
RegionPtr *destRgn;
PixmapPtr pPixmap;
- RegionPtr (*createDefault)();
+ CreateDftPtr createDefault;
int destBounding;
REQUEST_SIZE_MATCH (xShapeMaskReq);
@@ -425,45 +477,45 @@ ProcShapeMask (client)
stuff->xOff, stuff->yOff, createDefault);
}
-/************
- * ProcShapeCombine
- ************/
#ifdef PANORAMIX
static int
-ProcPanoramiXShapeCombine (client)
+ProcPanoramiXShapeMask (client)
register ClientPtr client;
{
- WindowPtr pSrcWin, pDestWin;
- ScreenPtr pScreen;
- REQUEST(xShapeCombineReq);
- RegionPtr srcRgn;
- RegionPtr *destRgn;
- RegionPtr (*createDefault)();
- RegionPtr (*createSrc)();
- RegionPtr tmp;
- int destBounding;
+ REQUEST(xShapeMaskReq);
+ PanoramiXRes *win, *pmap;
+ int j, result = 0;
- register int result;
- int j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
+ REQUEST_SIZE_MATCH (xShapeMaskReq);
- REQUEST_AT_LEAST_SIZE (xShapeCombineReq);
- PANORAMIXFIND_ID(pPanoramiXWin,stuff->dest);
- IF_RETURN(!pPanoramiXWin, BadRequest);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin , j) {
- stuff->dest = pPanoramiXWin->info[j].id;
- result = ProcShapeCombine (client);
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ if(stuff->src != None) {
+ if(!(pmap = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->src, XRT_PIXMAP, SecurityReadAccess)))
+ return BadPixmap;
+ } else
+ pmap = NULL;
+
+ FOR_NSCREENS(j) {
+ stuff->dest = win->info[j].id;
+ if(pmap)
+ stuff->src = pmap->info[j].id;
+ result = ProcShapeMask (client);
BREAK_IF(result != Success);
}
return (result);
}
#endif
-#ifdef PANORAMIX
-int
-#else
+
+/************
+ * ProcShapeCombine
+ ************/
+
static int
-#endif
ProcShapeCombine (client)
register ClientPtr client;
{
@@ -472,8 +524,8 @@ ProcShapeCombine (client)
REQUEST(xShapeCombineReq);
RegionPtr srcRgn;
RegionPtr *destRgn;
- RegionPtr (*createDefault)();
- RegionPtr (*createSrc)();
+ CreateDftPtr createDefault;
+ CreateDftPtr createSrc;
RegionPtr tmp;
int destBounding;
@@ -539,40 +591,41 @@ ProcShapeCombine (client)
stuff->xOff, stuff->yOff, createDefault);
}
-/*************
- * ProcShapeOffset
- *************/
+
#ifdef PANORAMIX
static int
-ProcPanoramiXShapeOffset (client)
+ProcPanoramiXShapeCombine (client)
register ClientPtr client;
{
- WindowPtr pWin;
- ScreenPtr pScreen;
- REQUEST(xShapeOffsetReq);
- RegionPtr srcRgn;
+ REQUEST(xShapeCombineReq);
+ PanoramiXRes *win, *win2;
+ int j, result = 0;
+
+ REQUEST_AT_LEAST_SIZE (xShapeCombineReq);
- register int result;
- int j;
- PanoramiXWindow *pPanoramiXWin = PanoramiXWinRoot;
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
- REQUEST_AT_LEAST_SIZE (xShapeOffsetReq);
- PANORAMIXFIND_ID(pPanoramiXWin,stuff->dest);
- IF_RETURN(!pPanoramiXWin, BadRequest);
- FOR_NSCREENS_OR_ONCE(pPanoramiXWin , j) {
- stuff->dest = pPanoramiXWin->info[j].id;
- result = ProcShapeOffset (client);
+ if(!(win2 = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->src, XRT_WINDOW, SecurityReadAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS(j) {
+ stuff->dest = win->info[j].id;
+ stuff->src = win2->info[j].id;
+ result = ProcShapeCombine (client);
BREAK_IF(result != Success);
}
return (result);
}
#endif
-#ifdef PANORAMIX
-int
-#else
+/*************
+ * ProcShapeOffset
+ *************/
+
static int
-#endif
ProcShapeOffset (client)
register ClientPtr client;
{
@@ -607,6 +660,32 @@ ProcShapeOffset (client)
return Success;
}
+
+#ifdef PANORAMIX
+static int
+ProcPanoramiXShapeOffset (client)
+ register ClientPtr client;
+{
+ REQUEST(xShapeOffsetReq);
+ PanoramiXRes *win;
+ int j, result = 0;
+
+ REQUEST_AT_LEAST_SIZE (xShapeOffsetReq);
+
+ if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
+ return BadWindow;
+
+ FOR_NSCREENS(j) {
+ stuff->dest = win->info[j].id;
+ result = ProcShapeOffset (client);
+ if(result != Success) break;
+ }
+ return (result);
+}
+#endif
+
+
static int
ProcShapeQueryExtents (client)
register ClientPtr client;
@@ -616,6 +695,7 @@ ProcShapeQueryExtents (client)
xShapeQueryExtentsReply rep;
BoxRec extents, *pExtents;
register int n;
+ RegionPtr region;
REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);
pWin = LookupWindow (stuff->window, client);
@@ -626,9 +706,9 @@ ProcShapeQueryExtents (client)
rep.sequenceNumber = client->sequence;
rep.boundingShaped = (wBoundingShape(pWin) != 0);
rep.clipShaped = (wClipShape(pWin) != 0);
- if (wBoundingShape(pWin)) {
+ if ((region = wBoundingShape(pWin))) {
/* this is done in two steps because of a compiler bug on SunOS 4.1.3 */
- pExtents = REGION_EXTENTS(pWin->drawable.pScreen, wBoundingShape(pWin));
+ pExtents = REGION_EXTENTS(pWin->drawable.pScreen, region);
extents = *pExtents;
} else {
extents.x1 = -wBorderWidth (pWin);
@@ -640,9 +720,9 @@ ProcShapeQueryExtents (client)
rep.yBoundingShape = extents.y1;
rep.widthBoundingShape = extents.x2 - extents.x1;
rep.heightBoundingShape = extents.y2 - extents.y1;
- if (wClipShape(pWin)) {
+ if ((region = wClipShape(pWin))) {
/* this is done in two steps because of a compiler bug on SunOS 4.1.3 */
- pExtents = REGION_EXTENTS(pWin->drawable.pScreen, wClipShape(pWin));
+ pExtents = REGION_EXTENTS(pWin->drawable.pScreen, region);
extents = *pExtents;
} else {
extents.x1 = 0;
@@ -1001,37 +1081,29 @@ ProcShapeDispatch (client)
if ( !noPanoramiXExtension )
return ProcPanoramiXShapeRectangles (client);
else
- return ProcShapeRectangles (client);
-#else
- return ProcShapeRectangles (client);
#endif
+ return ProcShapeRectangles (client);
case X_ShapeMask:
#ifdef PANORAMIX
if ( !noPanoramiXExtension )
return ProcPanoramiXShapeMask (client);
else
- return ProcShapeMask (client);
-#else
- return ProcShapeMask (client);
#endif
+ return ProcShapeMask (client);
case X_ShapeCombine:
#ifdef PANORAMIX
if ( !noPanoramiXExtension )
return ProcPanoramiXShapeCombine (client);
else
- return ProcShapeCombine (client);
-#else
- return ProcShapeCombine (client);
#endif
+ return ProcShapeCombine (client);
case X_ShapeOffset:
#ifdef PANORAMIX
if ( !noPanoramiXExtension )
return ProcPanoramiXShapeOffset (client);
else
- return ProcShapeOffset (client);
-#else
- return ProcShapeOffset (client);
#endif
+ return ProcShapeOffset (client);
case X_ShapeQueryExtents:
return ProcShapeQueryExtents (client);
case X_ShapeSelectInput:
diff --git a/Xext/shm.c b/Xext/shm.c
index 0a9f3af59..3ba9ad2c1 100644
--- a/Xext/shm.c
+++ b/Xext/shm.c
@@ -1,3 +1,4 @@
+/* $XFree86: xc/programs/Xserver/Xext/shm.c,v 3.36 2002/04/03 19:51:11 herrb Exp $ */
/************************************************************
Copyright 1989, 1998 The Open Group
@@ -29,8 +30,15 @@ in this Software without prior written authorization from The Open Group.
/* $Xorg: shm.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
#include <sys/types.h>
+#ifndef Lynx
#include <sys/ipc.h>
#include <sys/shm.h>
+#else
+#include <ipc.h>
+#include <shm.h>
+#endif
+#include <unistd.h>
+#include <sys/stat.h>
#define NEED_REPLIES
#define NEED_EVENTS
#include "X.h"
@@ -48,6 +56,14 @@ in this Software without prior written authorization from The Open Group.
#define _XSHM_SERVER_
#include "shmstr.h"
#include "Xfuncproto.h"
+#ifdef EXTMODULE
+#include "xf86_ansic.h"
+#endif
+
+#ifdef PANORAMIX
+#include "panoramiX.h"
+#include "panoramiXsrv.h"
+#endif
typedef struct _ShmDesc {
struct _ShmDesc *next;
@@ -58,21 +74,57 @@ typedef struct _ShmDesc {
unsigned long size;
} ShmDescRec, *ShmDescPtr;
-static void miShmPutImage(), fbShmPutImage();
-static PixmapPtr fbShmCreatePixmap();
-static int ProcShmDispatch(), SProcShmDispatch();
-static int ShmDetachSegment();
-static void ShmResetProc(), SShmCompletionEvent();
+static void miShmPutImage(XSHM_PUT_IMAGE_ARGS);
+static void fbShmPutImage(XSHM_PUT_IMAGE_ARGS);
+static PixmapPtr fbShmCreatePixmap(XSHM_CREATE_PIXMAP_ARGS);
+static int ShmDetachSegment(
+#if NeedFunctionPrototypes
+ pointer /* value */,
+ XID /* shmseg */
+#endif
+ );
+static void ShmResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* extEntry */
+#endif
+ );
+static void SShmCompletionEvent(
+#if NeedFunctionPrototypes
+ xShmCompletionEvent * /* from */,
+ xShmCompletionEvent * /* to */
+#endif
+ );
+
+static Bool ShmDestroyPixmap (PixmapPtr pPixmap);
+
+static DISPATCH_PROC(ProcShmAttach);
+static DISPATCH_PROC(ProcShmCreatePixmap);
+static DISPATCH_PROC(ProcShmDetach);
+static DISPATCH_PROC(ProcShmDispatch);
+static DISPATCH_PROC(ProcShmGetImage);
+static DISPATCH_PROC(ProcShmPutImage);
+static DISPATCH_PROC(ProcShmQueryVersion);
+static DISPATCH_PROC(SProcShmAttach);
+static DISPATCH_PROC(SProcShmCreatePixmap);
+static DISPATCH_PROC(SProcShmDetach);
+static DISPATCH_PROC(SProcShmDispatch);
+static DISPATCH_PROC(SProcShmGetImage);
+static DISPATCH_PROC(SProcShmPutImage);
+static DISPATCH_PROC(SProcShmQueryVersion);
static unsigned char ShmReqCode;
-static int ShmCompletionCode;
-static int BadShmSegCode;
-static RESTYPE ShmSegType, ShmPixType;
+int ShmCompletionCode;
+int BadShmSegCode;
+RESTYPE ShmSegType;
static ShmDescPtr Shmsegs;
static Bool sharedPixmaps;
static int pixmapFormat;
static int shmPixFormat[MAXSCREENS];
static ShmFuncsPtr shmFuncs[MAXSCREENS];
+static DestroyPixmapProcPtr destroyPixmap[MAXSCREENS];
+#ifdef PIXPRIV
+static int shmPixmapPrivate;
+#endif
static ShmFuncs miFuncs = {NULL, miShmPutImage};
static ShmFuncs fbFuncs = {fbShmCreatePixmap, fbShmPutImage};
@@ -106,20 +158,60 @@ static ShmFuncs fbFuncs = {fbShmCreatePixmap, fbShmPutImage};
} \
}
+
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/signal.h>
+
+static Bool badSysCall = FALSE;
+
+static void
+SigSysHandler(signo)
+int signo;
+{
+ badSysCall = TRUE;
+}
+
+static Bool CheckForShmSyscall()
+{
+ void (*oldHandler)();
+ int shmid = -1;
+
+ /* If no SHM support in the kernel, the bad syscall will generate SIGSYS */
+ oldHandler = signal(SIGSYS, SigSysHandler);
+
+ badSysCall = FALSE;
+ shmid = shmget(IPC_PRIVATE, 4096, IPC_CREAT);
+ /* Clean up */
+ if (shmid != -1)
+ {
+ shmctl(shmid, IPC_RMID, (struct shmid_ds *)NULL);
+ }
+ signal(SIGSYS, oldHandler);
+ return(!badSysCall);
+}
+#endif
+
void
ShmExtensionInit()
{
ExtensionEntry *extEntry;
int i;
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+ if (!CheckForShmSyscall())
+ {
+ ErrorF("MIT-SHM extension disabled due to lack of kernel support\n");
+ return;
+ }
+#endif
+
sharedPixmaps = xFalse;
pixmapFormat = 0;
-#else
- sharedPixmaps = xTrue;
- pixmapFormat = shmPixFormat[0];
- for (i = 0; i < screenInfo.numScreens; i++)
{
+ sharedPixmaps = xTrue;
+ pixmapFormat = shmPixFormat[0];
+ for (i = 0; i < screenInfo.numScreens; i++)
+ {
if (!shmFuncs[i])
shmFuncs[i] = &miFuncs;
if (!shmFuncs[i]->CreatePixmap)
@@ -129,13 +221,29 @@ ShmExtensionInit()
sharedPixmaps = xFalse;
pixmapFormat = 0;
}
- }
- if (!pixmapFormat)
+ }
+ if (!pixmapFormat)
pixmapFormat = ZPixmap;
+ if (sharedPixmaps)
+ {
+ for (i = 0; i < screenInfo.numScreens; i++)
+ {
+ destroyPixmap[i] = screenInfo.screens[i]->DestroyPixmap;
+ screenInfo.screens[i]->DestroyPixmap = ShmDestroyPixmap;
+ }
+#ifdef PIXPRIV
+ shmPixmapPrivate = AllocatePixmapPrivateIndex();
+ for (i = 0; i < screenInfo.numScreens; i++)
+ {
+ if (!AllocatePixmapPrivate(screenInfo.screens[i],
+ shmPixmapPrivate, 0))
+ return;
+ }
#endif
+ }
+ }
ShmSegType = CreateNewResourceType(ShmDetachSegment);
- ShmPixType = CreateNewResourceType(ShmDetachSegment);
- if (ShmSegType && ShmPixType &&
+ if (ShmSegType &&
(extEntry = AddExtension(SHMNAME, ShmNumberEvents, ShmNumberErrors,
ProcShmDispatch, SProcShmDispatch,
ShmResetProc, StandardMinorOpcode)))
@@ -143,7 +251,7 @@ ShmExtensionInit()
ShmReqCode = (unsigned char)extEntry->base;
ShmCompletionCode = extEntry->eventBase;
BadShmSegCode = extEntry->errorBase;
- EventSwapVector[ShmCompletionCode] = SShmCompletionEvent;
+ EventSwapVector[ShmCompletionCode] = (EventSwapPtr) SShmCompletionEvent;
}
}
@@ -177,6 +285,41 @@ ShmSetPixmapFormat(pScreen, format)
shmPixFormat[pScreen->myNum] = format;
}
+static Bool
+ShmDestroyPixmap (PixmapPtr pPixmap)
+{
+ ScreenPtr pScreen = pPixmap->drawable.pScreen;
+ Bool ret;
+ if (pPixmap->refcnt == 1)
+ {
+ ShmDescPtr shmdesc;
+#ifdef PIXPRIV
+ shmdesc = (ShmDescPtr) pPixmap->devPrivates[shmPixmapPrivate].ptr;
+#else
+ char *base = (char *) pPixmap->devPrivate.ptr;
+
+ if (base != (pointer) (pPixmap + 1))
+ {
+ for (shmdesc = Shmsegs; shmdesc; shmdesc = shmdesc->next)
+ {
+ if (shmdesc->addr <= base && base <= shmdesc->addr + shmdesc->size)
+ break;
+ }
+ }
+ else
+ shmdesc = 0;
+#endif
+ if (shmdesc)
+ ShmDetachSegment ((pointer) shmdesc, pPixmap->drawable.id);
+ }
+
+ pScreen->DestroyPixmap = destroyPixmap[pScreen->myNum];
+ ret = (*pScreen->DestroyPixmap) (pPixmap);
+ destroyPixmap[pScreen->myNum] = pScreen->DestroyPixmap;
+ pScreen->DestroyPixmap = ShmDestroyPixmap;
+ return ret;
+}
+
void
ShmRegisterFbFuncs(pScreen)
ScreenPtr pScreen;
@@ -188,7 +331,6 @@ static int
ProcShmQueryVersion(client)
register ClientPtr client;
{
- REQUEST(xShmQueryVersionReq);
xShmQueryVersionReply rep;
register int n;
@@ -214,6 +356,47 @@ ProcShmQueryVersion(client)
return (client->noClientException);
}
+/*
+ * Simulate the access() system call for a shared memory segement,
+ * using the credentials from the client if available
+ */
+static int
+shm_access(ClientPtr client, struct ipc_perm *perm, int readonly)
+{
+ int uid, gid;
+ mode_t mask;
+
+ if (LocalClientCred(client, &uid, &gid) != -1) {
+
+ /* User id 0 always gets access */
+ if (uid == 0) {
+ return 0;
+ }
+ /* Check the owner */
+ if (perm->uid == uid || perm->cuid == uid) {
+ mask = S_IRUSR;
+ if (!readonly) {
+ mask |= S_IWUSR;
+ }
+ return (perm->mode & mask) == mask ? 0 : -1;
+ }
+ /* Check the group */
+ if (perm->gid == gid || perm->cgid == gid) {
+ mask = S_IRGRP;
+ if (!readonly) {
+ mask |= S_IWGRP;
+ }
+ return (perm->mode & mask) == mask ? 0 : -1;
+ }
+ }
+ /* Otherwise, check everyone else */
+ mask = S_IROTH;
+ if (!readonly) {
+ mask |= S_IWOTH;
+ }
+ return (perm->mode & mask) == mask ? 0 : -1;
+}
+
static int
ProcShmAttach(client)
register ClientPtr client;
@@ -252,6 +435,17 @@ ProcShmAttach(client)
xfree(shmdesc);
return BadAccess;
}
+
+ /* The attach was performed with root privs. We must
+ * do manual checking of access rights for the credentials
+ * of the client */
+
+ if (shm_access(client, &(buf.shm_perm), stuff->readOnly) == -1) {
+ shmdt(shmdesc->addr);
+ xfree(shmdesc);
+ return BadAccess;
+ }
+
shmdesc->shmid = stuff->shmid;
shmdesc->refcnt = 1;
shmdesc->writable = !stuff->readOnly;
@@ -342,7 +536,7 @@ fbShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
PixmapPtr pPixmap;
pPixmap = GetScratchPixmapHeader(dst->pScreen, w, h, depth,
- /*XXX*/depth, PixmapBytePad(w, depth), (pointer)data);
+ BitsPerPixel(depth), PixmapBytePad(w, depth), (pointer)data);
if (!pPixmap)
return;
if (format == XYBitmap)
@@ -358,6 +552,251 @@ fbShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
data);
}
+
+#ifdef PANORAMIX
+static int
+ProcPanoramiXShmPutImage(register ClientPtr client)
+{
+ int j, result = 0, orig_x, orig_y;
+ PanoramiXRes *draw, *gc;
+ Bool sendEvent, isRoot;
+
+ REQUEST(xShmPutImageReq);
+ REQUEST_SIZE_MATCH(xShmPutImageReq);
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
+ client, stuff->gc, XRT_GC, SecurityReadAccess)))
+ return BadGC;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
+ orig_x = stuff->dstX;
+ orig_y = stuff->dstY;
+ sendEvent = stuff->sendEvent;
+ stuff->sendEvent = 0;
+ FOR_NSCREENS(j) {
+ if(!j) stuff->sendEvent = sendEvent;
+ stuff->drawable = draw->info[j].id;
+ stuff->gc = gc->info[j].id;
+ if (isRoot) {
+ stuff->dstX = orig_x - panoramiXdataPtr[j].x;
+ stuff->dstY = orig_y - panoramiXdataPtr[j].y;
+ }
+ result = ProcShmPutImage(client);
+ if(result != client->noClientException) break;
+ }
+ return(result);
+}
+
+static int
+ProcPanoramiXShmGetImage(ClientPtr client)
+{
+ PanoramiXRes *draw;
+ DrawablePtr drawables[MAXSCREENS];
+ DrawablePtr pDraw;
+ xShmGetImageReply xgi;
+ ShmDescPtr shmdesc;
+ int i, x, y, w, h, format;
+ Mask plane = 0, planemask;
+ long lenPer = 0, length, widthBytesLine;
+ Bool isRoot;
+
+ REQUEST(xShmGetImageReq);
+
+ REQUEST_SIZE_MATCH(xShmGetImageReq);
+
+ if ((stuff->format != XYPixmap) && (stuff->format != ZPixmap)) {
+ client->errorValue = stuff->format;
+ return(BadValue);
+ }
+
+ if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+ client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+ return BadDrawable;
+
+ if (draw->type == XRT_PIXMAP)
+ return ProcShmGetImage(client);
+
+ VERIFY_DRAWABLE(pDraw, stuff->drawable, client);
+
+ VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
+
+ x = stuff->x;
+ y = stuff->y;
+ w = stuff->width;
+ h = stuff->height;
+ format = stuff->format;
+ planemask = stuff->planeMask;
+
+ isRoot = (draw->type == XRT_WINDOW) &&
+ (stuff->drawable == WindowTable[0]->drawable.id);
+
+ if(isRoot) {
+ if( /* check for being onscreen */
+ x < 0 || x + w > PanoramiXPixWidth ||
+ y < 0 || y + h > PanoramiXPixHeight )
+ return(BadMatch);
+ } else {
+ if( /* check for being onscreen */
+ panoramiXdataPtr[0].x + pDraw->x + x < 0 ||
+ panoramiXdataPtr[0].x + pDraw->x + x + w > PanoramiXPixWidth ||
+ panoramiXdataPtr[0].y + pDraw->y + y < 0 ||
+ panoramiXdataPtr[0].y + pDraw->y + y + h > PanoramiXPixHeight ||
+ /* check for being inside of border */
+ x < - wBorderWidth((WindowPtr)pDraw) ||
+ x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
+ y < -wBorderWidth((WindowPtr)pDraw) ||
+ y + h > wBorderWidth ((WindowPtr)pDraw) + (int)pDraw->height)
+ return(BadMatch);
+ }
+
+ drawables[0] = pDraw;
+ for(i = 1; i < PanoramiXNumScreens; i++)
+ VERIFY_DRAWABLE(drawables[i], draw->info[i].id, client);
+
+ xgi.visual = wVisual(((WindowPtr)pDraw));
+ xgi.type = X_Reply;
+ xgi.length = 0;
+ xgi.sequenceNumber = client->sequence;
+ xgi.depth = pDraw->depth;
+
+ if(format == ZPixmap) {
+ widthBytesLine = PixmapBytePad(w, pDraw->depth);
+ length = widthBytesLine * h;
+ } else {
+ widthBytesLine = PixmapBytePad(w, 1);
+ lenPer = widthBytesLine * h;
+ plane = ((Mask)1) << (pDraw->depth - 1);
+ length = lenPer * Ones(planemask & (plane | (plane - 1)));
+ }
+
+ VERIFY_SHMSIZE(shmdesc, stuff->offset, length, client);
+ xgi.size = length;
+
+ if (length == 0) {/* nothing to do */ }
+ else if (format == ZPixmap) {
+ XineramaGetImageData(drawables, x, y, w, h, format, planemask,
+ shmdesc->addr + stuff->offset,
+ widthBytesLine, isRoot);
+ } else {
+
+ length = stuff->offset;
+ for (; plane; plane >>= 1) {
+ if (planemask & plane) {
+ XineramaGetImageData(drawables, x, y, w, h,
+ format, plane, shmdesc->addr + length,
+ widthBytesLine, isRoot);
+ length += lenPer;
+ }
+ }
+ }
+
+ if (client->swapped) {
+ register int n;
+ swaps(&xgi.sequenceNumber, n);
+ swapl(&xgi.length, n);
+ swapl(&xgi.visual, n);
+ swapl(&xgi.size, n);
+ }
+ WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
+
+ return(client->noClientException);
+}
+
+static int
+ProcPanoramiXShmCreatePixmap(client)
+ register ClientPtr client;
+{
+ ScreenPtr pScreen = NULL;
+ PixmapPtr pMap = NULL;
+ DrawablePtr pDraw;
+ DepthPtr pDepth;
+ int i, j, result;
+ ShmDescPtr shmdesc;
+ REQUEST(xShmCreatePixmapReq);
+ PanoramiXRes *newPix;
+
+ REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
+ client->errorValue = stuff->pid;
+ if (!sharedPixmaps)
+ return BadImplementation;
+ LEGAL_NEW_RESOURCE(stuff->pid, client);
+ VERIFY_GEOMETRABLE(pDraw, stuff->drawable, client);
+ VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
+ if (!stuff->width || !stuff->height)
+ {
+ client->errorValue = 0;
+ return BadValue;
+ }
+ if (stuff->depth != 1)
+ {
+ pDepth = pDraw->pScreen->allowedDepths;
+ for (i=0; i<pDraw->pScreen->numDepths; i++, pDepth++)
+ if (pDepth->depth == stuff->depth)
+ goto CreatePmap;
+ client->errorValue = stuff->depth;
+ return BadValue;
+ }
+CreatePmap:
+ VERIFY_SHMSIZE(shmdesc, stuff->offset,
+ PixmapBytePad(stuff->width, stuff->depth) * stuff->height,
+ client);
+
+ if(!(newPix = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+ return BadAlloc;
+
+ newPix->type = XRT_PIXMAP;
+ newPix->u.pix.shared = TRUE;
+ newPix->info[0].id = stuff->pid;
+ for(j = 1; j < PanoramiXNumScreens; j++)
+ newPix->info[j].id = FakeClientID(client->index);
+
+ result = (client->noClientException);
+
+ FOR_NSCREENS(j) {
+ pScreen = screenInfo.screens[j];
+
+ pMap = (*shmFuncs[j]->CreatePixmap)(pScreen,
+ stuff->width, stuff->height, stuff->depth,
+ shmdesc->addr + stuff->offset);
+
+ if (pMap) {
+#ifdef PIXPRIV
+ pMap->devPrivates[shmPixmapPrivate].ptr = (pointer) shmdesc;
+#endif
+ shmdesc->refcnt++;
+ pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+ pMap->drawable.id = newPix->info[j].id;
+ if (!AddResource(newPix->info[j].id, RT_PIXMAP, (pointer)pMap)) {
+ (*pScreen->DestroyPixmap)(pMap);
+ result = BadAlloc;
+ break;
+ }
+ } else {
+ result = BadAlloc;
+ break;
+ }
+ }
+
+ if(result == BadAlloc) {
+ while(j--) {
+ (*pScreen->DestroyPixmap)(pMap);
+ FreeResource(newPix->info[j].id, RT_NONE);
+ }
+ xfree(newPix);
+ } else
+ AddResource(stuff->pid, XRT_PIXMAP, newPix);
+
+ return result;
+}
+
+#endif
+
static int
ProcShmPutImage(client)
register ClientPtr client;
@@ -365,11 +804,6 @@ ProcShmPutImage(client)
register GCPtr pGC;
register DrawablePtr pDraw;
long length;
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- long lengthProto;
- char *tmpImage;
- int tmpAlloced = 0;
-#endif
ShmDescPtr shmdesc;
REQUEST(xShmPutImageReq);
@@ -383,9 +817,6 @@ ProcShmPutImage(client)
if (stuff->depth != 1)
return BadMatch;
length = PixmapBytePad(stuff->totalWidth, 1);
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- lengthProto = PixmapBytePadProto(stuff->totalWidth, 1);
-#endif
}
else if (stuff->format == XYPixmap)
{
@@ -393,19 +824,12 @@ ProcShmPutImage(client)
return BadMatch;
length = PixmapBytePad(stuff->totalWidth, 1);
length *= stuff->depth;
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- lengthProto = PixmapBytePadProto(stuff->totalWidth, 1);
- lengthProto *= stuff->depth;
-#endif
}
else if (stuff->format == ZPixmap)
{
if (pDraw->depth != stuff->depth)
return BadMatch;
length = PixmapBytePad(stuff->totalWidth, stuff->depth);
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- lengthProto = PixmapBytePadProto(stuff->totalWidth, stuff->depth);
-#endif
}
else
{
@@ -413,13 +837,8 @@ ProcShmPutImage(client)
return BadValue;
}
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- VERIFY_SHMSIZE(shmdesc, stuff->offset, lengthProto * stuff->totalHeight,
- client);
-#else
VERIFY_SHMSIZE(shmdesc, stuff->offset, length * stuff->totalHeight,
client);
-#endif
if (stuff->srcX > stuff->totalWidth)
{
client->errorValue = stuff->srcX;
@@ -441,63 +860,6 @@ ProcShmPutImage(client)
return BadValue;
}
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- /* handle 64 bit case where protocol may pad to 32 and we want 64
- * In this case, length is what the server wants and lengthProto is
- * what the protocol thinks it is. If the the two are different,
- * copy the protocol version (i.e. the memory shared between the
- * server and the client) to a version with a scanline pad of 64.
- */
- if (length != lengthProto)
- {
- register int i;
- char * stuffptr, /* pointer into protocol data */
- * tmpptr; /* new location to copy to */
-
- if(!(tmpImage = (char *) ALLOCATE_LOCAL(length*stuff->totalHeight)))
- return (BadAlloc);
- tmpAlloced = 1;
-
- bzero(tmpImage,length*stuff->totalHeight);
-
- if (stuff->format == XYPixmap)
- {
- int lineBytes = PixmapBytePad(stuff->totalWidth, 1);
- int lineBytesProto = PixmapBytePadProto(stuff->totalWidth, 1);
- int depth = stuff->depth;
-
- stuffptr = shmdesc->addr + stuff->offset ;
- tmpptr = tmpImage;
- for (i = 0; i < stuff->totalHeight*stuff->depth;
- stuffptr += lineBytesProto,tmpptr += lineBytes, i++)
- bcopy(stuffptr,tmpptr,lineBytesProto);
- }
- else
- {
- for (i = 0,
- stuffptr = shmdesc->addr + stuff->offset,
- tmpptr=tmpImage;
- i < stuff->totalHeight;
- stuffptr += lengthProto,tmpptr += length, i++)
- bcopy(stuffptr,tmpptr,lengthProto);
- }
- }
- /* handle 64-bit case where stuff is not 64-bit aligned
- */
- else if ((unsigned long)(shmdesc->addr+stuff->offset) &
- (sizeof(long)-1))
- {
- if(!(tmpImage = (char *) ALLOCATE_LOCAL(length*stuff->totalHeight)))
- return (BadAlloc);
- tmpAlloced = 1;
- bcopy((char *)(shmdesc->addr+stuff->offset),
- tmpImage,
- length*stuff->totalHeight);
- }
- else
- tmpImage = (char *)(shmdesc->addr+stuff->offset);
-#endif
-
if ((((stuff->format == ZPixmap) && (stuff->srcX == 0)) ||
((stuff->format != ZPixmap) &&
(stuff->srcX < screenInfo.bitmapScanlinePad) &&
@@ -509,11 +871,7 @@ ProcShmPutImage(client)
stuff->dstX, stuff->dstY,
stuff->totalWidth, stuff->srcHeight,
stuff->srcX, stuff->format,
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- tmpImage +
-#else
shmdesc->addr + stuff->offset +
-#endif
(stuff->srcY * length));
else
(*shmFuncs[pDraw->pScreen->myNum]->PutImage)(
@@ -522,12 +880,7 @@ ProcShmPutImage(client)
stuff->srcX, stuff->srcY,
stuff->srcWidth, stuff->srcHeight,
stuff->dstX, stuff->dstY,
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- tmpImage);
-
-#else
shmdesc->addr + stuff->offset);
-#endif
if (stuff->sendEvent)
{
@@ -543,12 +896,7 @@ ProcShmPutImage(client)
WriteEventsToClient(client, 1, (xEvent *) &ev);
}
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- if (tmpAlloced)
- DEALLOCATE_LOCAL(tmpImage);
-#endif
-
- return (client->noClientException);
+ return (client->noClientException);
}
@@ -558,17 +906,11 @@ ProcShmGetImage(client)
register ClientPtr client;
{
register DrawablePtr pDraw;
- long lenPer, length;
- Mask plane;
+ long lenPer = 0, length;
+ Mask plane = 0;
xShmGetImageReply xgi;
ShmDescPtr shmdesc;
int n;
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- long widthBytesLine,widthBytesLineProto;
- long lenPerProto,lengthProto;
- char *tmpImage;
- int tmpAlloced = 0;
-#endif
REQUEST(xShmGetImageReq);
@@ -616,43 +958,18 @@ ProcShmGetImage(client)
xgi.depth = pDraw->depth;
if(stuff->format == ZPixmap)
{
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- widthBytesLine = PixmapBytePad(stuff->width, pDraw->depth);
- length = widthBytesLine * stuff->height;
- widthBytesLineProto = PixmapBytePadProto(stuff->width, pDraw->depth);
- lengthProto = widthBytesLineProto * stuff->height;
-#else
length = PixmapBytePad(stuff->width, pDraw->depth) * stuff->height;
-#endif
}
else
{
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- widthBytesLine = PixmapBytePad(stuff->width, 1);
- lenPer = widthBytesLine * stuff->height;
- plane = ((Mask)1) << (pDraw->depth - 1);
- /* only planes asked for */
- length = lenPer * Ones(stuff->planeMask & (plane | (plane - 1)));
-
- widthBytesLineProto = PixmapBytePadProto(stuff->width, 1);
- lenPerProto = widthBytesLineProto * stuff->height;
- lengthProto = lenPerProto * Ones(stuff->planeMask &
- (plane | (plane - 1)));
-#else
lenPer = PixmapBytePad(stuff->width, 1) * stuff->height;
plane = ((Mask)1) << (pDraw->depth - 1);
/* only planes asked for */
length = lenPer * Ones(stuff->planeMask & (plane | (plane - 1)));
-#endif
}
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- VERIFY_SHMSIZE(shmdesc, stuff->offset, lengthProto, client);
- xgi.size = lengthProto;
-#else
VERIFY_SHMSIZE(shmdesc, stuff->offset, length, client);
xgi.size = length;
-#endif
if (length == 0)
{
@@ -660,105 +977,25 @@ ProcShmGetImage(client)
}
else if (stuff->format == ZPixmap)
{
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- /* check for protocol/server padding differences.
- */
- if ((widthBytesLine != widthBytesLineProto) ||
- ((unsigned long)shmdesc->addr + stuff->offset & (sizeof(long)-1)))
- {
- /* temp stuff for 64 bit alignment stuff */
- register char * bufPtr, * protoPtr;
- register int i;
-
- if(!(tmpImage = (char *) ALLOCATE_LOCAL(length)))
- return (BadAlloc);
- tmpAlloced = 1;
-
- (*pDraw->pScreen->GetImage)(pDraw, stuff->x, stuff->y,
- stuff->width, stuff->height,
- stuff->format, stuff->planeMask,
- tmpImage);
-
- /* for 64-bit server, convert image to pad to 32 bits
- */
- bzero(shmdesc->addr + stuff->offset,lengthProto);
-
- for (i=0,bufPtr=tmpImage,protoPtr=shmdesc->addr + stuff->offset;
- i < stuff->height;
- bufPtr += widthBytesLine,protoPtr += widthBytesLineProto,
- i++)
- bcopy(bufPtr,protoPtr,widthBytesLineProto);
- }
- else
- {
- (*pDraw->pScreen->GetImage)(pDraw, stuff->x, stuff->y,
- stuff->width, stuff->height,
- stuff->format, stuff->planeMask,
- shmdesc->addr + stuff->offset);
- }
-#else
(*pDraw->pScreen->GetImage)(pDraw, stuff->x, stuff->y,
stuff->width, stuff->height,
stuff->format, stuff->planeMask,
shmdesc->addr + stuff->offset);
-#endif
}
else
{
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- /* check for protocol/server padding differences.
- */
- if ((widthBytesLine != widthBytesLineProto) ||
- ((unsigned long)shmdesc->addr + stuff->offset &
- (sizeof(long)-1)))
- {
- if(!(tmpImage = (char *) ALLOCATE_LOCAL(length)))
- return (BadAlloc);
- tmpAlloced = 1;
- }
-#endif
length = stuff->offset;
for (; plane; plane >>= 1)
{
if (stuff->planeMask & plane)
{
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- if ((widthBytesLine != widthBytesLineProto) ||
- ((unsigned long)shmdesc->addr + stuff->offset &
- (sizeof(long)-1)))
- {
- /* get image for each plane.
- */
- (*pDraw->pScreen->GetImage)(pDraw,
- stuff->x, stuff->y,
- stuff->width, stuff->height,
- stuff->format, plane,
- tmpImage);
-
- /* for 64-bit server, convert image to pad to 32 bits */
- bzero(shmdesc->addr+length, widthBytesLine);
- bcopy(tmpImage, shmdesc->addr+length, widthBytesLineProto);
- /* increment length */
- length += lenPerProto;
- }
- else /* no diff between protocol and server */
- {
- (*pDraw->pScreen->GetImage)(pDraw,
- stuff->x, stuff->y,
- stuff->width, stuff->height,
- stuff->format, plane,
- shmdesc->addr + length);
- length += lenPer;
- }
-#else
(*pDraw->pScreen->GetImage)(pDraw,
stuff->x, stuff->y,
stuff->width, stuff->height,
stuff->format, plane,
shmdesc->addr + length);
length += lenPer;
-#endif
}
}
}
@@ -771,11 +1008,6 @@ ProcShmGetImage(client)
}
WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
-#ifdef INTERNAL_VS_EXTERNAL_PADDING
- if (tmpAlloced)
- DEALLOCATE_LOCAL(tmpImage);
-#endif
-
return(client->noClientException);
}
@@ -794,8 +1026,10 @@ fbShmCreatePixmap (pScreen, width, height, depth, addr)
return NullPixmap;
if (!(*pScreen->ModifyPixmapHeader)(pPixmap, width, height, depth,
- /*XXX*/depth, PixmapBytePad(width, depth), (pointer)addr))
+ BitsPerPixel(depth), PixmapBytePad(width, depth), (pointer)addr)) {
+ (*pScreen->DestroyPixmap)(pPixmap);
return NullPixmap;
+ }
return pPixmap;
}
@@ -841,14 +1075,15 @@ CreatePmap:
shmdesc->addr + stuff->offset);
if (pMap)
{
+#ifdef PIXPRIV
+ pMap->devPrivates[shmPixmapPrivate].ptr = (pointer) shmdesc;
+#endif
+ shmdesc->refcnt++;
pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
pMap->drawable.id = stuff->pid;
if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))
{
- shmdesc->refcnt++;
- if (AddResource(stuff->pid, ShmPixType, (pointer)shmdesc))
- return(client->noClientException);
- FreeResource(stuff->pid, RT_NONE);
+ return(client->noClientException);
}
}
return (BadAlloc);
@@ -868,11 +1103,23 @@ ProcShmDispatch (client)
case X_ShmDetach:
return ProcShmDetach(client);
case X_ShmPutImage:
+#ifdef PANORAMIX
+ if ( !noPanoramiXExtension )
+ return ProcPanoramiXShmPutImage(client);
+#endif
return ProcShmPutImage(client);
case X_ShmGetImage:
+#ifdef PANORAMIX
+ if ( !noPanoramiXExtension )
+ return ProcPanoramiXShmGetImage(client);
+#endif
return ProcShmGetImage(client);
case X_ShmCreatePixmap:
- return ProcShmCreatePixmap(client);
+#ifdef PANORAMIX
+ if ( !noPanoramiXExtension )
+ return ProcPanoramiXShmCreatePixmap(client);
+#endif
+ return ProcShmCreatePixmap(client);
default:
return BadRequest;
}
diff --git a/Xext/sleepuntil.c b/Xext/sleepuntil.c
index 292924ed6..eb2b96a76 100644
--- a/Xext/sleepuntil.c
+++ b/Xext/sleepuntil.c
@@ -25,9 +25,11 @@ in this Software without prior written authorization from The Open Group.
*
* Author: Keith Packard, MIT X Consortium
*/
+/* $XFree86: xc/programs/Xserver/Xext/sleepuntil.c,v 3.5 2001/12/14 19:58:51 dawes Exp $ */
/* dixsleep.c - implement millisecond timeouts for X clients */
+#include "sleepuntil.h"
#include "X.h"
#include "Xmd.h"
#include "misc.h"
@@ -41,7 +43,13 @@ typedef struct _Sertafied {
TimeStamp revive;
ClientPtr pClient;
XID id;
- void (*notifyFunc)();
+ void (*notifyFunc)(
+#if NeedNestedPrototypes
+ ClientPtr /* client */,
+ pointer /* closure */
+#endif
+ );
+
pointer closure;
} SertafiedRec, *SertafiedPtr;
@@ -49,11 +57,35 @@ static SertafiedPtr pPending;
static RESTYPE SertafiedResType;
static Bool BlockHandlerRegistered;
static int SertafiedGeneration;
-static void ClientAwaken();
-static int SertafiedDelete();
-static void SertafiedBlockHandler();
-static void SertafiedWakeupHandler();
+static void ClientAwaken(
+#if NeedFunctionPrototypes
+ ClientPtr /* client */,
+ pointer /* closure */
+#endif
+);
+static int SertafiedDelete(
+#if NeedFunctionPrototypes
+ pointer /* value */,
+ XID /* id */
+#endif
+);
+static void SertafiedBlockHandler(
+#if NeedFunctionPrototypes
+ pointer /* data */,
+ OSTimePtr /* wt */,
+ pointer /* LastSelectMask */
+#endif
+);
+static void SertafiedWakeupHandler(
+#if NeedFunctionPrototypes
+ pointer /* data */,
+ int /* i */,
+ pointer /* LastSelectMask */
+#endif
+);
+
+int
ClientSleepUntil (client, revive, notifyFunc, closure)
ClientPtr client;
TimeStamp *revive;
@@ -152,7 +184,7 @@ SertafiedBlockHandler (data, wt, LastSelectMask)
pointer LastSelectMask;
{
SertafiedPtr pReq, pNext;
- unsigned long newdelay, olddelay;
+ unsigned long delay;
TimeStamp now;
if (!pPending)
@@ -177,8 +209,8 @@ SertafiedBlockHandler (data, wt, LastSelectMask)
pReq = pPending;
if (!pReq)
return;
- newdelay = pReq->revive.milliseconds - now.milliseconds;
- AdjustWaitForDelay (wt, newdelay);
+ delay = pReq->revive.milliseconds - now.milliseconds;
+ AdjustWaitForDelay (wt, delay);
}
static void
diff --git a/Xext/sync.c b/Xext/sync.c
index 8274d2522..079a804e3 100644
--- a/Xext/sync.c
+++ b/Xext/sync.c
@@ -50,10 +50,10 @@ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
*/
+/* $XFree86: xc/programs/Xserver/Xext/sync.c,v 3.11 2001/12/14 19:58:51 dawes Exp $ */
#define NEED_REPLIES
#define NEED_EVENTS
-#include <stdio.h>
#include "X.h"
#include "Xproto.h"
#include "Xmd.h"
@@ -67,6 +67,15 @@ PERFORMANCE OF THIS SOFTWARE.
#include "sync.h"
#include "syncstr.h"
+#ifdef EXTMODULE
+#include "xf86_ansic.h"
+#else
+#include <stdio.h>
+#if !defined(WIN32) && !defined(Lynx)
+#include <sys/time.h>
+#endif
+#endif
+
/*
* Local Global Variables
*/
@@ -87,13 +96,254 @@ static SyncCounter **SysCounterList = NULL;
#define XSyncCAAllTrigger \
(XSyncCACounter | XSyncCAValueType | XSyncCAValue | XSyncCATestType)
+static int
+FreeAlarm(
+#if NeedFunctionPrototypes
+ pointer /* addr */,
+ XID /* id */
+#endif
+);
+
+static int
+FreeAlarmClient(
+#if NeedFunctionPrototypes
+ pointer /* value */,
+ XID /* id */
+#endif
+);
+
+static int
+FreeAwait(
+#if NeedFunctionPrototypes
+ pointer /* addr */,
+ XID /* id */
+#endif
+);
+
+static void
+ServertimeBracketValues(
+#if NeedFunctionPrototypes
+ pointer /* pCounter */,
+ CARD64 * /* pbracket_less */,
+ CARD64 * /* pbracket_greater */
+#endif
+);
+
+static void
+ServertimeQueryValue(
+#if NeedFunctionPrototypes
+ pointer /* pCounter */,
+ CARD64 * /* pValue_return */
+#endif
+);
+
+static void
+ServertimeWakeupHandler(
+#if NeedFunctionPrototypes
+ pointer /* env */,
+ int /* rc */,
+ pointer /* LastSelectMask */
+#endif
+);
+
+static int
+SyncInitTrigger(
+#if NeedFunctionPrototypes
+ ClientPtr /* client */,
+ SyncTrigger * /* pTrigger */,
+ XSyncCounter /* counter */,
+ Mask /* changes */
+#endif
+);
+
+static void
+SAlarmNotifyEvent(
+#if NeedFunctionPrototypes
+ xSyncAlarmNotifyEvent * /* from */,
+ xSyncAlarmNotifyEvent * /* to */
+#endif
+);
+
+static void
+SCounterNotifyEvent(
+#if NeedFunctionPrototypes
+ xSyncCounterNotifyEvent * /* from */,
+ xSyncCounterNotifyEvent * /* to */
+#endif
+);
+
+static void
+ServertimeBlockHandler(
+#if NeedFunctionPrototypes
+ pointer /* env */,
+ struct timeval ** /* wt */,
+ pointer /* LastSelectMask */
+#endif
+);
+
+static int
+SyncAddTriggerToCounter(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */
+#endif
+);
+
+extern void
+SyncAlarmCounterDestroyed(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */
+#endif
+);
+
+static void
+SyncAlarmTriggerFired(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */
+#endif
+);
+
+static void
+SyncAwaitTriggerFired(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */
+#endif
+);
+
+static int
+SyncChangeAlarmAttributes(
+#if NeedFunctionPrototypes
+ ClientPtr /* client */,
+ SyncAlarm * /* pAlarm */,
+ Mask /* mask */,
+ CARD32 * /* values */
+#endif
+);
+
+static Bool
+SyncCheckTriggerNegativeComparison(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */,
+ CARD64 /* oldval */
+#endif
+);
+
+static Bool
+SyncCheckTriggerNegativeTransition(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */,
+ CARD64 /* oldval */
+#endif
+);
+
+static Bool
+SyncCheckTriggerPositiveComparison(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */,
+ CARD64 /* oldval */
+#endif
+);
+
+static Bool
+SyncCheckTriggerPositiveTransition(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */,
+ CARD64 /* oldval */
+#endif
+);
+
+static SyncCounter *
+SyncCreateCounter(
+#if NeedFunctionPrototypes
+ ClientPtr /* client */,
+ XSyncCounter /* id */,
+ CARD64 /* initialvalue */
+#endif
+);
+
static void SyncComputeBracketValues(
#if NeedFunctionPrototypes
- SyncCounter * /* pCounter */,
- Bool /* startOver */
+ SyncCounter * /* pCounter */,
+ Bool /* startOver */
#endif
);
+static void
+SyncDeleteTriggerFromCounter(
+#if NeedFunctionPrototypes
+ SyncTrigger * /* pTrigger */
+#endif
+);
+
+static Bool
+SyncEventSelectForAlarm(
+#if NeedFunctionPrototypes
+ SyncAlarm * /* pAlarm */,
+ ClientPtr /* client */,
+ Bool /* wantevents */
+#endif
+);
+
+static void
+SyncInitServerTime(
+#if NeedFunctionPrototypes
+ void
+#endif
+);
+
+static void
+SyncResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* extEntry */
+#endif
+);
+
+static void
+SyncSendAlarmNotifyEvents(
+#if NeedFunctionPrototypes
+ SyncAlarm * /* pAlarm */
+#endif
+);
+
+static void
+SyncSendCounterNotifyEvents(
+#if NeedFunctionPrototypes
+ ClientPtr /* client */,
+ SyncAwait ** /* ppAwait */,
+ int /* num_events */
+#endif
+);
+
+static DISPATCH_PROC(ProcSyncAwait);
+static DISPATCH_PROC(ProcSyncChangeAlarm);
+static DISPATCH_PROC(ProcSyncChangeCounter);
+static DISPATCH_PROC(ProcSyncCreateAlarm);
+static DISPATCH_PROC(ProcSyncCreateCounter);
+static DISPATCH_PROC(ProcSyncDestroyAlarm);
+static DISPATCH_PROC(ProcSyncDestroyCounter);
+static DISPATCH_PROC(ProcSyncDispatch);
+static DISPATCH_PROC(ProcSyncGetPriority);
+static DISPATCH_PROC(ProcSyncInitialize);
+static DISPATCH_PROC(ProcSyncListSystemCounters);
+static DISPATCH_PROC(ProcSyncQueryAlarm);
+static DISPATCH_PROC(ProcSyncQueryCounter);
+static DISPATCH_PROC(ProcSyncSetCounter);
+static DISPATCH_PROC(ProcSyncSetPriority);
+static DISPATCH_PROC(SProcSyncAwait);
+static DISPATCH_PROC(SProcSyncChangeAlarm);
+static DISPATCH_PROC(SProcSyncChangeCounter);
+static DISPATCH_PROC(SProcSyncCreateAlarm);
+static DISPATCH_PROC(SProcSyncCreateCounter);
+static DISPATCH_PROC(SProcSyncDestroyAlarm);
+static DISPATCH_PROC(SProcSyncDestroyCounter);
+static DISPATCH_PROC(SProcSyncDispatch);
+static DISPATCH_PROC(SProcSyncGetPriority);
+static DISPATCH_PROC(SProcSyncInitialize);
+static DISPATCH_PROC(SProcSyncListSystemCounters);
+static DISPATCH_PROC(SProcSyncQueryAlarm);
+static DISPATCH_PROC(SProcSyncQueryCounter);
+static DISPATCH_PROC(SProcSyncSetCounter);
+static DISPATCH_PROC(SProcSyncSetPriority);
+
/* Each counter maintains a simple linked list of triggers that are
* interested in the counter. The two functions below are used to
* delete and add triggers on this list.
@@ -462,26 +712,26 @@ SyncAlarmTriggerFired(pTrigger)
{
Bool overflow;
CARD64 oldvalue;
- SyncTrigger *pTrigger = &pAlarm->trigger;
+ SyncTrigger *paTrigger = &pAlarm->trigger;
/* "The alarm is updated by repeatedly adding delta to the
* value of the trigger and re-initializing it until it
* becomes FALSE."
*/
- oldvalue = pTrigger->test_value;
+ oldvalue = paTrigger->test_value;
/* XXX really should do something smarter here */
do
{
- XSyncValueAdd(&pTrigger->test_value, pTrigger->test_value,
+ XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value,
pAlarm->delta, &overflow);
} while (!overflow &&
- (*pTrigger->CheckTrigger)(pTrigger,
- pTrigger->pCounter->value));
+ (*paTrigger->CheckTrigger)(paTrigger,
+ paTrigger->pCounter->value));
- new_test_value = pTrigger->test_value;
- pTrigger->test_value = oldvalue;
+ new_test_value = paTrigger->test_value;
+ paTrigger->test_value = oldvalue;
/* "If this update would cause value to fall outside the range
* for an INT64...no change is made to value (test-value) and
@@ -710,7 +960,6 @@ SyncChangeAlarmAttributes(client, pAlarm, mask, values)
Mask mask;
CARD32 *values;
{
- SyncAlarmClientList *pClients;
int status;
XSyncCounter counter;
Mask origmask = mask;
@@ -719,9 +968,9 @@ SyncChangeAlarmAttributes(client, pAlarm, mask, values)
while (mask)
{
- int index = lowbit(mask);
- mask &= ~index;
- switch (index)
+ int index2 = lowbit(mask);
+ mask &= ~index2;
+ switch (index2)
{
case XSyncCACounter:
mask &= ~XSyncCACounter;
@@ -998,7 +1247,6 @@ FreeAlarm(addr, id)
XID id;
{
SyncAlarm *pAlarm = (SyncAlarm *) addr;
- SyncAlarmClientList *pClient;
pAlarm->state = XSyncAlarmDestroyed;
@@ -1139,7 +1387,6 @@ static int
ProcSyncInitialize(client)
ClientPtr client;
{
- REQUEST(xSyncInitializeReq);
xSyncInitializeReply rep;
int n;
@@ -1166,10 +1413,9 @@ static int
ProcSyncListSystemCounters(client)
ClientPtr client;
{
- REQUEST(xSyncListSystemCountersReq);
xSyncListSystemCountersReply rep;
int i, len;
- xSyncSystemCounter *list, *walklist;
+ xSyncSystemCounter *list = NULL, *walklist = NULL;
REQUEST_SIZE_MATCH(xSyncListSystemCountersReq);
@@ -1318,7 +1564,6 @@ ProcSyncCreateCounter(client)
ClientPtr client;
{
REQUEST(xSyncCreateCounterReq);
- SyncCounter *pCounter;
CARD64 initial;
REQUEST_SIZE_MATCH(xSyncCreateCounterReq);
@@ -1440,9 +1685,8 @@ ProcSyncAwait(client)
{
REQUEST(xSyncAwaitReq);
int len, items;
- int n, i;
+ int i;
xSyncWaitCondition *pProtocolWaitConds;
- int ret;
SyncAwaitUnion *pAwaitUnion;
SyncAwait *pAwait;
int status;
@@ -1606,7 +1850,6 @@ ProcSyncCreateAlarm(client)
REQUEST(xSyncCreateAlarmReq);
SyncAlarm *pAlarm;
int status;
- int i;
unsigned long len, vmask;
SyncTrigger *pTrigger;
@@ -2063,8 +2306,6 @@ static int
SProcSyncDispatch(client)
ClientPtr client;
{
- int n;
-
REQUEST(xReq);
switch (stuff->data)
@@ -2154,8 +2395,6 @@ SyncResetProc(extEntry)
}
-static void SyncInitServerTime();
-
/*
* ** Initialise the extension.
*/
@@ -2188,8 +2427,8 @@ SyncExtensionInit()
SyncReqCode = extEntry->base;
SyncEventBase = extEntry->eventBase;
SyncErrorBase = extEntry->errorBase;
- EventSwapVector[SyncEventBase + XSyncCounterNotify] = SCounterNotifyEvent;
- EventSwapVector[SyncEventBase + XSyncAlarmNotify] = SAlarmNotifyEvent;
+ EventSwapVector[SyncEventBase + XSyncCounterNotify] = (EventSwapPtr) SCounterNotifyEvent;
+ EventSwapVector[SyncEventBase + XSyncAlarmNotify] = (EventSwapPtr) SAlarmNotifyEvent;
/*
* Although SERVERTIME is implemented by the OS layer, we initialise it
@@ -2211,9 +2450,6 @@ SyncExtensionInit()
*/
-#ifndef WIN32
-#include <sys/time.h>
-#endif
static pointer ServertimeCounter;
static XSyncValue Now;
diff --git a/Xext/xcmisc.c b/Xext/xcmisc.c
index 4977fdf88..1d3b416db 100644
--- a/Xext/xcmisc.c
+++ b/Xext/xcmisc.c
@@ -26,28 +26,44 @@ other dealings in this Software without prior written authorization
from The Open Group.
*/
+/* $XFree86: xc/programs/Xserver/Xext/xcmisc.c,v 3.5 2001/12/14 19:58:51 dawes Exp $ */
+#define NEED_EVENTS
+#define NEED_REPLIES
#include "X.h"
#include "Xproto.h"
#include "misc.h"
#include "os.h"
#include "dixstruct.h"
#include "extnsionst.h"
+#include "swaprep.h"
#include "xcmiscstr.h"
static unsigned char XCMiscCode;
-static int ProcXCMiscDispatch(), SProcXCMiscDispatch();
-static void XCMiscResetProc();
-extern void Swap32Write(); /* XXX should be in header file */
+
+static void XCMiscResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* extEntry */
+#endif
+);
+
+static DISPATCH_PROC(ProcXCMiscDispatch);
+static DISPATCH_PROC(ProcXCMiscGetVersion);
+static DISPATCH_PROC(ProcXCMiscGetXIDList);
+static DISPATCH_PROC(ProcXCMiscGetXIDRange);
+static DISPATCH_PROC(SProcXCMiscDispatch);
+static DISPATCH_PROC(SProcXCMiscGetVersion);
+static DISPATCH_PROC(SProcXCMiscGetXIDList);
+static DISPATCH_PROC(SProcXCMiscGetXIDRange);
void
XCMiscExtensionInit()
{
- ExtensionEntry *extEntry, *AddExtension();
+ ExtensionEntry *extEntry;
- if (extEntry = AddExtension(XCMiscExtensionName, 0, 0,
+ if ((extEntry = AddExtension(XCMiscExtensionName, 0, 0,
ProcXCMiscDispatch, SProcXCMiscDispatch,
- XCMiscResetProc, StandardMinorOpcode))
+ XCMiscResetProc, StandardMinorOpcode)) != 0)
XCMiscCode = (unsigned char)extEntry->base;
DeclareExtensionSecurity(XCMiscExtensionName, TRUE);
}
@@ -63,7 +79,6 @@ static int
ProcXCMiscGetVersion(client)
register ClientPtr client;
{
- REQUEST(xXCMiscGetVersionReq);
xXCMiscGetVersionReply rep;
register int n;
@@ -86,7 +101,6 @@ static int
ProcXCMiscGetXIDRange(client)
register ClientPtr client;
{
- REQUEST(xXCMiscGetXIDRangeReq);
xXCMiscGetXIDRangeReply rep;
register int n;
XID min_id, max_id;
@@ -137,7 +151,7 @@ ProcXCMiscGetXIDList(client)
WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *)&rep);
if (count)
{
- client->pSwapReplyFunc = Swap32Write;
+ client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, count * sizeof(XID), pids);
}
DEALLOCATE_LOCAL(pids);
diff --git a/Xext/xprint.c b/Xext/xprint.c
index 6e2013140..db9a25135 100644
--- a/Xext/xprint.c
+++ b/Xext/xprint.c
@@ -1,4 +1,4 @@
-/* $Xorg: xprint.c,v 1.5 2001/03/05 20:42:36 pookie Exp $ */
+/* $Xorg: xprint.c,v 1.5 2001/03/05 20:42:26 pookie Exp $ */
/*
(c) Copyright 1996 Hewlett-Packard Company
(c) Copyright 1996 International Business Machines Corp.
@@ -64,8 +64,11 @@ copyright holders.
** *********************************************************
**
********************************************************************/
+/* $XFree86: xc/programs/Xserver/Xext/xprint.c,v 1.13 2001/11/23 19:21:31 dawes Exp $ */
+#define _XP_PRINT_SERVER_
#include "X.h"
+#include "Xos.h"
#define NEED_EVENTS
#include "Xproto.h"
#undef NEED_EVENTS
@@ -76,105 +79,90 @@ copyright holders.
#include "extnsionst.h"
#include "dixstruct.h"
#include "Xatom.h"
-#define _XP_PRINT_SERVER_
#include "Print.h"
#include "Printstr.h"
-#undef _XP_PRINT_SERVER_
#include "../Xprint/DiPrint.h"
-
-extern WindowPtr *WindowTable; /* declared in dix:globals.c */
-
-extern WindowPtr XpDiValidatePrinter();
-extern char *XpDiGetDriverName();
-extern char *XpGetAttributes();
-extern char *XpGetOneAttribute();
-extern int XpRehashPrinterList();
-extern void XpSetFontResFunc();
-
-static void XpResetProc();
-
-static int ProcXpDispatch();
-static int ProcXpSwappedDispatch();
-
-static int ProcXpQueryVersion();
-static int ProcXpGetPrinterList();
-static int ProcXpCreateContext();
-static int ProcXpSetContext();
-static int ProcXpGetContext();
-static int ProcXpDestroyContext();
-static int ProcXpGetContextScreen();
-static int ProcXpStartJob();
-static int ProcXpEndJob();
-static int ProcXpStartDoc();
-static int ProcXpEndDoc();
-static int ProcXpStartPage();
-static int ProcXpEndPage();
-static int ProcXpSelectInput();
-static int ProcXpInputSelected();
-static int ProcXpPutDocumentData();
-static int ProcXpGetDocumentData();
-static int ProcXpGetAttributes();
-static int ProcXpGetOneAttribute();
-static int ProcXpSetAttributes();
-static int ProcXpRehashPrinterList();
-static int ProcXpQueryScreens();
-static int ProcXpGetPageDimensions();
-static int ProcXpSetImageResolution();
-static int ProcXpGetImageResolution();
-
-static void SwapXpNotifyEvent();
-static void SwapXpAttributeEvent();
-
-static int SProcXpGetPrinterList();
-static int SProcXpCreateContext();
-static int SProcXpSetContext();
-static int SProcXpGetContext();
-static int SProcXpDestroyContext();
-static int SProcXpGetContextScreen();
-static int SProcXpStartJob();
-static int SProcXpEndJob();
-static int SProcXpStartDoc();
-static int SProcXpEndDoc();
-static int SProcXpStartPage();
-static int SProcXpEndPage();
-static int SProcXpSelectInput();
-static int SProcXpInputSelected();
-static int SProcXpPutDocumentData();
-static int SProcXpGetDocumentData();
-static int SProcXpGetAttributes();
-static int SProcXpGetOneAttribute();
-static int SProcXpSetAttributes();
-static int SProcXpRehashPrinterList();
-static int SProcXpGetPageDimensions();
-static int SProcXpSetImageResolution();
-static int SProcXpGetImageResolution();
-
-static void SendXpNotify();
-static void SendAttributeNotify();
-static int XpFreeClient();
-static int XpFreeContext();
-static int XpFreePage();
-static int XpFreeEvents();
-static Bool XpCloseScreen();
-static CARD32 GetAllEventMasks();
-static struct _XpEvent *AddEventRec();
-static void DeleteEventRec();
-static struct _XpEvent *FindEventRec();
-static struct _XpClient *CreateXpClient();
-static void FreeXpClient();
-static void InitContextPrivates();
-static void ResetContextPrivates();
-static struct _XpClient *FindClient();
-static struct _XpClient *AcquireClient();
+#include "../Xprint/attributes.h"
+
+static void XpResetProc(ExtensionEntry *);
+
+static int ProcXpDispatch(ClientPtr);
+static int ProcXpSwappedDispatch(ClientPtr);
+
+static int ProcXpQueryVersion(ClientPtr);
+static int ProcXpGetPrinterList(ClientPtr);
+static int ProcXpCreateContext(ClientPtr);
+static int ProcXpSetContext(ClientPtr);
+static int ProcXpGetContext(ClientPtr);
+static int ProcXpDestroyContext(ClientPtr);
+static int ProcXpGetContextScreen(ClientPtr);
+static int ProcXpStartJob(ClientPtr);
+static int ProcXpEndJob(ClientPtr);
+static int ProcXpStartDoc(ClientPtr);
+static int ProcXpEndDoc(ClientPtr);
+static int ProcXpStartPage(ClientPtr);
+static int ProcXpEndPage(ClientPtr);
+static int ProcXpSelectInput(ClientPtr);
+static int ProcXpInputSelected(ClientPtr);
+static int ProcXpPutDocumentData(ClientPtr);
+static int ProcXpGetDocumentData(ClientPtr);
+static int ProcXpGetAttributes(ClientPtr);
+static int ProcXpGetOneAttribute(ClientPtr);
+static int ProcXpSetAttributes(ClientPtr);
+static int ProcXpRehashPrinterList(ClientPtr);
+static int ProcXpQueryScreens(ClientPtr);
+static int ProcXpGetPageDimensions(ClientPtr);
+static int ProcXpSetImageResolution(ClientPtr);
+static int ProcXpGetImageResolution(ClientPtr);
+
+static void SwapXpNotifyEvent(xPrintPrintEvent *, xPrintPrintEvent *);
+static void SwapXpAttributeEvent(xPrintAttributeEvent *, xPrintAttributeEvent *);
+
+static int SProcXpGetPrinterList(ClientPtr);
+static int SProcXpCreateContext(ClientPtr);
+static int SProcXpSetContext(ClientPtr);
+static int SProcXpGetContext(ClientPtr);
+static int SProcXpDestroyContext(ClientPtr);
+static int SProcXpGetContextScreen(ClientPtr);
+static int SProcXpStartJob(ClientPtr);
+static int SProcXpEndJob(ClientPtr);
+static int SProcXpStartDoc(ClientPtr);
+static int SProcXpEndDoc(ClientPtr);
+static int SProcXpStartPage(ClientPtr);
+static int SProcXpEndPage(ClientPtr);
+static int SProcXpSelectInput(ClientPtr);
+static int SProcXpInputSelected(ClientPtr);
+static int SProcXpPutDocumentData(ClientPtr);
+static int SProcXpGetDocumentData(ClientPtr);
+static int SProcXpGetAttributes(ClientPtr);
+static int SProcXpGetOneAttribute(ClientPtr);
+static int SProcXpSetAttributes(ClientPtr);
+static int SProcXpRehashPrinterList(ClientPtr);
+static int SProcXpGetPageDimensions(ClientPtr);
+static int SProcXpSetImageResolution(ClientPtr);
+static int SProcXpGetImageResolution(ClientPtr);
+
+static void SendXpNotify(XpContextPtr, int, int);
+static void SendAttributeNotify(XpContextPtr, int);
+static int XpFreeClient(pointer, XID);
+static int XpFreeContext(pointer, XID);
+static int XpFreePage(pointer, XID);
+static Bool XpCloseScreen(int, ScreenPtr);
+static CARD32 GetAllEventMasks(XpContextPtr);
+static struct _XpClient *CreateXpClient(ClientPtr);
+static void InitContextPrivates(XpContextPtr);
+static void ResetContextPrivates(void);
+static struct _XpClient *FindClient(XpContextPtr, ClientPtr);
+static struct _XpClient *AcquireClient(XpContextPtr, ClientPtr);
typedef struct _driver {
struct _driver *next;
char *name;
- int (* CreateContext)();
+ int (* CreateContext)(XpContextPtr);
} XpDriverRec, *XpDriverPtr;
typedef struct _xpScreen {
- Bool (* CloseScreen)();
+ Bool (* CloseScreen)(int, ScreenPtr);
struct _driver *drivers;
} XpScreenRec, *XpScreenPtr;
@@ -196,6 +184,8 @@ typedef struct _XpClient {
XID contextClientID; /* unneeded sanity check? */
} XpClientRec, *XpClientPtr;
+static void FreeXpClient(XpClientPtr, Bool);
+
/*
* Each StartPage request specifies a window which forms the top level
* window of the page. One of the following structs is created as a
@@ -240,8 +230,7 @@ static XpScreenPtr XpScreens[MAXSCREENS];
static unsigned char XpReqCode;
static int XpEventBase;
static int XpErrorBase;
-static int XpGeneration = 0;
-static int XpWindowPrivateIndex;
+static unsigned long XpGeneration = 0;
static int XpClientPrivateIndex;
/* Variables for the context private machinery.
@@ -293,9 +282,9 @@ static CARD32 allEvents = XPPrintMask | XPAttributeMask;
*/
void
-XpExtensionInit()
+XpExtensionInit(void)
{
- ExtensionEntry *extEntry, *AddExtension();
+ ExtensionEntry *extEntry;
int i;
RTclient = CreateNewResourceType(XpFreeClient);
@@ -309,8 +298,8 @@ XpExtensionInit()
XpReqCode = (unsigned char)extEntry->base;
XpEventBase = extEntry->eventBase;
XpErrorBase = extEntry->errorBase;
- EventSwapVector[XpEventBase] = SwapXpNotifyEvent;
- EventSwapVector[XpEventBase+1] = SwapXpAttributeEvent;
+ EventSwapVector[XpEventBase] = (EventSwapPtr) SwapXpNotifyEvent;
+ EventSwapVector[XpEventBase+1] = (EventSwapPtr) SwapXpAttributeEvent;
}
if(XpGeneration != serverGeneration)
@@ -347,15 +336,15 @@ XpExtensionInit()
}
static void
-XpResetProc(extEntry)
- ExtensionEntry extEntry;
+XpResetProc(ExtensionEntry *extEntry)
{
- int i;
-
/*
* We can't free up the XpScreens recs here, because extensions are
* closed before screens, and our CloseScreen function uses the XpScreens
* recs.
+
+ int i;
+
for(i = 0; i < MAXSCREENS; i++)
{
if(XpScreens[i] != (XpScreenPtr)NULL)
@@ -366,11 +355,9 @@ XpResetProc(extEntry)
}
static Bool
-XpCloseScreen(index, pScreen)
- int index;
- ScreenPtr pScreen;
+XpCloseScreen(int index, ScreenPtr pScreen)
{
- Bool (* CloseScreen)();
+ Bool (* CloseScreen)(int, ScreenPtr);
CloseScreen = XpScreens[index]->CloseScreen;
if(XpScreens[index] != (XpScreenPtr)NULL)
@@ -399,9 +386,9 @@ XpCloseScreen(index, pScreen)
return (*CloseScreen)(index, pScreen);
}
+#if 0 /* NOT USED */
static void
-FreeScreenEntry(pScreenEntry)
- XpScreenPtr pScreenEntry;
+FreeScreenEntry(XpScreenPtr pScreenEntry)
{
XpDriverPtr pDriver;
@@ -416,6 +403,7 @@ FreeScreenEntry(pScreenEntry)
}
xfree(pScreenEntry);
}
+#endif
/*
* XpRegisterInitFunc tells the print extension which screens
@@ -426,24 +414,20 @@ FreeScreenEntry(pScreenEntry)
* whenever a context gets created for a particular driver on this screen.
*/
void
-XpRegisterInitFunc(pScreen, driverName, initContext)
- ScreenPtr pScreen;
- char *driverName;
- int (*initContext)();
+XpRegisterInitFunc(ScreenPtr pScreen, char *driverName, int (*initContext)(struct _XpContext *))
{
XpDriverPtr pDriver;
- if(XpScreens[pScreen->myNum] == (XpScreenPtr)NULL)
+ if(XpScreens[pScreen->myNum] == 0)
{
if((XpScreens[pScreen->myNum] =
- (XpScreenPtr) Xalloc(sizeof(XpScreenRec))) == (XpScreenPtr)NULL)
+ (XpScreenPtr) Xalloc(sizeof(XpScreenRec))) == 0)
return;
- XpScreens[pScreen->myNum]->CloseScreen = (Bool(*)())NULL;
- XpScreens[pScreen->myNum]->drivers = (XpDriverPtr)NULL;
+ XpScreens[pScreen->myNum]->CloseScreen = 0;
+ XpScreens[pScreen->myNum]->drivers = 0;
}
- if((pDriver = (XpDriverPtr)Xalloc(sizeof(XpDriverRec))) ==
- (XpDriverPtr)NULL)
+ if((pDriver = (XpDriverPtr)Xalloc(sizeof(XpDriverRec))) == 0)
return;
pDriver->next = XpScreens[pScreen->myNum]->drivers;
pDriver->name = driverName;
@@ -452,8 +436,7 @@ XpRegisterInitFunc(pScreen, driverName, initContext)
}
static int
-ProcXpDispatch(client)
- ClientPtr client;
+ProcXpDispatch(ClientPtr client)
{
REQUEST(xReq);
@@ -515,8 +498,7 @@ ProcXpDispatch(client)
}
static int
-ProcXpSwappedDispatch(client)
- ClientPtr client;
+ProcXpSwappedDispatch(ClientPtr client)
{
int temp;
REQUEST(xReq);
@@ -581,10 +563,9 @@ ProcXpSwappedDispatch(client)
}
static int
-ProcXpQueryVersion(client)
- ClientPtr client;
+ProcXpQueryVersion(ClientPtr client)
{
- REQUEST(xPrintQueryVersionReq);
+ /* REQUEST(xPrintQueryVersionReq); */
xPrintQueryVersionReply rep;
register int n;
long l;
@@ -614,12 +595,12 @@ ProcXpQueryVersion(client)
******************************************************************************/
static int
-ProcXpGetPrinterList(client)
- ClientPtr client;
+ProcXpGetPrinterList(ClientPtr client)
{
REQUEST(xPrintGetPrinterListReq);
- int totalSize, numEntries;
- XpDiListEntry **pList, *pEntry;
+ int totalSize;
+ int numEntries;
+ XpDiListEntry **pList;
xPrintGetPrinterListReply *rep;
int n, i, totalBytes;
long l;
@@ -699,10 +680,9 @@ ProcXpGetPrinterList(client)
******************************************************************************/
static int
-ProcXpQueryScreens(client)
- ClientPtr client;
+ProcXpQueryScreens(ClientPtr client)
{
- REQUEST(xPrintQueryScreensReq);
+ /* REQUEST(xPrintQueryScreensReq); */
int i, numPrintScreens, totalSize;
WINDOW *pWinId;
xPrintQueryScreensReply *rep;
@@ -752,8 +732,7 @@ ProcXpQueryScreens(client)
}
static int
-ProcXpGetPageDimensions(client)
- ClientPtr client;
+ProcXpGetPageDimensions(ClientPtr client)
{
REQUEST(xPrintGetPageDimensionsReq);
CARD16 width, height;
@@ -774,12 +753,12 @@ ProcXpGetPageDimensions(client)
return XpErrorBase+XPBadContext;
}
- if(pContext->funcs.GetMediumDimensions != (int (*)())NULL)
+ if(pContext->funcs.GetMediumDimensions != 0)
result = pContext->funcs.GetMediumDimensions(pContext, &width, &height);
else
return BadImplementation;
- if(pContext->funcs.GetReproducibleArea != (int (*)())NULL)
+ if(pContext->funcs.GetReproducibleArea != 0)
result = pContext->funcs.GetReproducibleArea(pContext, &rect);
else
return BadImplementation;
@@ -814,8 +793,7 @@ ProcXpGetPageDimensions(client)
}
static int
-ProcXpSetImageResolution(client)
- ClientPtr client;
+ProcXpSetImageResolution(ClientPtr client)
{
REQUEST(xPrintSetImageResolutionReq);
xPrintSetImageResolutionReply rep;
@@ -836,7 +814,7 @@ ProcXpSetImageResolution(client)
}
rep.prevRes = pContext->imageRes;
- if(pContext->funcs.SetImageResolution != (int (*)())NULL)
+ if(pContext->funcs.SetImageResolution != 0)
result = pContext->funcs.SetImageResolution(pContext,
(int)stuff->imageRes,
&status);
@@ -863,14 +841,11 @@ ProcXpSetImageResolution(client)
}
static int
-ProcXpGetImageResolution(client)
- ClientPtr client;
+ProcXpGetImageResolution(ClientPtr client)
{
REQUEST(xPrintGetImageResolutionReq);
xPrintGetImageResolutionReply rep;
XpContextPtr pContext;
- Bool status;
- int result;
REQUEST_SIZE_MATCH(xPrintGetImageResolutionReq);
@@ -912,10 +887,9 @@ ProcXpGetImageResolution(client)
******************************************************************************/
static int
-ProcXpRehashPrinterList(client)
- ClientPtr client;
+ProcXpRehashPrinterList(ClientPtr client)
{
- REQUEST(xPrintRehashPrinterListReq);
+ /* REQUEST(xPrintRehashPrinterListReq); */
REQUEST_SIZE_MATCH(xPrintRehashPrinterListReq);
@@ -950,15 +924,13 @@ ProcXpRehashPrinterList(client)
* is then called.
*/
static int
-ProcXpCreateContext(client)
- ClientPtr client;
+ProcXpCreateContext(ClientPtr client)
{
REQUEST(xPrintCreateContextReq);
XpScreenPtr pPrintScreen;
WindowPtr pRoot;
- char *printerName, *driverName;
+ char *driverName;
XpContextPtr pContext;
- XpClientPtr pNewPrintClient;
int result = Success;
XpDriverPtr pDriver;
@@ -969,7 +941,7 @@ ProcXpCreateContext(client)
/*
* Check to see if the printer name is valid.
*/
- if((pRoot = XpDiValidatePrinter(stuff + 1, stuff->printerNameLen)) ==
+ if((pRoot = XpDiValidatePrinter((char *)(stuff + 1), stuff->printerNameLen)) ==
(WindowPtr)NULL)
return BadMatch;
@@ -998,22 +970,22 @@ ProcXpCreateContext(client)
pContext->clientSlept = (ClientPtr)NULL;
pContext->imageRes = 0;
- pContext->funcs.DestroyContext = (int (*)())NULL;
- pContext->funcs.StartJob = (int (*)())NULL;
- pContext->funcs.EndJob = (int (*)())NULL;
- pContext->funcs.StartDoc = (int (*)())NULL;
- pContext->funcs.EndDoc = (int (*)())NULL;
- pContext->funcs.StartPage = (int (*)())NULL;
- pContext->funcs.EndPage = (int (*)())NULL;
- pContext->funcs.PutDocumentData = (int (*)())NULL;
- pContext->funcs.GetDocumentData = (int (*)())NULL;
- pContext->funcs.GetAttributes = (char * (*)())NULL;
- pContext->funcs.GetOneAttribute = (char * (*)())NULL;
- pContext->funcs.SetAttributes = (int (*)())NULL;
- pContext->funcs.AugmentAttributes = (int (*)())NULL;
- pContext->funcs.GetMediumDimensions = (int (*)())NULL;
- pContext->funcs.GetReproducibleArea = (int (*)())NULL;
- pContext->funcs.SetImageResolution = (int (*)())NULL;
+ pContext->funcs.DestroyContext = 0;
+ pContext->funcs.StartJob = 0;
+ pContext->funcs.EndJob = 0;
+ pContext->funcs.StartDoc = 0;
+ pContext->funcs.EndDoc = 0;
+ pContext->funcs.StartPage = 0;
+ pContext->funcs.EndPage = 0;
+ pContext->funcs.PutDocumentData = 0;
+ pContext->funcs.GetDocumentData = 0;
+ pContext->funcs.GetAttributes = 0;
+ pContext->funcs.GetOneAttribute = 0;
+ pContext->funcs.SetAttributes = 0;
+ pContext->funcs.AugmentAttributes = 0;
+ pContext->funcs.GetMediumDimensions = 0;
+ pContext->funcs.GetReproducibleArea = 0;
+ pContext->funcs.SetImageResolution = 0;
if((pContext->printerName = (char *)xalloc(stuff->printerNameLen + 1)) ==
(char *)NULL)
@@ -1034,7 +1006,7 @@ ProcXpCreateContext(client)
{
if(!strcmp(driverName, pDriver->name))
{
- if(pDriver->CreateContext != (Bool (*)())NULL)
+ if(pDriver->CreateContext != 0)
pDriver->CreateContext(pContext);
else
return BadImplementation;
@@ -1053,8 +1025,7 @@ ProcXpCreateContext(client)
* and stashes the contextID in the client's devPrivate.
*/
static int
-ProcXpSetContext(client)
- ClientPtr client;
+ProcXpSetContext(ClientPtr client)
{
REQUEST(xPrintSetContextReq);
@@ -1111,22 +1082,18 @@ ProcXpSetContext(client)
}
XpContextPtr
-XpGetPrintContext(client)
- ClientPtr client;
+XpGetPrintContext(ClientPtr client)
{
return (client->devPrivates[XpClientPrivateIndex].ptr);
}
static int
-ProcXpGetContext(client)
- ClientPtr client;
+ProcXpGetContext(ClientPtr client)
{
- REQUEST(xPrintGetContextReq);
+ /* REQUEST(xPrintGetContextReq); */
xPrintGetContextReply rep;
XpContextPtr pContext;
- XpClientPtr pNewPrintClient;
- int result = Success;
register int n;
register long l;
@@ -1156,14 +1123,11 @@ ProcXpGetContext(client)
* to be called.
*/
static int
-ProcXpDestroyContext(client)
- ClientPtr client;
+ProcXpDestroyContext(ClientPtr client)
{
REQUEST(xPrintDestroyContextReq);
XpContextPtr pContext;
- XpClientPtr pXpClient;
- ClientPtr curClient;
REQUEST_SIZE_MATCH(xPrintDestroyContextReq);
@@ -1185,8 +1149,7 @@ ProcXpDestroyContext(client)
}
static int
-ProcXpGetContextScreen(client)
- ClientPtr client;
+ProcXpGetContextScreen(ClientPtr client)
{
REQUEST(xPrintGetContextScreenReq);
xPrintGetContextScreenReply rep;
@@ -1229,9 +1192,7 @@ ProcXpGetContextScreen(client)
* itself.
*/
static int
-XpFreeContext(data, id)
- pointer data;
- XID id;
+XpFreeContext(pointer data, XID id)
{
XpContextPtr pContext = (XpContextPtr)data;
@@ -1245,7 +1206,7 @@ XpFreeContext(data, id)
XpPagePtr pPage = (XpPagePtr)LookupIDByType(
pContext->pageWin, RTpage);
- pContext->funcs.EndPage(pContext, pWin, TRUE);
+ pContext->funcs.EndPage(pContext, pWin);
SendXpNotify(pContext, XPEndPageNotify, TRUE);
pContext->state &= ~PAGE_STARTED;
if(pPage)
@@ -1259,7 +1220,7 @@ XpFreeContext(data, id)
pContext->state &= ~DOC_RAW_STARTED;
pContext->state &= ~DOC_COOKED_STARTED;
}
- if(pContext->funcs.EndJob != (int (*)())NULL)
+ if(pContext->funcs.EndJob != 0)
{
pContext->funcs.EndJob(pContext, TRUE);
SendXpNotify(pContext, XPEndJobNotify, TRUE);
@@ -1272,7 +1233,7 @@ XpFreeContext(data, id)
* Tell the driver we're destroying the context
* This allows the driver to free and ContextPrivate data
*/
- if(pContext->funcs.DestroyContext != (int (*)())NULL)
+ if(pContext->funcs.DestroyContext != 0)
pContext->funcs.DestroyContext(pContext);
/* Free up all the XpClientRecs */
@@ -1291,11 +1252,10 @@ XpFreeContext(data, id)
* is freed. It simply calls the FreeXpClient routine to do the work.
*/
static int
-XpFreeClient(data, id)
- pointer data;
- XID id;
+XpFreeClient(pointer data, XID id)
{
FreeXpClient((XpClientPtr)data, TRUE);
+ return Success;
}
/*
@@ -1309,9 +1269,7 @@ XpFreeClient(data, id)
* XpClientRec's XID).
*/
static void
-FreeXpClient(pXpClient, freeResource)
- XpClientPtr pXpClient;
- Bool freeResource;
+FreeXpClient(XpClientPtr pXpClient, Bool freeResource)
{
XpClientPtr pCurrent, pPrev;
XpContextPtr pContext = pXpClient->context;
@@ -1355,8 +1313,7 @@ FreeXpClient(pXpClient, freeResource)
* freeing of the Rec when the client's connection is closed.
*/
static XpClientPtr
-CreateXpClient(client)
- ClientPtr client;
+CreateXpClient(ClientPtr client)
{
XpClientPtr pNewPrintClient;
XID clientResource;
@@ -1389,9 +1346,7 @@ CreateXpClient(client)
* the page resource.
*/
static int
-XpFreePage(data, id)
- pointer data;
- XID id;
+XpFreePage(pointer data, XID id)
{
XpPagePtr page = (XpPagePtr)data;
int result = Success;
@@ -1401,9 +1356,8 @@ XpFreePage(data, id)
if(page->context != (XpContextPtr)NULL &&
page->context->state & PAGE_STARTED)
{
- XpScreenPtr pPrintScreen = XpScreens[page->context->screenNum];
- if(page->context->funcs.EndPage != (int (*)())NULL)
- result = page->context->funcs.EndPage(page->context, pWin, TRUE);
+ if(page->context->funcs.EndPage != 0)
+ result = page->context->funcs.EndPage(page->context, pWin);
SendXpNotify(page->context, XPEndPageNotify, (int)TRUE);
page->context->pageWin = 0; /* None, NULL??? XXX */
}
@@ -1420,8 +1374,7 @@ XpFreePage(data, id)
*/
static void
-InitContextPrivates(context)
- XpContextPtr context;
+InitContextPrivates(XpContextPtr context)
{
register char *ptr;
DevUnion *ppriv;
@@ -1450,7 +1403,7 @@ InitContextPrivates(context)
}
static void
-ResetContextPrivates()
+ResetContextPrivates(void)
{
contextPrivateCount = 0;
contextPrivateLen = 0;
@@ -1461,15 +1414,13 @@ ResetContextPrivates()
}
int
-XpAllocateContextPrivateIndex()
+XpAllocateContextPrivateIndex(void)
{
return contextPrivateCount++;
}
Bool
-XpAllocateContextPrivate(index, amount)
- int index;
- unsigned amount;
+XpAllocateContextPrivate(int index, unsigned amount)
{
unsigned oldamount;
@@ -1497,9 +1448,7 @@ XpAllocateContextPrivate(index, amount)
}
static XpClientPtr
-AcquireClient(pContext, client)
- XpContextPtr pContext;
- ClientPtr client;
+AcquireClient(XpContextPtr pContext, ClientPtr client)
{
XpClientPtr pXpClient;
@@ -1517,9 +1466,7 @@ AcquireClient(pContext, client)
}
static XpClientPtr
-FindClient(pContext, client)
- XpContextPtr pContext;
- ClientPtr client;
+FindClient(XpContextPtr pContext, ClientPtr client)
{
XpClientPtr pXpClient;
@@ -1539,8 +1486,7 @@ FindClient(pContext, client)
******************************************************************************/
static int
-ProcXpStartJob(client)
- ClientPtr client;
+ProcXpStartJob(ClientPtr client)
{
REQUEST(xPrintStartJobReq);
XpContextPtr pContext;
@@ -1564,9 +1510,10 @@ ProcXpStartJob(client)
}
pPrintScreen = XpScreens[pContext->screenNum];
- if(pContext->funcs.StartJob != (int (*)())NULL)
+ if(pContext->funcs.StartJob != 0)
result = pContext->funcs.StartJob(pContext,
- (stuff->saveData == XPGetData)? TRUE:FALSE);
+ (stuff->saveData == XPGetData)? TRUE:FALSE,
+ client);
else
return BadImplementation;
@@ -1583,12 +1530,10 @@ ProcXpStartJob(client)
}
static int
-ProcXpEndJob(client)
- ClientPtr client;
+ProcXpEndJob(ClientPtr client)
{
REQUEST(xPrintEndJobReq);
XpScreenPtr pPrintScreen;
- WindowPtr pWin;
int result = Success;
XpContextPtr pContext;
@@ -1617,8 +1562,8 @@ ProcXpEndJob(client)
if(stuff->cancel != TRUE)
return XpErrorBase+XPBadSequence;
- if(pContext->funcs.EndPage != (int (*)())NULL)
- result = pContext->funcs.EndPage(pContext, pWin, TRUE);
+ if(pContext->funcs.EndPage != 0)
+ result = pContext->funcs.EndPage(pContext, pWin);
else
return BadImplementation;
@@ -1632,7 +1577,7 @@ ProcXpEndJob(client)
if(result != Success) return result;
}
- if(pContext->funcs.EndDoc != (int (*)())NULL)
+ if(pContext->funcs.EndDoc != 0)
result = pContext->funcs.EndDoc(pContext, stuff->cancel);
else
return BadImplementation;
@@ -1640,7 +1585,7 @@ ProcXpEndJob(client)
SendXpNotify(pContext, XPEndDocNotify, stuff->cancel);
}
- if(pContext->funcs.EndJob != (int (*)())NULL)
+ if(pContext->funcs.EndJob != 0)
result = pContext->funcs.EndJob(pContext, stuff->cancel);
else
return BadImplementation;
@@ -1656,9 +1601,7 @@ ProcXpEndJob(client)
}
static Bool
-DoStartDoc(client, c)
- ClientPtr client;
- XpStDocPtr c;
+DoStartDoc(ClientPtr client, XpStDocPtr c)
{
XpScreenPtr pPrintScreen;
int result = Success;
@@ -1670,7 +1613,7 @@ DoStartDoc(client, c)
if(!c->slept)
{
c->slept = TRUE;
- ClientSleep(client, DoStartDoc, (pointer) c);
+ ClientSleep(client, (ClientSleepProcPtr)DoStartDoc, (pointer) c);
c->pContext->clientSlept = client;
}
return TRUE;
@@ -1678,7 +1621,7 @@ DoStartDoc(client, c)
pPrintScreen = XpScreens[pContext->screenNum];
- if(pContext->funcs.StartDoc != (int (*)())NULL)
+ if(pContext->funcs.StartDoc != 0)
result = pContext->funcs.StartDoc(pContext, c->type);
else
{
@@ -1699,11 +1642,9 @@ DoStartDoc(client, c)
}
static int
-ProcXpStartDoc(client)
- ClientPtr client;
+ProcXpStartDoc(ClientPtr client)
{
REQUEST(xPrintStartDocReq);
- XpScreenPtr pPrintScreen;
int result = Success;
XpContextPtr pContext;
XpStDocPtr c;
@@ -1738,8 +1679,7 @@ ProcXpStartDoc(client)
}
static int
-ProcXpEndDoc(client)
- ClientPtr client;
+ProcXpEndDoc(ClientPtr client)
{
REQUEST(xPrintEndDocReq);
XpScreenPtr pPrintScreen;
@@ -1767,8 +1707,8 @@ ProcXpEndDoc(client)
XpPagePtr pPage = (XpPagePtr)LookupIDByType(
pContext->pageWin, RTpage);
- if(pContext->funcs.EndPage != (int (*)())NULL)
- result = pContext->funcs.EndPage(pContext, pWin, TRUE);
+ if(pContext->funcs.EndPage != 0)
+ result = pContext->funcs.EndPage(pContext, pWin);
else
return BadImplementation;
@@ -1783,7 +1723,7 @@ ProcXpEndDoc(client)
return result;
}
- if(pContext->funcs.EndDoc != (int (*)())NULL)
+ if(pContext->funcs.EndDoc != 0)
result = pContext->funcs.EndDoc(pContext, stuff->cancel);
else
return BadImplementation;
@@ -1800,9 +1740,9 @@ ProcXpEndDoc(client)
}
static Bool
-DoStartPage(client, c)
- ClientPtr client;
- XpStPagePtr c;
+DoStartPage(
+ ClientPtr client,
+ XpStPagePtr c)
{
XpScreenPtr pPrintScreen;
WindowPtr pWin = c->pWin;
@@ -1816,7 +1756,7 @@ DoStartPage(client, c)
if(!c->slept)
{
c->slept = TRUE;
- ClientSleep(client, DoStartPage, (pointer) c);
+ ClientSleep(client, (ClientSleepProcPtr)DoStartPage, (pointer) c);
c->pContext->clientSlept = client;
}
return TRUE;
@@ -1825,7 +1765,7 @@ DoStartPage(client, c)
if(!(pContext->state & DOC_COOKED_STARTED))
{
/* Implied StartDoc if it was omitted */
- if(pContext->funcs.StartDoc != (int (*)())NULL)
+ if(pContext->funcs.StartDoc != 0)
result = pContext->funcs.StartDoc(pContext, XPDocNormal);
else
{
@@ -1878,7 +1818,7 @@ DoStartPage(client, c)
pPrintScreen = XpScreens[pContext->screenNum];
- if(pContext->funcs.StartPage != (int (*)())NULL)
+ if(pContext->funcs.StartPage != 0)
result = pContext->funcs.StartPage(pContext, pWin);
else
{
@@ -1897,15 +1837,12 @@ DoStartPage(client, c)
}
static int
-ProcXpStartPage(client)
- ClientPtr client;
+ProcXpStartPage(ClientPtr client)
{
REQUEST(xPrintStartPageReq);
- XpScreenPtr pPrintScreen;
WindowPtr pWin;
int result = Success;
XpContextPtr pContext;
- XpPagePtr pPage;
XpStPagePtr c;
REQUEST_SIZE_MATCH(xPrintStartPageReq);
@@ -1944,8 +1881,7 @@ ProcXpStartPage(client)
}
static int
-ProcXpEndPage(client)
- ClientPtr client;
+ProcXpEndPage(ClientPtr client)
{
REQUEST(xPrintEndPageReq);
XpScreenPtr pPrintScreen;
@@ -1967,8 +1903,8 @@ ProcXpEndPage(client)
pWin = (WindowPtr )LookupIDByType(pContext->pageWin, RT_WINDOW);
/* Call the ddx's EndPage proc. */
- if(pContext->funcs.EndPage != (int (*)())NULL)
- result = pContext->funcs.EndPage(pContext, pWin, stuff->cancel);
+ if(pContext->funcs.EndPage != 0)
+ result = pContext->funcs.EndPage(pContext, pWin);
else
return BadImplementation;
@@ -1996,14 +1932,13 @@ ProcXpEndPage(client)
******************************************************************************/
static int
-ProcXpPutDocumentData(client)
- ClientPtr client;
+ProcXpPutDocumentData(ClientPtr client)
{
REQUEST(xPrintPutDocumentDataReq);
XpContextPtr pContext;
DrawablePtr pDraw;
int result = Success;
- int len, totalSize;
+ unsigned totalSize;
char *pData, *pDoc_fmt, *pOptions;
REQUEST_AT_LEAST_SIZE(xPrintPutDocumentDataReq);
@@ -2040,7 +1975,7 @@ ProcXpPutDocumentData(client)
if((totalSize + (sz_xPrintPutDocumentDataReq >> 2)) != client->req_len)
return BadLength;
- if(pContext->funcs.PutDocumentData != (int (*)())NULL)
+ if(pContext->funcs.PutDocumentData != 0)
{
result = (*pContext->funcs.PutDocumentData)(pContext, pDraw,
pData, stuff->len_data,
@@ -2058,12 +1993,10 @@ ProcXpPutDocumentData(client)
}
static int
-ProcXpGetDocumentData(client)
- ClientPtr client;
+ProcXpGetDocumentData(ClientPtr client)
{
REQUEST(xPrintGetDocumentDataReq);
xPrintGetDocumentDataReply rep;
- XpScreenPtr pPrintScreen;
XpContextPtr pContext;
int result = Success;
@@ -2079,7 +2012,7 @@ ProcXpGetDocumentData(client)
return XpErrorBase+XPBadContext;
}
- if(pContext->funcs.GetDocumentData == (int (*)())NULL)
+ if(pContext->funcs.GetDocumentData == 0)
return BadImplementation;
if(!(pContext->state & JOB_GET_DATA) ||
@@ -2132,8 +2065,7 @@ ProcXpGetDocumentData(client)
******************************************************************************/
static int
-ProcXpGetAttributes(client)
- ClientPtr client;
+ProcXpGetAttributes(ClientPtr client)
{
REQUEST(xPrintGetAttributesReq);
XpContextPtr pContext;
@@ -2163,7 +2095,7 @@ ProcXpGetAttributes(client)
return XpErrorBase+XPBadContext;
}
- if(pContext->funcs.GetAttributes == (char *(*)())NULL)
+ if(pContext->funcs.GetAttributes == 0)
return BadImplementation;
if((attrs = (*pContext->funcs.GetAttributes)(pContext, stuff->type)) ==
(char *)NULL)
@@ -2203,8 +2135,7 @@ ProcXpGetAttributes(client)
}
static int
-ProcXpSetAttributes(client)
- ClientPtr client;
+ProcXpSetAttributes(ClientPtr client)
{
REQUEST(xPrintSetAttributesReq);
int result = Success;
@@ -2236,7 +2167,7 @@ ProcXpSetAttributes(client)
return XpErrorBase+XPBadContext;
}
- if(pContext->funcs.SetAttributes == (int (*)())NULL)
+ if(pContext->funcs.SetAttributes == 0)
return BadImplementation;
/*
@@ -2275,14 +2206,14 @@ ProcXpSetAttributes(client)
}
static int
-ProcXpGetOneAttribute(client)
- ClientPtr client;
+ProcXpGetOneAttribute(ClientPtr client)
{
REQUEST(xPrintGetOneAttributeReq);
XpContextPtr pContext;
char *value, *attrName;
xPrintGetOneAttributeReply *pRep;
- int totalSize, n;
+ int totalSize;
+ int n;
unsigned long l;
REQUEST_AT_LEAST_SIZE(xPrintGetOneAttributeReq);
@@ -2316,7 +2247,7 @@ ProcXpGetOneAttribute(client)
return XpErrorBase+XPBadContext;
}
- if(pContext->funcs.GetOneAttribute == (char *(*)())NULL)
+ if(pContext->funcs.GetOneAttribute == 0)
return BadImplementation;
if((value = (*pContext->funcs.GetOneAttribute)(pContext, stuff->type,
attrName)) == (char *)NULL)
@@ -2364,8 +2295,7 @@ ProcXpGetOneAttribute(client)
static int
-ProcXpSelectInput(client)
- ClientPtr client;
+ProcXpSelectInput(ClientPtr client)
{
REQUEST(xPrintSelectInputReq);
int result = Success;
@@ -2403,14 +2333,12 @@ ProcXpSelectInput(client)
}
static int
-ProcXpInputSelected(client)
- ClientPtr client;
+ProcXpInputSelected(ClientPtr client)
{
REQUEST(xPrintInputSelectedReq);
xPrintInputSelectedReply rep;
register int n;
- long l, allMask;
- WindowPtr pWin;
+ long l;
XpClientPtr pXpClient;
XpContextPtr pContext;
@@ -2446,9 +2374,7 @@ ProcXpInputSelected(client)
}
static void
-SendAttributeNotify(pContext, which)
- XpContextPtr pContext;
- int which;
+SendAttributeNotify(XpContextPtr pContext, int which)
{
XpClientPtr pXpClient;
xPrintAttributeEvent ae;
@@ -2473,11 +2399,9 @@ SendAttributeNotify(pContext, which)
WriteEventsToClient (client, 1, (xEvent *) &ae);
}
}
+
static void
-SendXpNotify(pContext, which, val)
- XpContextPtr pContext;
- int which;
- int val;
+SendXpNotify(XpContextPtr pContext, int which, int val)
{
XpClientPtr pXpClient;
xPrintPrintEvent pe;
@@ -2505,8 +2429,7 @@ SendXpNotify(pContext, which, val)
}
static CARD32
-GetAllEventMasks(pContext)
- XpContextPtr pContext;
+GetAllEventMasks(XpContextPtr pContext)
{
XpClientPtr pPrintClient;
CARD32 totalMask = (CARD32)0;
@@ -2526,11 +2449,8 @@ GetAllEventMasks(pContext)
* does not currently have a context set.
*/
XpContextPtr
-XpContextOfClient(client)
- ClientPtr client;
+XpContextOfClient(ClientPtr client)
{
- XpContextPtr pContext;
-
return (XpContextPtr)client->devPrivates[XpClientPrivateIndex].ptr;
}
@@ -2542,8 +2462,7 @@ XpContextOfClient(client)
******************************************************************************/
static int
-SProcXpCreateContext(client)
- ClientPtr client;
+SProcXpCreateContext(ClientPtr client)
{
int i;
long n;
@@ -2558,8 +2477,7 @@ SProcXpCreateContext(client)
}
static int
-SProcXpGetPrinterList(client)
- ClientPtr client;
+SProcXpGetPrinterList(ClientPtr client)
{
int i;
long n;
@@ -2573,11 +2491,9 @@ SProcXpGetPrinterList(client)
}
static int
-SProcXpRehashPrinterList(client)
- ClientPtr client;
+SProcXpRehashPrinterList(ClientPtr client)
{
int i;
- long n;
REQUEST(xPrintRehashPrinterListReq);
swaps(&stuff->length, i);
@@ -2585,11 +2501,9 @@ SProcXpRehashPrinterList(client)
}
static int
-SProcXpSetContext(client)
- ClientPtr client;
+SProcXpSetContext(ClientPtr client)
{
int i;
- long n;
REQUEST(xPrintSetContextReq);
swaps(&stuff->length, i);
@@ -2598,8 +2512,7 @@ SProcXpSetContext(client)
}
static int
-SProcXpGetContext(client)
- ClientPtr client;
+SProcXpGetContext(ClientPtr client)
{
int i;
@@ -2609,8 +2522,7 @@ SProcXpGetContext(client)
}
static int
-SProcXpDestroyContext(client)
- ClientPtr client;
+SProcXpDestroyContext(ClientPtr client)
{
int i;
long n;
@@ -2622,8 +2534,7 @@ SProcXpDestroyContext(client)
}
static int
-SProcXpGetContextScreen(client)
- ClientPtr client;
+SProcXpGetContextScreen(ClientPtr client)
{
int i;
long n;
@@ -2635,8 +2546,7 @@ SProcXpGetContextScreen(client)
}
static int
-SProcXpInputSelected(client)
- ClientPtr client;
+SProcXpInputSelected(ClientPtr client)
{
int i;
long n;
@@ -2648,8 +2558,7 @@ SProcXpInputSelected(client)
}
static int
-SProcXpStartJob(client)
- ClientPtr client;
+SProcXpStartJob(ClientPtr client)
{
int i;
@@ -2659,8 +2568,7 @@ SProcXpStartJob(client)
}
static int
-SProcXpEndJob(client)
- ClientPtr client;
+SProcXpEndJob(ClientPtr client)
{
int i;
@@ -2670,8 +2578,7 @@ SProcXpEndJob(client)
}
static int
-SProcXpStartDoc(client)
- ClientPtr client;
+SProcXpStartDoc(ClientPtr client)
{
int i;
@@ -2681,8 +2588,7 @@ SProcXpStartDoc(client)
}
static int
-SProcXpEndDoc(client)
- ClientPtr client;
+SProcXpEndDoc(ClientPtr client)
{
int i;
@@ -2692,8 +2598,7 @@ SProcXpEndDoc(client)
}
static int
-SProcXpStartPage(client)
- ClientPtr client;
+SProcXpStartPage(ClientPtr client)
{
int i;
long n;
@@ -2705,8 +2610,7 @@ SProcXpStartPage(client)
}
static int
-SProcXpEndPage(client)
- ClientPtr client;
+SProcXpEndPage(ClientPtr client)
{
int i;
@@ -2716,8 +2620,7 @@ SProcXpEndPage(client)
}
static int
-SProcXpPutDocumentData(client)
- ClientPtr client;
+SProcXpPutDocumentData(ClientPtr client)
{
long n;
int i;
@@ -2732,8 +2635,7 @@ SProcXpPutDocumentData(client)
}
static int
-SProcXpGetDocumentData(client)
- ClientPtr client;
+SProcXpGetDocumentData(ClientPtr client)
{
long n;
int i;
@@ -2746,8 +2648,7 @@ SProcXpGetDocumentData(client)
}
static int
-SProcXpGetAttributes(client)
- ClientPtr client;
+SProcXpGetAttributes(ClientPtr client)
{
long n;
int i;
@@ -2759,8 +2660,7 @@ SProcXpGetAttributes(client)
}
static int
-SProcXpSetAttributes(client)
- ClientPtr client;
+SProcXpSetAttributes(ClientPtr client)
{
long n;
int i;
@@ -2773,8 +2673,7 @@ SProcXpSetAttributes(client)
}
static int
-SProcXpGetOneAttribute(client)
- ClientPtr client;
+SProcXpGetOneAttribute(ClientPtr client)
{
long n;
int i;
@@ -2787,8 +2686,7 @@ SProcXpGetOneAttribute(client)
}
static int
-SProcXpSelectInput(client)
- ClientPtr client;
+SProcXpSelectInput(ClientPtr client)
{
long n;
int i;
@@ -2799,9 +2697,9 @@ SProcXpSelectInput(client)
swapl(&stuff->printContext, n);
return ProcXpSelectInput(client);
}
+
static int
-SProcXpGetPageDimensions(client)
- ClientPtr client;
+SProcXpGetPageDimensions(ClientPtr client)
{
long n;
int i;
@@ -2811,9 +2709,9 @@ SProcXpGetPageDimensions(client)
swapl(&stuff->printContext, n);
return ProcXpGetPageDimensions(client);
}
+
static int
-SProcXpSetImageResolution(client)
- ClientPtr client;
+SProcXpSetImageResolution(ClientPtr client)
{
long n;
int i;
@@ -2824,9 +2722,9 @@ SProcXpSetImageResolution(client)
swaps(&stuff->imageRes, i);
return ProcXpSetImageResolution(client);
}
+
static int
-SProcXpGetImageResolution(client)
- ClientPtr client;
+SProcXpGetImageResolution(ClientPtr client)
{
long n;
int i;
@@ -2838,8 +2736,7 @@ SProcXpGetImageResolution(client)
}
static void
-SwapXpNotifyEvent(src, dst)
- xPrintPrintEvent *src, *dst;
+SwapXpNotifyEvent(xPrintPrintEvent *src, xPrintPrintEvent *dst)
{
/*
* Swap the sequence number and context fields.
@@ -2856,8 +2753,7 @@ SwapXpNotifyEvent(src, dst)
}
static void
-SwapXpAttributeEvent(src, dst)
- xPrintAttributeEvent *src, *dst;
+SwapXpAttributeEvent(xPrintAttributeEvent *src, xPrintAttributeEvent *dst)
{
/*
* Swap the sequence number and context fields.
diff --git a/Xext/xtest.c b/Xext/xtest.c
index a07cf6186..47e7418d8 100644
--- a/Xext/xtest.c
+++ b/Xext/xtest.c
@@ -26,6 +26,7 @@ other dealings in this Software without prior written authorization
from The Open Group.
*/
+/* $XFree86: xc/programs/Xserver/Xext/xtest.c,v 3.7 2001/12/14 19:58:51 dawes Exp $ */
#include "X.h"
#define NEED_EVENTS
@@ -37,6 +38,8 @@ from The Open Group.
#include "windowstr.h"
#include "inputstr.h"
#include "scrnintstr.h"
+#include "dixevents.h"
+#include "sleepuntil.h"
#define _XTEST_SERVER_
#include "XTest.h"
#include "xteststr.h"
@@ -44,27 +47,49 @@ from The Open Group.
#include "XI.h"
#include "XIproto.h"
#define EXTENSION_EVENT_BASE 64
+#include "extinit.h" /* LookupDeviceIntRec */
#endif /* XINPUT */
+#ifdef EXTMODULE
+#include "xf86_ansic.h"
+#endif
static unsigned char XTestReqCode;
-static int ProcXTestDispatch(), SProcXTestDispatch();
-static void XTestResetProc();
-static int XTestSwapFakeInput();
-CursorPtr GetSpriteCursor();
-WindowPtr GetCurrentRootWindow();
+
#ifdef XINPUT
extern int DeviceValuator;
-DeviceIntPtr LookupDeviceIntRec();
#endif /* XINPUT */
+static void XTestResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* extEntry */
+#endif
+);
+static int XTestSwapFakeInput(
+#if NeedFunctionPrototypes
+ ClientPtr /* client */,
+ xReq * /* req */
+#endif
+);
+
+static DISPATCH_PROC(ProcXTestCompareCursor);
+static DISPATCH_PROC(ProcXTestDispatch);
+static DISPATCH_PROC(ProcXTestFakeInput);
+static DISPATCH_PROC(ProcXTestGetVersion);
+static DISPATCH_PROC(ProcXTestGrabControl);
+static DISPATCH_PROC(SProcXTestCompareCursor);
+static DISPATCH_PROC(SProcXTestDispatch);
+static DISPATCH_PROC(SProcXTestFakeInput);
+static DISPATCH_PROC(SProcXTestGetVersion);
+static DISPATCH_PROC(SProcXTestGrabControl);
+
void
XTestExtensionInit()
{
- ExtensionEntry *extEntry, *AddExtension();
+ ExtensionEntry *extEntry;
- if (extEntry = AddExtension(XTestExtensionName, 0, 0,
+ if ((extEntry = AddExtension(XTestExtensionName, 0, 0,
ProcXTestDispatch, SProcXTestDispatch,
- XTestResetProc, StandardMinorOpcode))
+ XTestResetProc, StandardMinorOpcode)) != 0)
XTestReqCode = (unsigned char)extEntry->base;
}
@@ -79,7 +104,6 @@ static int
ProcXTestGetVersion(client)
register ClientPtr client;
{
- REQUEST(xXTestGetVersionReq);
xXTestGetVersionReply rep;
register int n;
@@ -142,12 +166,12 @@ ProcXTestFakeInput(client)
int nev;
int n;
xEvent *ev;
- DeviceIntPtr dev;
+ DeviceIntPtr dev = NULL;
WindowPtr root;
int type;
#ifdef XINPUT
Bool extension = FALSE;
- deviceValuator *dv;
+ deviceValuator *dv = NULL;
int base;
int *values;
#endif /* XINPUT */
@@ -468,7 +492,7 @@ XTestSwapFakeInput(client, req)
register int nev;
register xEvent *ev;
xEvent sev;
- void (*proc)(), NotImplemented();
+ EventSwapPtr proc;
nev = ((req->length << 2) - sizeof(xReq)) / sizeof(xEvent);
for (ev = (xEvent *)&req[1]; --nev >= 0; ev++)
@@ -476,7 +500,7 @@ XTestSwapFakeInput(client, req)
/* Swap event */
proc = EventSwapVector[ev->u.u.type & 0177];
/* no swapping proc; invalid event type? */
- if (!proc || (int (*)()) proc == (int (*)()) NotImplemented) {
+ if (!proc || proc == NotImplemented) {
client->errorValue = ev->u.u.type;
return BadValue;
}
diff --git a/Xext/xtest1dd.c b/Xext/xtest1dd.c
index 38c977557..8a2b779be 100644
--- a/Xext/xtest1dd.c
+++ b/Xext/xtest1dd.c
@@ -52,6 +52,7 @@ Telephone and Telegraph Company or of the Regents of the
University of California.
*/
+/* $XFree86: xc/programs/Xserver/Xext/xtest1dd.c,v 3.5 2001/12/14 19:58:52 dawes Exp $ */
/***************************************************************
* include files
@@ -70,6 +71,8 @@ University of California.
#define XTestSERVER_SIDE
#include "xtestext1.h"
+#include "xtest1dd.h"
+
/***************************************************************
* defines
***************************************************************/
@@ -96,8 +99,6 @@ extern int XTestFakeAckType;
/*
* used in the WriteReplyToClient macro
*/
-extern void (* ReplySwapVector[256]) ();
-
extern int exclusive_steal;
/***************************************************************
@@ -286,24 +287,62 @@ KeyCode xtest_command_key = 0;
* function declarations
***************************************************************/
-void flush_input_actions();
-void XTestStealJumpData();
-void XTestGenerateEvent();
-void XTestGetPointerPos();
-void XTestJumpPointer();
-
-static void parse_key_fake();
-static void parse_motion_fake();
-static void parse_jump_fake();
-static void parse_delay_fake();
-static void send_ack();
-static void start_play_clock();
-static void compute_action_time();
-static int find_residual_time();
+static void parse_key_fake(
+#if NeedFunctionPrototypes
+ XTestKeyInfo * /* fkey */
+#endif
+ );
+static void parse_motion_fake(
+#if NeedFunctionPrototypes
+ XTestMotionInfo * /* fmotion */
+#endif
+ );
+static void parse_jump_fake(
+#if NeedFunctionPrototypes
+ XTestJumpInfo * /* fjump */
+#endif
+ );
+static void parse_delay_fake(
+#if NeedFunctionPrototypes
+ XTestDelayInfo * /* tevent */
+#endif
+ );
+static void send_ack(
+#if NeedFunctionPrototypes
+ ClientPtr /* client */
+#endif
+ );
+static void start_play_clock(
+#if NeedFunctionPrototypes
+ void
+#endif
+ );
+static void compute_action_time(
+#if NeedFunctionPrototypes
+ struct timeval * /* rtime */
+#endif
+ );
+static int find_residual_time(
+#if NeedFunctionPrototypes
+ struct timeval * /* rtime */
+#endif
+ );
-static CARD16 check_time_event();
-static CARD32 current_ms();
-static int there_is_room();
+static CARD16 check_time_event(
+#if NeedFunctionPrototypes
+ void
+#endif
+ );
+static CARD32 current_ms(
+#if NeedFunctionPrototypes
+ struct timeval * /* otime */
+#endif
+ );
+static int there_is_room(
+#if NeedFunctionPrototypes
+ int /* actsize */
+#endif
+ );
/******************************************************************************
*
@@ -450,8 +489,8 @@ XTestStealJumpData(jx, jy, dev_type)
/*
* the x and y coordinates to jump to
*/
-short jx;
-short jy;
+int jx;
+int jy;
/*
* which device caused the jump
*/
@@ -527,7 +566,7 @@ current_ms(otime)
struct timeval *otime;
{
struct timeval tval;
- unsigned long ctime;
+ unsigned long the_ms;
unsigned long sec;
unsigned long usec;
@@ -556,8 +595,8 @@ struct timeval *otime;
* compute the number of milliseconds contained in
* 'sec' seconds and 'usec' microseconds
*/
- ctime = (sec * 1000000 + usec) / 1000;
- return (ctime);
+ the_ms = (sec * 1000000L + usec) / 1000L;
+ return (the_ms);
}
/******************************************************************************
@@ -673,8 +712,8 @@ XTestStealMotionData(dx, dy, dev_type, mx, my)
/*
* the x and y delta motion of the locator
*/
-short dx;
-short dy;
+int dx;
+int dy;
/*
* which locator did the moving
*/
@@ -682,8 +721,8 @@ int dev_type;
/*
* the x and y position of the locator before the delta motion
*/
-short mx;
-short my;
+int mx;
+int my;
{
/*
* pointer to a XTestMOTION_ACTION input action
@@ -791,20 +830,20 @@ XTestStealKeyData(keycode, keystate, dev_type, locx, locy)
/*
* which key/button moved
*/
-CARD8 keycode;
+unsigned keycode;
/*
* whether the key/button was pressed or released
*/
-char keystate;
+int keystate;
/*
* which device caused the input action
*/
-int dev_type;
+int dev_type;
/*
* the x and y coordinates of the locator when the action happenned
*/
-short locx;
-short locy;
+int locx;
+int locy;
{
/*
* pointer to key/button motion input action
@@ -814,7 +853,7 @@ short locy;
* time delta from previous event
*/
CARD16 tchar;
- char keytrans;
+ char keytrans = 0;
/*
* update the logical position of the locator if the physical position
@@ -1445,8 +1484,8 @@ struct timeval *rtime;
* the current time.
*/
static int
-find_residual_time(rtime)
-struct timeval *rtime;
+find_residual_time(the_residual)
+struct timeval *the_residual;
{
/*
* if > 0, there is time to wait. If < 0, then don't wait
@@ -1507,8 +1546,8 @@ struct timeval *rtime;
}
else
{
- rtime->tv_usec = pusec - busec;
- rtime->tv_sec = 0;
+ the_residual->tv_usec = pusec - busec;
+ the_residual->tv_sec = 0;
}
}
else
@@ -1519,14 +1558,14 @@ struct timeval *rtime;
* 'borrow' a second's worth of microseconds
* from the seconds left to wait
*/
- rtime->tv_usec = 1000000 - busec + pusec;
+ the_residual->tv_usec = 1000000 - busec + pusec;
psec--;
- rtime->tv_sec = psec - bsec;
+ the_residual->tv_sec = psec - bsec;
}
else
{
- rtime->tv_sec = psec - bsec;
- rtime->tv_usec = pusec - busec;
+ the_residual->tv_sec = psec - bsec;
+ the_residual->tv_usec = pusec - busec;
}
}
}
@@ -1540,8 +1579,8 @@ struct timeval *rtime;
/*
* set the time to wait to 0
*/
- rtime->tv_sec = 0;
- rtime->tv_usec = 0;
+ the_residual->tv_sec = 0;
+ the_residual->tv_usec = 0;
}
return(wait);
}
diff --git a/Xext/xtest1di.c b/Xext/xtest1di.c
index cd8f5e727..43c1d58d1 100644
--- a/Xext/xtest1di.c
+++ b/Xext/xtest1di.c
@@ -52,6 +52,7 @@ Telephone and Telegraph Company or of the Regents of the
University of California.
*/
+/* $XFree86: xc/programs/Xserver/Xext/xtest1di.c,v 3.3 2001/12/14 19:58:52 dawes Exp $ */
/*****************************************************************************
* include files
@@ -72,6 +73,8 @@ University of California.
#define XTestSERVER_SIDE
#include "xtestext1.h"
+#include "xtest1dd.h"
+
/*****************************************************************************
* defines
****************************************************************************/
@@ -81,10 +84,6 @@ University of California.
****************************************************************************/
/*
- * holds the addresses of the routines that handle byte-swapping of replys
- */
-extern void (* ReplySwapVector[256]) ();
-/*
* id of client using XTestGetInput
*
* defined in xtest1dd.c
@@ -137,31 +136,44 @@ static XID current_client_id;
* function declarations
****************************************************************************/
-static int ProcXTestDispatch();
-static int SProcXTestDispatch();
-static void XTestResetProc();
-static int ProcTestFakeInput();
-static int SProcTestFakeInput();
-static int ProcTestGetInput();
-static int SProcTestGetInput();
-static int ProcTestStopInput();
-static int SProcTestStopInput();
-static int ProcTestReset();
-static int SProcTestReset();
-static int ProcTestQueryInputSize();
-static int SProcTestQueryInputSize();
-static void SReplyXTestDispatch();
-static void SEventXTestDispatch();
-void NotImplemented();
-
-void abort_play_back();
-void return_input_array_size();
-void steal_input();
-void stop_stealing_input();
-void flush_input_actions();
-void parse_fake_input();
-
-static int XTestCurrentClientGone();
+static DISPATCH_PROC(ProcXTestDispatch);
+static DISPATCH_PROC(SProcXTestDispatch);
+static DISPATCH_PROC(ProcTestFakeInput);
+static DISPATCH_PROC(SProcTestFakeInput);
+static DISPATCH_PROC(ProcTestGetInput);
+static DISPATCH_PROC(SProcTestGetInput);
+static DISPATCH_PROC(ProcTestStopInput);
+static DISPATCH_PROC(SProcTestStopInput);
+static DISPATCH_PROC(ProcTestReset);
+static DISPATCH_PROC(SProcTestReset);
+static DISPATCH_PROC(ProcTestQueryInputSize);
+static DISPATCH_PROC(SProcTestQueryInputSize);
+
+static void XTestResetProc(
+#if NeedFunctionPrototypes
+ ExtensionEntry * /* unused */
+#endif
+ );
+static void SReplyXTestDispatch(
+#if NeedFunctionPrototypes
+ ClientPtr /* client_ptr */,
+ int /* size */,
+ char * /* reply_ptr */
+#endif
+ );
+static void SEventXTestDispatch(
+#if NeedFunctionPrototypes
+ xEvent * /* from */,
+ xEvent * /* to */
+#endif
+ );
+
+static int XTestCurrentClientGone(
+#if NeedFunctionPrototypes
+ pointer /* value */,
+ XID /* id */
+#endif
+ );
/*****************************************************************************
*
@@ -180,10 +192,6 @@ XTestExtension1Init()
* holds the pointer to the extension entry structure
*/
ExtensionEntry *extEntry;
- /*
- * This routine adds the extension to the server extension table.
- */
- ExtensionEntry *AddExtension();
extEntry = AddExtension(XTestEXTENSION_NAME,
XTestEVENT_COUNT,
@@ -213,7 +221,7 @@ XTestExtension1Init()
* install the routine to handle byte-swapping the replies
* for this extension in the ReplySwapVector table
*/
- ReplySwapVector[XTestReqCode] = SReplyXTestDispatch;
+ ReplySwapVector[XTestReqCode] = (ReplySwapPtr) SReplyXTestDispatch;
/*
* install the routine to handle byte-swapping the events
* for this extension in the EventSwapVector table
@@ -647,7 +655,6 @@ static int
ProcTestStopInput(client)
register ClientPtr client;
{
- REQUEST(xTestStopInputReq);
REQUEST_SIZE_MATCH(xTestStopInputReq);
if (on_steal_input && (current_xtest_client == client))
{
@@ -686,7 +693,6 @@ static int
ProcTestReset(client)
register ClientPtr client;
{
- REQUEST(xTestResetReq);
REQUEST_SIZE_MATCH(xTestResetReq);
on_steal_input = FALSE;
exclusive_steal = FALSE;
@@ -711,7 +717,6 @@ static int
ProcTestQueryInputSize(client)
register ClientPtr client;
{
- REQUEST(xTestQueryInputSizeReq);
REQUEST_SIZE_MATCH(xTestQueryInputSizeReq);
/*
* defined in xtest1dd.c
@@ -728,14 +733,16 @@ ProcTestQueryInputSize(client)
* connected to it. It must put eveything back the way it was before
* this extension was installed.
*/
+/*ARGSUSED*/
static void
-XTestResetProc()
+XTestResetProc(unused)
+ ExtensionEntry * unused;
{
/*
* remove the routine to handle byte-swapping the replies
* for this extension in the ReplySwapVector table
*/
- ReplySwapVector[XTestReqCode] = NotImplemented;
+ ReplySwapVector[XTestReqCode] = ReplyNotSwappd;
/*
* remove the routine to handle byte-swapping the events
* for this extension in the EventSwapVector table
@@ -755,7 +762,7 @@ XTestResetProc()
/*****************************************************************************
*
- * ProcTestQueryInputSize
+ * PXTestCurrentClientGone
*
* This routine is called when a client that has asked for input actions
* to be sent to it "goes away". This routine must clean up the
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-19 23:39:13 +0000