diff options
Diffstat (limited to 'recipes/xorg-xserver/xserver-kdrive/xcalibrate.patch')
| -rw-r--r-- | recipes/xorg-xserver/xserver-kdrive/xcalibrate.patch | 351 |
1 files changed, 351 insertions, 0 deletions
diff --git a/recipes/xorg-xserver/xserver-kdrive/xcalibrate.patch b/recipes/xorg-xserver/xserver-kdrive/xcalibrate.patch new file mode 100644 index 0000000000..5d44dd679d --- /dev/null +++ b/recipes/xorg-xserver/xserver-kdrive/xcalibrate.patch @@ -0,0 +1,351 @@ +--- xorg-server-X11R7.1-1.1.0/mi/miinitext.c.orig 2006-06-22 14:11:46.000000000 +0200 ++++ xorg-server-X11R7.1-1.1.0/mi/miinitext.c 2006-06-22 15:26:17.000000000 +0200 +@@ -385,6 +385,9 @@ + #ifdef DMXEXT + extern void DMXExtensionInit(INITARGS); + #endif ++#ifdef XCALIBRATE ++extern void XCalibrateExtensionInit(INITARGS); ++#endif + #ifdef XEVIE + extern void XevieExtensionInit(INITARGS); + #endif +@@ -679,6 +682,9 @@ + #ifdef DAMAGE + if (!noDamageExtension) DamageExtensionInit(); + #endif ++#ifdef XCALIBRATE ++ XCalibrateExtensionInit (); ++#endif + } + + void +--- xorg-server-X11R7.1-1.1.0/configure.ac.orig 2006-06-15 17:03:14.000000000 +0200 ++++ xorg-server-X11R7.1-1.1.0/configure.ac 2006-06-24 08:21:25.000000000 +0200 +@@ -407,6 +407,7 @@ + AC_ARG_ENABLE(xf86vidmode, AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: enabled)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=yes]) + AC_ARG_ENABLE(xf86misc, AS_HELP_STRING([--disable-xf86misc], [Build XF86Misc extension (default: enabled)]), [XF86MISC=$enableval], [XF86MISC=yes]) + AC_ARG_ENABLE(xcsecurity, AS_HELP_STRING([--disable-xcsecurity], [Build Security extension (default: enabled)]), [XCSECURITY=$enableval], [XCSECURITY=yes]) ++AC_ARG_ENABLE(xcalibrate, AS_HELP_STRING([--enable-xcalibrate], [Build XCalibrate extension (default: disabled)]), [XCALIBRATE=$enableval], [XCALIBRATE=no]) + AC_ARG_ENABLE(xevie, AS_HELP_STRING([--disable-xevie], [Build XEvIE extension (default: enabled)]), [XEVIE=$enableval], [XEVIE=yes]) + AC_ARG_ENABLE(lbx, AS_HELP_STRING([--disable-lbx], [Build LBX extension (default: no)]), [LBX=$enableval], [LBX=no]) + AC_ARG_ENABLE(appgroup, AS_HELP_STRING([--disable-appgroup], [Build XC-APPGROUP extension (default: enabled)]), [APPGROUP=$enableval], [APPGROUP=yes]) +@@ -641,6 +642,12 @@ + AC_DEFINE(XCSECURITY, 1, [Build Security extension]) + fi + ++AM_CONDITIONAL(XCALIBRATE, [test "x$XCALIBRATE" = xyes]) ++if test "x$XCALIBRATE" = xyes; then ++ AC_DEFINE(XCALIBRATE, 1, [Build XCalibrate extension]) ++ REQUIRED_MODULES="$REQUIRED_MODULES xcalibrateproto" ++fi ++ + AM_CONDITIONAL(XEVIE, [test "x$XEVIE" = xyes]) + if test "x$XEVIE" = xyes; then + AC_DEFINE(XEVIE, 1, [Build XEvIE extension]) +@@ -1466,7 +1473,7 @@ + KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.a' + KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a' + KDRIVE_STUB_LIB='$(top_builddir)/hw/kdrive/src/libkdrivestubs.a' +- KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB" ++ KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_PURE_LIBS $KDRIVE_OS_LIB $KDRIVE_STUB_LIB" + + # check if we can build Xephyr + PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"]) +--- xorg-server-X11R7.1-1.1.0/include/kdrive-config.h.in.orig 2006-06-22 14:22:07.000000000 +0200 ++++ xorg-server-X11R7.1-1.1.0/include/kdrive-config.h.in 2006-06-22 14:33:29.000000000 +0200 +@@ -22,4 +22,7 @@ + /* Support tslib touchscreen abstraction library */ + #undef TSLIB + ++/* Enable XCalibrate extension */ ++#undef XCALIBRATE ++ + #endif /* _KDRIVE_CONFIG_H_ */ +--- xorg-server-X11R7.1-1.1.0/Xext/Makefile.am.orig 2006-06-15 17:06:43.000000000 +0200 ++++ xorg-server-X11R7.1-1.1.0/Xext/Makefile.am 2006-06-15 18:12:40.000000000 +0200 +@@ -78,6 +78,11 @@ + AM_CFLAGS += -DDEFAULTPOLICYFILE=\"$(SERVERCONFIGdir)/SecurityPolicy\" + endif + ++XCALIBRATE_SRCS = xcalibrate.c ++if XCALIBRATE ++BUILTIN_SRCS += $(XCALIBRATE_SRCS) ++endif ++ + # X EVent Interception Extension: allows accessibility helpers & composite + # managers to intercept events from input devices and transform as needed + # before the clients see them. +@@ -155,6 +160,7 @@ + $(SCREENSAVER_SRCS) \ + $(XCSECURITY_SRCS) \ + $(XINERAMA_SRCS) \ ++ $(XCALIBRATE_SRCS) \ + $(XEVIE_SRCS) \ + $(XPRINT_SRCS) \ + $(APPGROUP_SRCS) \ +--- xorg-server-X11R7.1-1.1.0/Xext/xcalibrate.c.orig 2006-06-15 17:05:19.000000000 +0200 ++++ xorg-server-X11R7.1-1.1.0/Xext/xcalibrate.c 2006-06-22 15:15:09.000000000 +0200 +@@ -0,0 +1,262 @@ ++/* ++ * $Id: xcalibrate.c,v 3.1 2004/06/02 20:49:50 pb Exp $ ++ * ++ * Copyright © 2003 Philip Blundell ++ * ++ * 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, and that the name of Philip Blundell not be used in ++ * advertising or publicity pertaining to distribution of the software without ++ * specific, written prior permission. Philip Blundell makes no ++ * representations about the suitability of this software for any purpose. It ++ * is provided "as is" without express or implied warranty. ++ * ++ * PHILIP BLUNDELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, ++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO ++ * EVENT SHALL PHILIP BLUNDELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR ++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, ++ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER ++ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR ++ * PERFORMANCE OF THIS SOFTWARE. ++ */ ++ ++#ifdef HAVE_KDRIVE_CONFIG_H ++#include <kdrive-config.h> ++#endif ++ ++#define NEED_EVENTS ++#define NEED_REPLIES ++ ++#include <X11/X.h> ++#include <X11/Xproto.h> ++#include "misc.h" ++#include "os.h" ++#include "dixstruct.h" ++#include "extnsionst.h" ++#include "swaprep.h" ++ ++#include <X11/extensions/xcalibrateproto.h> ++#include <X11/extensions/xcalibratewire.h> ++ ++extern void (*tslib_raw_event_hook)(int x, int y, int pressure, void *closure); ++extern void *tslib_raw_event_closure; ++ ++static CARD8 XCalibrateReqCode; ++int XCalibrateEventBase; ++int XCalibrateReqBase; ++int XCalibrateErrorBase; ++ ++static ClientPtr xcalibrate_client; ++ ++static void ++xcalibrate_event_hook (int x, int y, int pressure, void *closure) ++{ ++ ClientPtr pClient = (ClientPtr) closure; ++ xXCalibrateRawTouchscreenEvent ev; ++ ++ ev.type = XCalibrateEventBase + X_XCalibrateRawTouchscreen; ++ ev.sequenceNumber = pClient->sequence; ++ ev.x = x; ++ ev.y = y; ++ ev.pressure = pressure; ++ ++ if (!pClient->clientGone) ++ WriteEventsToClient (pClient, 1, (xEvent *) &ev); ++} ++ ++static int ++ProcXCalibrateQueryVersion (ClientPtr client) ++{ ++ REQUEST(xXCalibrateQueryVersionReq); ++ xXCalibrateQueryVersionReply rep; ++ CARD16 client_major, client_minor; /* not used */ ++ ++ REQUEST_SIZE_MATCH (xXCalibrateQueryVersionReq); ++ ++ client_major = stuff->majorVersion; ++ client_minor = stuff->minorVersion; ++ ++ fprintf(stderr, "%s(): called\n", __func__); ++ ++ rep.type = X_Reply; ++ rep.length = 0; ++ rep.sequenceNumber = client->sequence; ++ rep.majorVersion = XCALIBRATE_MAJOR_VERSION; ++ rep.minorVersion = XCALIBRATE_MINOR_VERSION; ++ if (client->swapped) { ++ int n; ++ swaps(&rep.sequenceNumber, n); ++ swapl(&rep.length, n); ++ swaps(&rep.majorVersion, n); ++ swaps(&rep.minorVersion, n); ++ } ++ WriteToClient(client, sizeof (xXCalibrateQueryVersionReply), (char *)&rep); ++ return (client->noClientException); ++} ++ ++static int ++SProcXCalibrateQueryVersion (ClientPtr client) ++{ ++ REQUEST(xXCalibrateQueryVersionReq); ++ int n; ++ ++ REQUEST_SIZE_MATCH (xXCalibrateQueryVersionReq); ++ swaps(&stuff->majorVersion,n); ++ swaps(&stuff->minorVersion,n); ++ return ProcXCalibrateQueryVersion(client); ++} ++ ++static int ++ProcXCalibrateSetRawMode (ClientPtr client) ++{ ++ REQUEST(xXCalibrateRawModeReq); ++ xXCalibrateRawModeReply rep; ++ ++ REQUEST_SIZE_MATCH (xXCalibrateRawModeReq); ++ ++ memset (&rep, 0, sizeof (rep)); ++ rep.type = X_Reply; ++ rep.sequenceNumber = client->sequence; ++ ++ if (stuff->on) ++ { ++ if (xcalibrate_client == NULL) ++ { ++ /* Start calibrating. */ ++ xcalibrate_client = client; ++ tslib_raw_event_hook = xcalibrate_event_hook; ++ tslib_raw_event_closure = client; ++ rep.status = GrabSuccess; ++ } ++ else ++ { ++ rep.status = AlreadyGrabbed; ++ } ++ } ++ else ++ { ++ if (xcalibrate_client == client) ++ { ++ /* Stop calibrating. */ ++ xcalibrate_client = NULL; ++ tslib_raw_event_hook = NULL; ++ tslib_raw_event_closure = NULL; ++ rep.status = GrabSuccess; ++ ++ /* Cycle input off and on to reload configuration. */ ++ KdDisableInput (); ++ KdEnableInput (); ++ } ++ else ++ { ++ rep.status = AlreadyGrabbed; ++ } ++ } ++ ++ if (client->swapped) ++ { ++ int n; ++ ++ swaps (&rep.sequenceNumber, n); ++ swaps (&rep.status, n); ++ } ++ WriteToClient(client, sizeof (rep), (char *) &rep); ++ return (client->noClientException); ++} ++ ++ ++static int ++SProcXCalibrateSetRawMode (ClientPtr client) ++{ ++ REQUEST(xXCalibrateRawModeReq); ++ int n; ++ ++ REQUEST_SIZE_MATCH (xXCalibrateRawModeReq); ++ ++ swaps(&stuff->on, n); ++ ++ return ProcXCalibrateSetRawMode(client); ++} ++ ++static void ++XCalibrateResetProc (ExtensionEntry *extEntry) ++{ ++} ++ ++static int ++ProcXCalibrateDispatch (ClientPtr client) ++{ ++ REQUEST(xReq); ++ switch (stuff->data) { ++ case X_XCalibrateQueryVersion: ++ return ProcXCalibrateQueryVersion(client); ++ case X_XCalibrateRawMode: ++ return ProcXCalibrateSetRawMode(client); ++ default: break; ++ } ++ ++ return BadRequest; ++} ++ ++static int ++SProcXCalibrateDispatch (ClientPtr client) ++{ ++ REQUEST(xReq); ++ int n; ++ ++ swaps(&stuff->length,n); ++ ++ switch (stuff->data) { ++ case X_XCalibrateQueryVersion: ++ return SProcXCalibrateQueryVersion(client); ++ case X_XCalibrateRawMode: ++ return SProcXCalibrateSetRawMode(client); ++ ++ default: break; ++ } ++ ++ return BadRequest; ++} ++ ++static void ++XCalibrateClientCallback (CallbackListPtr *list, ++ pointer closure, ++ pointer data) ++{ ++ NewClientInfoRec *clientinfo = (NewClientInfoRec *) data; ++ ClientPtr pClient = clientinfo->client; ++ ++ if (clientinfo->setup == NULL ++ && xcalibrate_client != NULL ++ && xcalibrate_client == pClient) ++ { ++ /* Stop calibrating. */ ++ xcalibrate_client = NULL; ++ tslib_raw_event_hook = NULL; ++ tslib_raw_event_closure = NULL; ++ } ++} ++ ++void ++XCalibrateExtensionInit(void) ++{ ++ ExtensionEntry *extEntry; ++ ++ if (!AddCallback (&ClientStateCallback, XCalibrateClientCallback, 0)) ++ return; ++ ++ extEntry = AddExtension(XCALIBRATE_NAME, XCalibrateNumberEvents, XCalibrateNumberErrors, ++ ProcXCalibrateDispatch, SProcXCalibrateDispatch, ++ XCalibrateResetProc, StandardMinorOpcode); ++ ++ if (!extEntry) ++ return; ++ ++ XCalibrateReqCode = (unsigned char)extEntry->base; ++ XCalibrateEventBase = extEntry->eventBase; ++ XCalibrateErrorBase = extEntry->errorBase; ++ ++ xcalibrate_client = 0; ++} |