Populate branch.lg3d-dev

1 files changed, 762 insertions, 0 deletions

diff --git a/Xext/lge.c b/Xext/lge.c
new file mode 100644
index 000000000..5702f98f5
--- /dev/null
+++ b/Xext/lge.c
@@ -0,0 +1,762 @@
+/************************************************************
+
+Copyright (c) 2004, Sun Microsystems, Inc. 
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+#ifdef LG3D
+
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include <unistd.h>
+#include "X.h"
+#include "Xproto.h"
+#include "misc.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "cursorstr.h"
+#include "inputstr.h"
+#include "lgewire.h"
+#include "lgeint.h"
+
+int lgeDisplayServerIsAlive = 0;
+
+ClientPtr lgePickerClient = NULL;
+ClientPtr lgeEventDelivererClient = NULL;
+int lgeEventComesFromDS = 0;
+
+/*
+** If sendEventDirect == true we will call the core process event 
+** routine directly. The event will not be subject to queue freezing. 
+** If sendEventDirect == false we will reinsert the event via the 
+** device's processInputProc routine. This means that the event will
+** be subject to queue freezing. That is to say, if the queue is currently
+** frozen due to a synchronous grab the event will be enqueued and not
+** sent further up the event pipeline until the queue is unfrozen.
+*/
+
+Bool lgeSendEventDirect = FALSE;
+
+DeviceIntPtr lgekb = NULL;
+DeviceIntPtr lgems = NULL;
+
+/* The pseudo-root window of first screen */
+Window lgeDisplayServerPRW = INVALID;
+WindowPtr pLgeDisplayServerPRWWin = NULL;
+
+Window lgeDisplayServerPRWsList[MAXSCREENS];
+WindowPtr pLgeDisplayServerPRWWinsList[MAXSCREENS];
+WindowPtr pLgeDisplayServerPRWWinRoots[MAXSCREENS];
+
+static int numRegisteredScr = 0;
+
+static int  LgeReqCode;
+
+void LgeExtensionInit (void);
+int LgeShutdownDisplayServer (pointer data, XID id);
+int ProcLgeDispatch (ClientPtr client);
+int SProcLgeDispatch (ClientPtr client);
+
+static RESTYPE lgeClientResourceType;
+
+#ifdef PERF
+/* For performance analysis */
+#include "../dix/statbuf.h"
+static StatBuf *sbPerf = NULL;
+static struct timeval tvStart, tvStop;
+#endif /* PERF */
+
+extern void XkbProcessKeyboardEvent(xEvent *xE, DeviceIntPtr keybd, int count);
+
+extern WindowPtr *WindowTable;
+
+static void lgeDisableIncompatibleExtensions ();
+static void lgeReenableIncompatibleExtensions ();
+
+/* This must be the same as in dix/extension.c */
+#define EXTENSION_BASE  128
+
+extern unsigned int NumExtensions;
+extern ExtensionEntry **extensions;
+
+static int
+ProcLgeQueryVersion (ClientPtr client)
+{
+    REQUEST(xLgeQueryVersionReq);
+    xLgeQueryVersionReply rep;
+    int n;
+
+    REQUEST_SIZE_MATCH(xLgeQueryVersionReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = LGE_MAJOR_VERSION;
+    rep.minorVersion = LGE_MINOR_VERSION;
+    rep.implementation = LG3D_IMPLEMENTATION;
+
+    if (client->swapped) {
+	swaps(&rep.sequenceNumber, n);
+	swapl(&rep.majorVersion, n);
+	swapl(&rep.minorVersion, n);
+	swapl(&rep.implementation, n);
+    }
+    WriteToClient(client, sizeof(xLgeQueryVersionReply), (char *) &rep);
+    return (client->noClientException);
+}
+
+/* For debug
+
+static void
+printEventMask (unsigned int mask) 
+{
+    int i;
+    unsigned int bit;
+
+    for (i = 0, bit = 0x1; i < 32; i++, bit <<= 1) {
+	if ((mask & bit) != 0) {
+	    switch (mask & bit) {
+	    case KeyPressMask: 
+		ErrorF("KeyPressMask ");
+		break;
+	    case KeyReleaseMask: 
+		ErrorF("KeyReleaseMask ");
+		break;
+	    case ButtonPressMask: 
+		ErrorF("ButtonPressMask ");
+		break;
+	    case ButtonReleaseMask: 
+		ErrorF("ButtonReleaseMask ");
+		break;
+	    case EnterWindowMask: 
+		ErrorF("EnterWindowMask ");
+		break;
+	    case LeaveWindowMask: 
+		ErrorF("LeaveWindowMask ");
+		break;
+	    case PointerMotionMask: 
+		ErrorF("PointerMotionMask ");
+		break;
+	    case PointerMotionHintMask: 
+		ErrorF("PointerMotionHintMask ");
+		break;
+	    case Button1MotionMask: 
+		ErrorF("Button1MotionMask ");
+		break;
+	    case Button2MotionMask: 
+		ErrorF("Button2MotionMask ");
+		break;
+	    case Button3MotionMask: 
+		ErrorF("Button3MotionMask ");
+		break;
+	    case Button4MotionMask: 
+		ErrorF("Button4MotionMask ");
+		break;
+	    case Button5MotionMask: 
+		ErrorF("Button5MotionMask ");
+		break;
+	    case ButtonMotionMask: 
+		ErrorF("ButtonMotionMask ");
+		break;
+	    case KeymapStateMask: 
+		ErrorF("KeymapStateMask ");
+		break;
+	    case ExposureMask: 
+		ErrorF("ExposureMask ");
+		break;
+	    case VisibilityChangeMask: 
+		ErrorF("VisibilityChangeMask ");
+		break;
+	    case StructureNotifyMask: 
+		ErrorF("StructureNotifyMask ");
+		break;
+	    case ResizeRedirectMask: 
+		ErrorF("ResizeRedirectMask ");
+		break;
+	    case SubstructureNotifyMask: 
+		ErrorF("SubstructureNotifyMask ");
+		break;
+	    case SubstructureRedirectMask: 
+		ErrorF("SubstructureRedirectMask ");
+		break;
+	    case FocusChangeMask: 
+		ErrorF("FocusChangeMask ");
+		break;
+	    case PropertyChangeMask: 
+		ErrorF("PropertyChangeMask ");
+		break;
+	    case ColormapChangeMask: 
+		ErrorF("ColormapChangeMask ");
+		break;
+	    case OwnerGrabButtonMask: 
+		ErrorF("OwnerGrabButtonMask ");
+		break;
+	    }
+	    ErrorF("\n");
+	}
+    }
+}
+
+static void
+printEventInterest (WindowPtr pWin) 
+{
+    OtherClients * others;
+
+    ErrorF("Owner client = %d\n", wClient(pWin)->index);
+    ErrorF("Client event interest for prw %d\n", pWin->drawable.id);
+    ErrorF("Owner interest: eventMask = 0x%x\n", pWin->eventMask);
+    printEventMask(pWin->eventMask);
+    ErrorF("\n");
+    ErrorF("Non-owner interest:\n");
+    for (others = wOtherClients(pWin); others; others = others->next) {
+	ErrorF("Other client mask = 0x%x\n", others->mask);
+	printEventMask(others->mask);
+	ErrorF("\n");
+    }
+}
+*/
+
+static int
+ProcLgeRegisterClient (ClientPtr client)
+{
+    REQUEST(xLgeRegisterClientReq);
+
+    REQUEST_SIZE_MATCH(xLgeRegisterClientReq);
+  
+    switch (stuff->clientType) {
+
+    case LGE_CLIENT_PICKER:
+	if (lgePickerClient != NULL) {
+	    return BadAccess;
+	}
+	lgePickerClient = client;
+        lgeSendEventDirect = stuff->sendEventDirect;
+	break;
+
+    case LGE_CLIENT_EVENT_DELIVERER:
+	if (lgeEventDelivererClient != NULL) {
+	    return BadAccess;
+	}
+	lgeEventDelivererClient = client;
+	break;
+    }
+
+    /* The first client to close down tells the server that the DS has shut down */
+    if (!AddResource (FakeClientID(client->index), lgeClientResourceType, NULL)) {
+	return BadAlloc;
+    }
+
+    return client->noClientException;
+}
+
+static int
+ProcLgeRegisterScreen (ClientPtr client)
+{
+    REQUEST(xLgeRegisterScreenReq);
+    ScreenPtr pScreen;
+    WindowPtr pWin;
+    int       scrNum;
+
+    REQUEST_SIZE_MATCH(xLgeRegisterScreenReq);
+  
+    /* Only the picker client can make this request */
+    if (client != lgePickerClient) {
+	return BadAccess;
+    }
+
+    pWin = (WindowPtr) LookupIDByType (stuff->prw, RT_WINDOW);
+    if (pWin == NULL) {
+	return BadMatch;
+    }
+    scrNum = pWin->drawable.pScreen->myNum;
+    lgeDisplayServerPRWsList[scrNum] = stuff->prw;
+    pLgeDisplayServerPRWWinsList[scrNum] = pWin;
+    pLgeDisplayServerPRWWinRoots[scrNum] = WindowTable[scrNum];
+
+    if (numRegisteredScr == 0) {
+	lgeDisplayServerPRW = stuff->prw;
+	pLgeDisplayServerPRWWin = pWin;
+    } 
+    else if (numRegisteredScr >= MAXSCREENS) {
+    	return BadAlloc;
+    }
+
+    pScreen = pWin->drawable.pScreen;
+    numRegisteredScr++;
+
+    /* Prevent events from being sent to the PRW owner, which is AWT */
+    pWin->eventMask = 0;
+
+#ifdef PERF
+    /* For performance analysis */
+    sbPerf = statBufCreate();
+    if (sbPerf == NULL) {
+	return BadAlloc;
+    }
+#endif /* PERF */
+
+    return client->noClientException;
+}
+
+static int
+ProcLgeControlLgMode (ClientPtr client)
+{
+    REQUEST (xLgeControlLgModeReq);
+
+    REQUEST_SIZE_MATCH(xLgeControlLgModeReq);
+
+    /* Only the picker client can make this request */
+    if (client != lgePickerClient) {
+	return BadAccess;
+    }
+
+    if (stuff->enable == TRUE) {
+	lgeDisplayServerIsAlive = 1;
+	lgeDisableIncompatibleExtensions();
+    } else {
+	lgeReenableIncompatibleExtensions();
+	LgeShutdownDisplayServer(NULL, INVALID);
+    }
+
+    return client->noClientException;
+}
+
+static int
+ProcLgeSendEvent (ClientPtr client)
+{
+    REQUEST (xLgeSendEventReq);
+    xEvent *xE = (xEvent *)&stuff->event;
+
+    REQUEST_SIZE_MATCH(xLgeSendEventReq);
+
+    /* Only the picker client can make this request */
+    if (client != lgePickerClient) {
+	return BadAccess;
+    }
+
+    /*
+    ErrorF("ProcLgeSendEvent, event type = %d, pickSeq = %d\n", 
+	   xE->u.u.type, xE->u.u.sequenceNumber);
+    ErrorF("detail = %d\n", xE->u.u.detail);
+    ErrorF("time   = %d\n", xE->u.keyButtonPointer.time);
+    ErrorF("root   = %d\n", xE->u.keyButtonPointer.root);
+    ErrorF("event   = %d\n", xE->u.keyButtonPointer.event);
+    ErrorF("child   = %d\n", xE->u.keyButtonPointer.child);
+    ErrorF("rootX   = %d\n", xE->u.keyButtonPointer.rootX);
+    ErrorF("rootY   = %d\n", xE->u.keyButtonPointer.rootY);
+    ErrorF("eventX   = %d\n", xE->u.keyButtonPointer.eventX);
+    ErrorF("eventY   = %d\n", xE->u.keyButtonPointer.eventY);
+    ErrorF("state   = %d\n", xE->u.keyButtonPointer.state);
+    */
+
+    lgeEventComesFromDS = 1;
+    if (xE->u.u.type == KeyPress || xE->u.u.type == KeyRelease) {
+
+	if (lgeSendEventDirect) {
+	    XkbProcessKeyboardEvent(xE, inputInfo.keyboard, 1);
+	} else {
+	    (*inputInfo.keyboard->public.processInputProc)(xE, inputInfo.keyboard, 1);
+	}
+
+    } else {
+
+#ifdef PERF
+	/* For performance analysis */
+	float usStart, usStop, msDelta;
+	gettimeofday(&tvStart, 0);
+#endif /* PERF */
+
+	if (lgeSendEventDirect) {
+	    CoreProcessPointerEvent(xE, inputInfo.pointer, 1);
+	} else {
+	    (*inputInfo.pointer->public.processInputProc)(xE, inputInfo.pointer, 1);
+	}
+
+#ifdef PERF
+	/* For performance analysis */
+	gettimeofday(&tvStop, 0);
+	usStart = 1000000.0f * tvStart.tv_sec + tvStart.tv_usec;
+	usStop = 1000000.0f * tvStop.tv_sec + tvStop.tv_usec;
+	msDelta = (usStop - usStart) / 1000.0f;
+	statBufAdd(sbPerf, msDelta);
+#endif /* PERF */
+    }
+    lgeEventComesFromDS = 0;
+
+    return client->noClientException;
+}
+
+static int
+SProcLgeQueryVersion (ClientPtr client)
+{
+    int n;
+    REQUEST(xLgeQueryVersionReq);
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xLgeQueryVersionReq);
+
+    return ProcLgeQueryVersion(client);
+}
+
+static int
+SProcLgeRegisterClient (ClientPtr client)
+{
+    int n;
+    REQUEST(xLgeRegisterClientReq);
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xLgeRegisterClientReq);
+    return ProcLgeRegisterClient(client);
+}
+
+static int
+SProcLgeRegisterScreen (ClientPtr client)
+{
+    int n;
+    REQUEST(xLgeRegisterScreenReq);
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xLgeRegisterScreenReq);
+    swapl(&stuff->prw, n);
+    return ProcLgeRegisterScreen(client);
+}
+
+static int
+SProcLgeControlLgMode (ClientPtr client)
+{
+    int n;
+    REQUEST(xLgeControlLgModeReq);
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xLgeControlLgModeReq);
+    return ProcLgeControlLgMode(client);
+}
+
+static int
+SProcLgeSendEvent (ClientPtr client)
+{
+    int n;
+    EventSwapPtr proc;
+    xEvent eventT;
+
+    REQUEST(xLgeSendEventReq);
+    swaps (&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE (xLgeSendEventReq);
+
+    /* Swap event */
+    proc = EventSwapVector[stuff->event.u.u.type & 0177];
+    if (!proc ||  proc == NotImplemented)    /* no swapping proc; invalid event type? */
+       return (BadValue);
+    (*proc)(&stuff->event, &eventT);
+    stuff->event = eventT;
+
+    return ProcLgeSendEvent (client);
+}
+
+int
+ProcLgeDispatch (ClientPtr client)
+{
+  REQUEST(xReq);
+
+  switch (stuff->data) {
+  case X_LgeQueryVersion:
+      return ProcLgeQueryVersion(client);
+  case X_LgeRegisterClient:
+      return ProcLgeRegisterClient(client);
+  case X_LgeRegisterScreen:
+      return ProcLgeRegisterScreen(client);
+  case X_LgeControlLgMode:
+      return ProcLgeControlLgMode(client);
+  case X_LgeSendEvent:
+      return ProcLgeSendEvent(client);
+  default:
+      return BadRequest;
+  }
+}
+
+int
+SProcLgeDispatch (ClientPtr client)
+{
+  REQUEST(xReq);
+
+  switch (stuff->data) {
+
+  case X_LgeQueryVersion:
+      return SProcLgeQueryVersion(client);
+
+  case X_LgeRegisterClient: 
+      return SProcLgeRegisterClient(client);
+
+  case X_LgeRegisterScreen: 
+      return SProcLgeRegisterScreen(client);
+
+  case X_LgeControlLgMode: 
+      return SProcLgeControlLgMode(client);
+
+  case X_LgeSendEvent: 
+      return SProcLgeSendEvent(client);
+
+  default:
+      return BadRequest;
+  }
+}
+
+/*ARGSUSED*/
+int
+LgeShutdownDisplayServer (pointer data, XID id)
+{
+    int i;
+
+    if (!lgeDisplayServerIsAlive) {
+	return 1;
+    }
+
+    /*ErrorF("LG Display Server has shut down\n");*/
+
+    lgeDisplayServerIsAlive = 0;
+    lgeEventComesFromDS = 0;
+    lgekb = NULL;
+    lgems = NULL;
+
+    lgePickerClient = NULL;
+    lgeEventDelivererClient = NULL;
+
+    lgeDisplayServerPRW = INVALID;
+    pLgeDisplayServerPRWWin = NULL;
+
+    for (i = 0; i < MAXSCREENS; i++) {
+	lgeDisplayServerPRWsList[i] = INVALID;
+	pLgeDisplayServerPRWWinsList[i] = NULL;
+	pLgeDisplayServerPRWWinRoots[i] = NULL;
+    }
+    numRegisteredScr = 0;
+
+    return 1;
+}
+
+static void
+LgeReset (ExtensionEntry *extEntry)
+{
+    (void) LgeShutdownDisplayServer(NULL, INVALID);
+}
+
+void
+LgeExtensionInit (void)
+{
+  ExtensionEntry *extEntry;
+  int            i;
+
+  lgeClientResourceType = CreateNewResourceType(LgeShutdownDisplayServer);
+  if (lgeClientResourceType == 0) {
+      FatalError("LgeExtensionInit: Cannot create display server resource type\n");
+      exit(1);
+  }
+    
+  extEntry = AddExtension(LGE_NAME, 0, 0, ProcLgeDispatch,
+			  SProcLgeDispatch, LgeReset, StandardMinorOpcode);
+  if (extEntry == NULL) {
+      FatalError("LgeExtensionInit: AddExtension(%s) failed\n", LGE_NAME);
+      exit(1);
+  }
+ 
+  LgeReqCode = extEntry->base;
+
+  for (i = 0; i < MAXSCREENS; i++) {
+      lgeDisplayServerPRWsList[i] = INVALID;
+      pLgeDisplayServerPRWWinsList[i] = NULL;
+      pLgeDisplayServerPRWWinRoots[i] = NULL;
+  }
+}          
+
+int
+IsWinLgePRWOne(int win) 
+{
+    int i;
+	
+    for (i=0; i < numRegisteredScr; i++)
+    {
+	if(lgeDisplayServerPRWsList[i] == win)
+            return win;
+    }	
+    return INVALID;
+}
+
+WindowPtr
+GetLgePRWWinFor(int win) 
+{
+    int i;
+	
+    for (i=0; i < numRegisteredScr; i++)
+    {
+	if(lgeDisplayServerPRWsList[i] == win)
+	     return pLgeDisplayServerPRWWinsList[i];			
+    }	
+    return NULL;
+}
+
+/*
+** Returns True if the given extension is compatible with LG mode.
+** Returns false if the given extension is incompatible.
+** Specifically, XVideo is incompatible because it not redirectable 
+** by the composite extension. And XINPUT is incompatible because it 
+** is not yet supported by the LG-modified Xorg event subsystem.
+** 
+** TODO: GLX and NV-GLX are not compatible with LG either. But 
+** disabling these extensions has no effect; OpenGL apps run anyway
+** event without these extensions defined. I have not yet found
+** a way to gracefully keep OpenGL programs from running while
+** LG mode is abled.
+*/
+
+Bool
+lgeCompatibleExtension (ExtensionEntry *pExt)
+{
+    if (strcmp(pExt->name, "XVideo") == 0) {
+	return FALSE;
+    }
+    if (strcmp(pExt->name, "XVideo-MotionCompensation") == 0) {
+	return FALSE;
+    }
+
+    if (strcmp(pExt->name, "XInputExtension") == 0) {
+	return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*
+** Shuts the given extension off by replacing its MainProc and SwappedMainProc
+** with a routine which prints out an error message and returns BadAccess,
+** or enables the given extension by replacing its original MainProc and 
+** SwappedMainProc routines.
+*/
+
+#define WARNING_MESSAGE "WARNING: client attempt to access the %s extension, which has been disabled because it is incompatible with LG3D"
+
+static int (*XVideoSavedMainProc)(ClientPtr);
+static int (*XVideoSavedSwappedMainProc)(ClientPtr);
+static int (*XVideoMCSavedMainProc)(ClientPtr);
+static int (*XVideoMCSavedSwappedMainProc)(ClientPtr);
+static int (*XINPUTSavedMainProc)(ClientPtr);
+static int (*XINPUTSavedSwappedMainProc)(ClientPtr);
+
+static int
+lgeXVideoError (ClientPtr client) 
+{
+    ErrorF(WARNING_MESSAGE, "XVideo");
+    return BadAccess;
+}
+
+static int
+lgeXVideoMCError (ClientPtr client) 
+{
+    ErrorF(WARNING_MESSAGE, "XVideo-MotionCompensation");
+    return BadAccess;
+}
+
+static int
+lgeXINPUTError (ClientPtr client) 
+{
+    ErrorF(WARNING_MESSAGE, "XInputExtension");
+    return BadAccess;
+}
+
+static void
+lgeControlIncompatibleExtension (ExtensionEntry *pExt, Bool enable)
+{
+    int idx = pExt->index;
+
+    if (strcmp(pExt->name, "XVideo") == 0) {
+	if (enable) {
+	    ProcVector[idx + EXTENSION_BASE] = XVideoSavedMainProc;
+	    SwappedProcVector[idx + EXTENSION_BASE] = XVideoSavedSwappedMainProc;
+	} else {
+	    XVideoSavedMainProc = ProcVector[idx + EXTENSION_BASE];
+	    ProcVector[idx + EXTENSION_BASE] = lgeXVideoError;
+	    XVideoSavedSwappedMainProc = SwappedProcVector[idx + EXTENSION_BASE];
+	    SwappedProcVector[idx + EXTENSION_BASE] = lgeXVideoError;
+	}
+    }
+    if (strcmp(pExt->name, "XVideo-MotionCompensation") == 0) {
+	if (enable) {
+	    ProcVector[idx + EXTENSION_BASE] = XVideoMCSavedMainProc;
+	    SwappedProcVector[idx + EXTENSION_BASE] = XVideoMCSavedSwappedMainProc;
+	} else {
+	    XVideoMCSavedMainProc = ProcVector[idx + EXTENSION_BASE];
+	    ProcVector[idx + EXTENSION_BASE] = lgeXVideoMCError;
+	    XVideoMCSavedSwappedMainProc = SwappedProcVector[idx + EXTENSION_BASE];
+	    SwappedProcVector[idx + EXTENSION_BASE] = lgeXVideoMCError;
+	}
+    }
+
+    /* 
+     * In order to fix LG bug 665 we must not disable XINPUT here, because
+     * realplay requires it. But we will still not advertise the extension
+     * in the list of supported extensions.
+     *
+     * This seems to be a linux-only issue. So right now were only 
+     * reenabling it on linux.
+
+    if (strcmp(pExt->name, "XInputExtension") == 0) {
+	if (enable) {
+	    ProcVector[idx + EXTENSION_BASE] = XINPUTSavedMainProc;
+	    SwappedProcVector[idx + EXTENSION_BASE] = XINPUTSavedSwappedMainProc;
+	} else {
+	    XINPUTSavedMainProc = ProcVector[idx + EXTENSION_BASE];
+	    ProcVector[idx + EXTENSION_BASE] = lgeXINPUTError;
+	    XINPUTSavedSwappedMainProc = SwappedProcVector[idx + EXTENSION_BASE];
+	    SwappedProcVector[idx + EXTENSION_BASE] = lgeXINPUTError;
+	}	
+    }
+    */
+}
+
+static void
+lgeDisableIncompatibleExtensions ()
+{
+    int i;
+    
+    for (i = 0;  i < NumExtensions; i++) {
+	if (!lgeCompatibleExtension(extensions[i])) {
+	    lgeControlIncompatibleExtension(extensions[i], FALSE);
+	}
+    }
+}
+
+static void
+lgeReenableIncompatibleExtensions ()
+{
+    int i;
+    
+    for (i = 0;  i < NumExtensions; i++) {
+	if (!lgeCompatibleExtension(extensions[i])) {
+	    lgeControlIncompatibleExtension(extensions[i], TRUE);
+	}
+    }
+}
+
+#endif /* LG3D */
+
+