Attachment 1422 Details for Bug 1917 – Add support to new tablets.

[patch] Add support to new tablets.

xf86Wacom.patch (text/plain), 68.11 KB, created by Ping Cheng on 2004-11-29 15:13:52 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ping Cheng

Created: 2004-11-29 15:13:52 UTC

Size: 68.11 KB

patch

obsolete

>--- X11R6.8.1/xc/programs/Xserver/hw/xfree86/input/wacom/xf86Wacom.c	2004-11-18 17:38:02.000000000 -0800
>+++ xf86Wacom.c	2004-11-29 14:47:58.000000000 -0800
>@@ -2,6 +2,7 @@
> /* $XConsortium: xf86Wacom.c /main/20 1996/10/27 11:05:20 kaleb $ */
> /*
>  * Copyright 1995-2001 by Frederic Lepied, France. <Lepied@XFree86.org>
>+ * Copyright 2002-2004 by Ping Cheng. <pingc@wacom.com>
>  *                                                                            
>  * Permission to use, copy, modify, distribute, and sell this software and its
>  * documentation for any purpose is  hereby granted without fee, provided that
>@@ -45,7 +46,7 @@
>  *
>  */
> 
>-static const char identification[] = "$Identification: 42 $";
>+static const char identification[] = "$Identification: 43 $";
> 
> #include <xf86Version.h>
> 
>@@ -53,7 +54,7 @@
> #include <asm/types.h>
> #include <linux/input.h>
> 
>-/* 2.4.6 module support */
>+/* 2.6 module support */
> #ifndef EV_MSC
> #define EV_MSC 0x04
> #endif
>@@ -209,14 +210,18 @@
> static Bool isdv4Init(LocalDevicePtr);
> static void isdv4InitISDV4(WacomCommonPtr common, int fd, const char* id,
>         float version);
>+static int isdv4GetRanges(WacomCommonPtr common, int fd);
>+static int isdv4StartTablet(WacomCommonPtr common, int fd);
> static int isdv4Parse(WacomCommonPtr common, const unsigned char* data);
> 
> static int xf86WcmFilterCoord(WacomCommonPtr common, WacomChannelPtr pChannel,
>         WacomDeviceStatePtr ds);
> static int xf86WcmFilterIntuos(WacomCommonPtr common, WacomChannelPtr pChannel,
>         WacomDeviceStatePtr ds);
>+static int xf86WcmHysteresisFilter(WacomCommonPtr common, WacomChannelPtr pChannel,
>+	WacomDeviceStatePtr ds);
> 
>-static void xf86WcmSendEvents(LocalDevicePtr local, const WacomDeviceState* ds);
>+static void xf86WcmSendEvents(LocalDevicePtr local, const WacomDeviceState* ds, unsigned int c);
> static Bool xf86WcmDevConvert(LocalDevicePtr local, int first, int	num,
> 	       int v0, int v1, int v2, int v3, int v4, int v5, int *x, int *y);
> static Bool xf86WcmDevReverseConvert(LocalDevicePtr local, int x, int y,
>@@ -247,44 +252,29 @@
> #define POSIX_TTY
> #endif
> 
>-/******************************************************************************
>- * debugging macro
>- *****************************************************************************/
>-#ifdef DBG
>-#undef DBG
>-#endif
>-#ifdef DEBUG
>-#undef DEBUG
>-#endif
>-
>-static int      debug_level = 0;
>-#define DEBUG 1
>-#if DEBUG
>-#define DBG(lvl, f) {if ((lvl) <= debug_level) f;}
>-#else
>-#define DBG(lvl, f)
>-#endif
>-
> #define ABS(x) ((x) > 0 ? (x) : -(x))
> #define mils(res) (res * 100 / 2.54) /* resolution */
> 
> /******************************************************************************
>  * WacomDeviceRec flags
>  *****************************************************************************/
>-#define DEVICE_ID(flags) ((flags) & 0x07)
>+#define DEVICE_ID(flags) ((flags) & 0x0f)
> 
> #define STYLUS_ID		1
> #define CURSOR_ID		2
> #define ERASER_ID		4
>-#define ABSOLUTE_FLAG		8
>-#define	KEEP_SHAPE_FLAG		16
>-#define BAUD_19200_FLAG		32
>-#define BETA_FLAG		64
>+#define PAD_ID                  8
>+#define ABSOLUTE_FLAG		16
>+#define	KEEP_SHAPE_FLAG		32
>+#define BAUD_19200_FLAG		64
> #define BUTTONS_ONLY_FLAG	128
>+#define TPCBUTTONS_FLAG		256
>+#define TPCBUTTONONE_FLAG	512
> 
> #define IsCursor(priv) (DEVICE_ID((priv)->flags) == CURSOR_ID)
> #define IsStylus(priv) (DEVICE_ID((priv)->flags) == STYLUS_ID)
> #define IsEraser(priv) (DEVICE_ID((priv)->flags) == ERASER_ID)
>+#define IsPad(priv)    (DEVICE_ID((priv)->flags) == PAD_ID)
> 
> #define MAX_SAMPLES 4
> 
>@@ -330,6 +320,7 @@
> #define XI_STYLUS "STYLUS"	/* X device name for the stylus */
> #define XI_CURSOR "CURSOR"	/* X device name for the cursor */
> #define XI_ERASER "ERASER"	/* X device name for the eraser */
>+#define XI_PAD    "PAD"         /* X device name for the I3 Pad */
> #define MAX_VALUE 100           /* number of positions */
> #define MAXTRY 3                /* max number of try to receive magic number */
> #define MAX_COORD_RES 1270.0	/* Resolution of the returned MaxX and MaxY */
>@@ -341,6 +332,9 @@
> #define WC_CONFIG	"~R\r"	/* request a configuration string */
> #define WC_COORD	"~C\r"	/* request max coordinates */
> #define WC_MODEL	"~#\r"	/* request model and ROM version */
>+#define WC_ISDV4_QUERY	"*"	/* ISDV4 query command */
>+#define WC_ISDV4_STOP	"0"	/* ISDV4 stop command */
>+#define WC_ISDV4_SAMPLING "1"	/* ISDV4 sampling command */
> 
> #define WC_MULTI	"MU1\r"	/* multi mode input */
> #define WC_UPPER_ORIGIN	"OC1\r"	/* origin in upper left */
>@@ -398,6 +392,8 @@
>     int			pressure;
>     int			tiltx;
>     int			tilty;
>+    int			stripx;
>+    int			stripy;
>     int			rotation;
>     int			abswheel;
>     int			relwheel;
>@@ -459,6 +455,8 @@
>     int			oldTiltY;	/* previous tilt in y direction */    
>     int			oldWheel;	/* previous wheel value */    
>     int			oldRot;		/* previous rotation value */
>+    int			oldStripX;	/* previous left strip value */
>+    int			oldStripY;	/* previous right strip value */
>     int			oldThrottle;	/* previous throttle value */
>     int			oldButtons;	/* previous buttons state */
>     int			oldProximity;	/* previous proximity */
>@@ -466,11 +464,9 @@
>     int			accel;		/* relative mode acceleration */
>     int			numScreen;	/* number of configured screens */
>     int			currentScreen;	/* current screen in display */
>-    double		dscaleX;	/* scale in X for dual screens */
>-    double		dscaleY;	/* scale in Y for dual screens */
>-    int			doffsetX;	/* offset in X for dual screens */
>-    int			doffsetY;	/* offset in Y for dual screens */
>     tvMode		twinview;	/* using twinview mode of gfx card */
>+    int			tvoffsetX;	/* X edge offset for TwinView setup */
>+    int			tvoffsetY;	/* Y edge offset for TwinView setup */
>     int			tvResolution[4];/* twinview screens' resultion */
>     int			throttleStart;	/* time in ticks for last wheel movement */
>     int			throttleLimit;	/* time in ticks for next wheel movement */
>@@ -508,7 +504,10 @@
> 
>     WacomDeviceClassPtr	wcmDevCls;	/* device class functions */
>     WacomModelPtr	wcmModel; 	/* model-specific functions */
>+    char		*wcmEraserID;	/* eraser associated with the stylus */
>     int			wcmGimp;	/* support Gimp on Xinerama Enabled multi-monitor desktop */
>+    int			wcmMMonitor;	/* disable/enable moving across screens in multi-monitor desktop */
>+    int			wcmTPCButton;   /* set Tablet PC button on/off */
> 
>     int			bufpos;		/* position with buffer */
>     unsigned char	buffer[BUFFER_SIZE]; /* data read from device */
>@@ -680,6 +679,8 @@
> #define XWACOM_PARAM_FILEMODEL  100
> #define XWACOM_PARAM_FILEOPTION 101
> #define XWACOM_PARAM_GIMP       102
>+#define XWACOM_PARAM_MMT        103
>+#define XWACOM_PARAM_TPCBUTTON  104
> 
> WacomModule gWacomModule =
> {
>@@ -867,6 +868,21 @@
>     xf86WcmFilterIntuos,  /* input filtering recommended */
> };
> 
>+static WacomModel usbIntuos3 =
>+{
>+    "USB Intuos3",
>+    usbInitProtocol5,
>+    NULL,                 /* resolution not queried */
>+    usbGetRanges,
>+    NULL,                 /* reset not supported */
>+    NULL,                 /* tilt automatically enabled */
>+    NULL,                 /* suppress implemented in software */
>+    NULL,                 /* link speed unsupported */
>+    NULL,                 /* start not supported */
>+    usbParse,
>+    xf86WcmFilterIntuos,  /* input filtering recommended */
>+};
>+
> static WacomModel usbVolito =
> {
>     "USB Volito",
>@@ -895,6 +911,23 @@
>      NULL
> };
> 
>+/******************************************************************************
>+ * debugging macro
>+ *****************************************************************************/
>+#ifdef DBG
>+#undef DBG
>+#endif
>+#ifdef DEBUG
>+#undef DEBUG
>+#endif
>+
>+#define DEBUG 1
>+#if DEBUG
>+#define DBG(lvl, f) {if ((lvl) <= gWacomModule.debugLevel) f;}
>+#else
>+#define DBG(lvl, f)
>+#endif
>+
> #ifdef LINUX_INPUT
> /*****************************************************************************
>  * usbDetect --
>@@ -952,8 +985,8 @@
> 	    case 0x12: /* Graphire2 5x7 */
> 		model = &usbGraphire2; break;
> 
>-	    case 0x13: /* Graphire2 4x5 */
>-	    case 0x14: /* Graphire2 6x8 */
>+	    case 0x13: /* Graphire3 4x5 */
>+	    case 0x14: /* Graphire3 6x8 */
> 		model = &usbGraphire3; break;
> 
> 	    case 0x20: /* Intuos 4x5 */
>@@ -984,6 +1017,11 @@
> 
> 	    case 0x60: /* Volito */
> 		model = &usbVolito; break;
>+
>+	    case 0xB0: /* Intuos3 4x5 */
>+	    case 0xB1: /* Intuos3 6x8 */
>+	    case 0xB2: /* Intuos3 9x12 */
>+		model = &usbIntuos3; break;
> 	}
>     }
> 
>@@ -996,9 +1034,17 @@
>         float version)
> {
>     DBG(2, ErrorF("detected a protocol 5 model (%s)\n",id));
>-    common->wcmResolX = common->wcmResolY = 2540;
>+    if ( strstr(id, "Intuos3") )
>+    {
>+	common->wcmChannelCnt = 1;
>+	common->wcmResolX = common->wcmResolY = 5080;
>+    }
>+    else
>+    {
>+	common->wcmChannelCnt = 2;
>+	common->wcmResolX = common->wcmResolY = 2540;
>+    }
>     common->wcmProtocolLevel = 5;
>-    common->wcmChannelCnt = 2;
>     common->wcmPktLength = sizeof(struct input_event);
> }
> 
>@@ -1043,6 +1089,10 @@
> 		return !Success;
> 	    }
> 	    common->wcmMaxX = nValues[2];
>+	    if (common->wcmMaxX <= 0) {
>+		ErrorF("WACOM: xmax value is wrong.\n");
>+		return !Success;
>+	    }
>  	}
> 
>  	/* max y */
>@@ -1052,6 +1102,10 @@
> 		return !Success;
> 	    }
> 	    common->wcmMaxY = nValues[2];
>+	    if (common->wcmMaxY <= 0) {
>+		ErrorF("WACOM: ymax value is wrong.\n");
>+		return !Success;
>+	    }
> 	}
> 
> 	/* max z cannot be configured */
>@@ -1060,6 +1114,14 @@
> 	    return !Success;
> 	}
> 	common->wcmMaxZ = nValues[2];
>+ 	if (common->wcmMaxZ <= 0) {
>+	    ErrorF("WACOM: press max value is wrong.\n");
>+	    return !Success;
>+	}
>+    }
>+    else {
>+	ErrorF("WACOM: unable to ioctl max values.\n");
>+	return !Success;
>     }
> 
>     return Success;
>@@ -1092,11 +1154,12 @@
>     /* save it for later */
>     common->wcmEvents[common->wcmEventCnt++] = *event;
> 
>-    /* packet terminated by MSC_SERIAL on kernel 2.4 and SYN_REPORT on kernel 2.5 */
>+    /* packet terminated by MSC_SERIAL on kernel 2.4 and SYN_REPORT on kernel 2.6 */
>     if ((event->type != EV_MSC) || (event->code != MSC_SERIAL)) {
> #ifdef EV_SYN
> 	/* none serial number tools fall here */
>-	if ((event->type == EV_SYN) && (event->code == SYN_REPORT)) {
>+	if ((event->type == EV_SYN) && (event->code == SYN_REPORT) 
>+		&& (common->wcmChannelCnt == 1)) {
> 	    usbParseChannel(common,0,0);
> 	    common->wcmEventCnt = 0;
> 	}
>@@ -1107,9 +1170,29 @@
>     serial = event->value;
>     channel = -1;
> 
>-    /* one channel only? must be it. */
>-    if (common->wcmChannelCnt == 1) channel = 0;
>+    /* one channel only? */
>+    if (common->wcmChannelCnt == 1) {
>+	/* Intuos3 Pad */
>+	if (serial == 0xffffffff) {
>+	    channel = 1;
>+	    (&common->wcmChannel[channel].work)->device_type = PAD_ID;
>+	    (&common->wcmChannel[channel].work)->proximity = 1;
>+	}
>+	else {  /* must be it. */
>+	    channel = 0;
>+	    if (common->wcmChannel[0].work.proximity == 0) {
>+		memset(&common->wcmChannel[0],0,sizeof(WacomChannel));
>+	    }
>+	}
>+    }
>     else {		/* otherwise, find the channel */
>+	/* clear out channels */
>+	for (i=0; i<common->wcmChannelCnt; ++i) {
>+	    if (common->wcmChannel[i].work.proximity == 0) {
>+		memset(&common->wcmChannel[i],0,sizeof(WacomChannel));
>+	    }
>+	}
>+
> 	/* find existing channel */
> 	for (i=0; i<common->wcmChannelCnt; ++i) {
> 	    if (common->wcmChannel[i].work.serial_num == serial) {
>@@ -1122,9 +1205,9 @@
> 	if (channel < 0) {
> 	    for (i=0; i<common->wcmChannelCnt; ++i) {
> 		if (common->wcmChannel[i].work.proximity == 0) {
>-		    /* clear out channel */
>-		    memset(&common->wcmChannel[i],0, sizeof(WacomChannel));
> 		    channel = i;
>+		    /* the in-prox event was missing */
>+		    common->wcmChannel[i].work.proximity = 1;
> 		    break;
> 		}
> 	    }
>@@ -1145,13 +1228,14 @@
> 
> static void usbParseChannel(WacomCommonPtr common, int channel, int serial)
> {
>-    int i;
>+    int i, shift;
>     WacomDeviceState* ds;
>     struct input_event* event;
> 
> #   define MOD_BUTTONS(bit, value) do { \
>+		shift = 1<<bit; \
> 		ds->buttons = (((value) != 0) ? \
>-                (ds->buttons | (bit)) : (ds->buttons & ~(bit))); \
>+                (ds->buttons | (shift)) : (ds->buttons & ~(shift))); \
>                 } while (0)
> 
>     /* all USB data operates from previous context except relative values*/
>@@ -1173,17 +1257,18 @@
> 		ds->x = event->value;
> 	    else if (event->code == ABS_Y)
> 		ds->y = event->value;
>+	    else if (event->code == ABS_RX)
>+		ds->stripx = event->value;
>+	    else if (event->code == ABS_RY)
>+		ds->stripy = event->value;
> 	    else if (event->code == ABS_RZ)
> 		ds->rotation = event->value;
> 	    else if (event->code == ABS_TILT_X)
> 		ds->tiltx = event->value - 64;
> 	    else if (event->code ==  ABS_TILT_Y)
> 		ds->tilty = event->value - 64;
>-	    else if (event->code == ABS_PRESSURE) {
>+	    else if (event->code == ABS_PRESSURE)
> 		ds->pressure = event->value;
>-		MOD_BUTTONS (1, event->value > common->wcmThreshold ? 1 : 0);
>-		/* pressure button should be downstream */
>-	    }
> 	    else if (event->code == ABS_DISTANCE)
> 		ds->distance = event->value;
> 	    else if (event->code == ABS_WHEEL)
>@@ -1211,18 +1296,38 @@
> 		DBG(6, ErrorF("USB mouse detected %x\n", event->code));
> 		ds->device_type = CURSOR_ID;
> 		ds->proximity = (event->value != 0);
>+	    } else if (event->code == BTN_TOOL_FINGER) {
>+		    DBG(6, ErrorF("USB Intuos3 Pad detected %x\n", event->code));
>+		    ds->device_type = PAD_ID;
>+		    ds->proximity = (event->value != 0);
> 	    } else if (event->code == BTN_TOUCH) {
> 		/* we use the pressure to determine the button 1 for now */
> 	    } else if ((event->code == BTN_STYLUS) || (event->code == BTN_MIDDLE)) {
>-		MOD_BUTTONS (2, event->value);
>+		MOD_BUTTONS (1, event->value);
> 	    } else if ((event->code == BTN_STYLUS2) || (event->code == BTN_RIGHT)) {
>-		 MOD_BUTTONS (4, event->value);
>+		 MOD_BUTTONS (2, event->value);
> 	    } else if (event->code == BTN_LEFT)
>-		MOD_BUTTONS (1, event->value);
>+		MOD_BUTTONS (0, event->value);
> 	    else if (event->code == BTN_SIDE)
>-		MOD_BUTTONS (8, event->value);
>+		MOD_BUTTONS (3, event->value);
> 	    else if (event->code == BTN_EXTRA)
>-		MOD_BUTTONS (16, event->value);
>+		MOD_BUTTONS (4, event->value);
>+	    else if (event->code == BTN_0)
>+		MOD_BUTTONS (8, event->value);
>+	    else if (event->code == BTN_1)
>+		MOD_BUTTONS (9, event->value);
>+	    else if (event->code == BTN_2)
>+		MOD_BUTTONS (10, event->value);
>+	    else if (event->code == BTN_3)
>+		MOD_BUTTONS (11, event->value);
>+	    else if (event->code == BTN_4)
>+		MOD_BUTTONS (12, event->value);
>+	    else if (event->code == BTN_5)
>+		MOD_BUTTONS (13, event->value);
>+	    else if (event->code == BTN_6)
>+		MOD_BUTTONS (14, event->value);
>+ 	    else if (event->code == BTN_7)
>+		MOD_BUTTONS (15, event->value);
> 	}
>     } /* next event */
> 
>@@ -1783,8 +1888,7 @@
>                                 ((data[5] & 0x78) >> 3));
> 	if ((data[0] & 0xb8) == 0xa0) {
> 	    ds->pressure = (((data[5] & 0x07) << 7) | (data[6] & 0x7f));
>-	    ds->buttons = (((data[0]) & 0x06) | (ds->pressure >= common->wcmThreshold));
>-	    /* pressure button should go down stream */
>+	    ds->buttons = (data[0] & 0x06);
> 	} else {
> 	    /* 10 bits for absolute wheel position */
> 	    ds->abswheel = (((data[5] & 0x07) << 7) | (data[6] & 0x7f));
>@@ -2176,9 +2280,6 @@
>     /* first time into prox */
>     if (!last->proximity && ds->proximity) ds->device_type = cur_type;
> 
>-    /* out of prox */
>-    else if (!ds->proximity) memset(ds,0,sizeof(*ds));
>-
>     /* check on previous proximity */
>     else if (is_stylus) {
> 	/* we were fooled by tip and second
>@@ -2232,14 +2333,14 @@
>     "General ISDV4",
>     isdv4InitISDV4,
>     NULL,                 /* resolution not queried */
>-    NULL,                 /* ranges not queried */
>+    isdv4GetRanges,       /* query ranges  */
>     NULL,                 /* reset not supported */
>     NULL,                 /* tilt automatically enabled */
>     NULL,                 /* suppress implemented in software */
>     NULL,                 /* link speed unsupported */
>-    NULL,                 /* start not supported */
>+    isdv4StartTablet,     /* start tablet */
>     isdv4Parse,
>-    xf86WcmFilterCoord,   /* input filtering */
>+    xf86WcmHysteresisFilter,   /* input filtering */
> };
> 
> /*****************************************************************************
>@@ -2267,11 +2368,11 @@
> 
>     DBG(1, ErrorF("resetting tablet\n"));
> 
>-    /* Set the speed of the serial link to 38400 */
>-    if (xf86WcmSetSerialSpeed(local->fd, 38400) < 0) return !Success;
>+    /* Set the speed of the serial link to 19200 */
>+    if (xf86WcmSetSerialSpeed(local->fd, 19200) < 0) return !Success;
> 
>-    /* Send reset to the tablet */
>-    SYSCALL(err = xf86WcmWrite(local->fd, WC_RESET_BAUD, strlen(WC_RESET_BAUD)));
>+    /* Send stop command to the tablet */
>+    SYSCALL(err = xf86WcmWrite(local->fd, WC_ISDV4_STOP, strlen(WC_ISDV4_STOP)));
>     if (err == -1) {
> 	ErrorF("Wacom xf86WcmWrite error : %s\n", strerror(errno));
> 	return !Success;
>@@ -2280,68 +2381,103 @@
>     /* Wait 250 mSecs */
>     if (xf86WcmWait(250)) return !Success;
> 
>-    /* Send reset to the tablet */
>-    SYSCALL(err = xf86WcmWrite(local->fd, WC_RESET, strlen(WC_RESET)));
>-    if (err == -1) {
>-	ErrorF("Wacom xf86WcmWrite error : %s\n", strerror(errno));
>-	return !Success;
>+    return xf86WcmInitTablet(common,&isdv4General,local->fd,"ISDV4", common->wcmVersion);
>+}
>+
>+/*****************************************************************************
>+ * isdv4InitISDV4 -- Setup the device
>+ ****************************************************************************/
>+
>+static void isdv4InitISDV4(WacomCommonPtr common, int fd,
>+        const char* id, float version)
>+{
>+    int temp;
>+    DBG(2, ErrorF("initializing as ISDV4 model\n"));
>+
>+    /* set parameters */
>+    common->wcmProtocolLevel = 4;
>+    common->wcmResolX = 2540;       /* X resolution in points/inch */
>+    common->wcmResolY = 2540;       /* Y resolution in points/inch */
>+    common->wcmPktLength = 9;       /* length of a packet */
>+    common->wcmTPCButton = 1;       /* Tablet PC buttons on by default */
>+
>+    if (common->wcmRotate==ROTATE_CW || common->wcmRotate==ROTATE_CCW) {
>+	temp = common->wcmMaxX;
>+	common->wcmMaxX = common->wcmMaxY;
>+	common->wcmMaxY = temp;
>     }
>+}
> 
>-    /* Wait 75 mSecs */
>-    if (xf86WcmWait(75)) return !Success;
>+static int isdv4GetRanges(WacomCommonPtr common, int fd)
>+{
>+    char data[BUFFER_SIZE];
>+    int maxtry = MAXTRY, nr;
> 
>-    /* Set the speed of the serial link to 19200 */
>-    if (xf86WcmSetSerialSpeed(local->fd, 19200) < 0) return !Success;
>+    DBG(2, ErrorF("getting ISDV4 Ranges\n"));
>+    /* Send query command to the tablet */
>+    do {
>+	SYSCALL(nr = xf86WcmWrite(fd, WC_ISDV4_QUERY, strlen(WC_ISDV4_QUERY)));
>+	if ((nr == -1) && (errno != EAGAIN)) {
>+	    ErrorF("Wacom xf86WcmWrite error : %s", strerror(errno));
>+	    return !Success;
>+	}
>+	maxtry--;
>+    } while ((nr == -1) && maxtry);
> 
>-    /* Send reset to the tablet */
>-    SYSCALL(err = xf86WcmWrite(local->fd, WC_RESET_BAUD, strlen(WC_RESET_BAUD)));
>-    if (err == -1) {
>-	ErrorF("Wacom xf86WcmWrite error : %s\n", strerror(errno));
>+    if (maxtry == 0) {
>+	ErrorF("Wacom unable to xf86WcmWrite request query command "
>+				"after %d tries\n", MAXTRY);
> 	return !Success;
>     }
> 
>-    /* Wait 250 mSecs */
>-    if (xf86WcmWait(250)) return !Success;
>+    /* Read the control data */
>+    maxtry = MAXTRY;
>+    do {
>+	if ((nr = xf86WcmWaitForTablet(fd)) > 0) {
>+	    SYSCALL(nr = xf86WcmRead(fd, data, 11));
>+	    if ((nr == -1) && (errno != EAGAIN)) {
>+		ErrorF("Wacom xf86WcmRead error : %s\n", strerror(errno));
>+		return !Success;
>+	    }
>+	}
>+	maxtry--;  
>+    } while ( nr <= 0 && maxtry );
> 
>-    /* Send reset to the tablet */
>-    SYSCALL(err = xf86WcmWrite(local->fd, WC_RESET, strlen(WC_RESET)));
>-    if (err == -1) {
>-	ErrorF("Wacom xf86WcmWrite error : %s\n", strerror(errno));
>+    if (maxtry == 0 && nr <= 0 ) {
>+	ErrorF("Wacom unable to read ISDV4 control data "
>+			"after %d tries\n", MAXTRY);
> 	return !Success;
>     }
> 
>-    /* Wait 75 mSecs */
>-    if (xf86WcmWait(75)) return !Success;
>-
>-    xf86WcmFlushTablet(local->fd);
>+    /* Control data bit check */
>+    if ( !(data[0] & 0x40) ) {
>+	ErrorF("Wacom Query ISDV4 error magic error \n");
>+	return !Success;
>+    }
>+	
>+    common->wcmMaxZ = ( data[5] | ((data[6] & 0x07) << 7) );
>+    common->wcmMaxX = ( (data[1] << 9) | (data[2] << 2) 
>+				| ( (data[6] & 0x60) >> 5) );      
>+    common->wcmMaxY = ( (data[3] << 9) | (data[4] << 2 ) 
>+				| ( (data[6] & 0x18) >> 3) );
>+    common->wcmVersion = ( data[10] | (data[9] << 7) );
> 
>-    DBG(2, ErrorF("not reading model -- Wacom TabletPC ISD V4\n"));
>-    return xf86WcmInitTablet(common,&isdv4General,local->fd,"unknown",0.0);
>+    return Success;
> }
> 
>-/*****************************************************************************
>- * isdv4InitISDV4 -- Setup the device
>- ****************************************************************************/
>-
>-static void isdv4InitISDV4(WacomCommonPtr common, int fd,
>-        const char* id, float version)
>+static int isdv4StartTablet(WacomCommonPtr common, int fd)
> {
>-    DBG(2, ErrorF("initializing as ISDV4 model\n"));
>+    int err;
> 
>-    /* set parameters */
>-    common->wcmProtocolLevel = 0;
>-    common->wcmMaxZ = 255;          /* max Z value (pressure)*/
>-    common->wcmResolX = 2570;       /* X resolution in points/inch */
>-    common->wcmResolY = 2570;       /* Y resolution in points/inch */
>-    common->wcmPktLength = 9;       /* length of a packet */
>+    /* Tell the tablet to start sending coordinates */
>+    SYSCALL(err = xf86WcmWrite(fd, WC_ISDV4_SAMPLING, (strlen(WC_ISDV4_SAMPLING))));
> 
>-    if (common->wcmRotate==ROTATE_NONE) {
>-	common->wcmMaxX = 21136;
>-	common->wcmMaxY = 15900;
>-    } else if (common->wcmRotate==ROTATE_CW || common->wcmRotate==ROTATE_CCW) {
>-	common->wcmMaxX = 15900;
>-	common->wcmMaxY = 21136;
>+    if (err == -1) {
>+	ErrorF("Wacom xf86WcmWrite error : %s\n", strerror(errno));
>+	return !Success;
>     }
>+
>+    return Success;
> }
> 
> static int isdv4Parse(WacomCommonPtr common, const unsigned char* data)
>@@ -2350,7 +2486,12 @@
>     WacomDeviceState* ds;
>     int n, cur_type, tmp_coord;
> 
>-    if ((n = xf86WcmSerialValidate(common,data)) > 0) return n;
>+    if ((n = xf86WcmSerialValidate(common,data)) > 0) 
>+	return n;
>+    else {
>+	/* Coordinate data bit check */
>+	if (data[0] & 0x40) return common->wcmPktLength;
>+    }
> 
>     /* pick up where we left off, minus relative values */
>     ds = &common->wcmChannel[0].work;
>@@ -2376,33 +2517,13 @@
>     }
> 
>     /* pressure */
>-    ds->pressure = ((data[6] & 0x01) << 7) | (data[5] & 0x7F);
>+    ds->pressure = ((data[6] & 0x07) << 7) | data[5];
> 
>-    /* button order is slightly amiss so that styluses with only
>-     * one side button have buttons 1 and 3 */
>-
>-    /* report touch as button 1 */
>-    ds->buttons = (data[0] & 0x01) ? 1 : 0 ;
>-
>-    /* report side switch as button 3 */
>-    ds->buttons |= (data[0] & 0x02) ? 0x04 : 0 ;
>-
>-    /* report as button 2 (subject eraser check below) */
>-    ds->buttons |= (data[0] & 0x04) ? 0x02 : 0 ;
>-
>-    /* the bit used for button 2 is also used to ID the
>-     * eraser.  If the tool comes into proximity with this bit
>-     * set, it is assumed to be the eraser.  If the tool was
>-     * previously in proximity, it is assumed to be the button.
>-     * The mistaken identity case is handled with proximity below. */
>+    /* button */
>+    ds->buttons = (data[0] & 0x07) ;
> 
>     /* check which device we have */
>-    cur_type = (data[0] & 0x04) ? ERASER_ID : STYLUS_ID;
>-
>-    /* If there's no eraser configured, let's not even try to
>-     * report an eraser (handy for making button 2 action more
>-     * definite) */
>-    if ( common->wcmNumDevices == 1 && cur_type == ERASER_ID ) cur_type = STYLUS_ID;
>+    cur_type = (ds->buttons & 4) ? ERASER_ID : STYLUS_ID;
> 
>     /* first time into prox */
>     if (!last->proximity && ds->proximity) ds->device_type = cur_type;
>@@ -2617,13 +2738,13 @@
> 
> static void filterIntuosStylus(WacomFilterStatePtr state, WacomDeviceStatePtr ds)
> {
>-    if (!state->npoints) {
>+    if (state->npoints < 3) {
>+	state->x[state->npoints] = ds->x;
>+	state->y[state->npoints] = ds->y;
>+	state->tiltx[state->npoints] = ds->tiltx;
>+	state->tilty[state->npoints] = ds->tilty;
> 	++state->npoints;
>-	DBG(2,ErrorF("filterIntuosStylus: first sample NO_FILTER\n"));
>-	state->x[0] = state->x[1] = state->x[2] = ds->x;
>-	state->y[0] = state->y[1] = state->y[2] = ds->y;
>-	state->tiltx[0] = state->tiltx[1] = state->tiltx[2] = ds->tiltx;
>-	state->tilty[0] = state->tilty[1] = state->tilty[2] = ds->tilty;
>+	DBG(11,ErrorF("filterIntuosStylus: first %d sample(s) NO_FILTER\n",state->npoints));
> 	return;
>     }
> 
>@@ -2672,10 +2793,6 @@
>                 x1/100.0, y1/100.0,     /* control point 2 */
>                 1.0, 1.0);              /* top right */
> 
>-    for (i=0; i<=FILTER_PRESSURE_RES; i+=128)
>-	DBG(6, ErrorF("PRESSCURVE: %d=%d (%d)\n",i,pDev->pPressCurve[i],
>-                        pDev->pPressCurve[i] - i));
>-
>     pDev->nPressCtrl[0] = x0;
>     pDev->nPressCtrl[1] = y0;
>     pDev->nPressCtrl[2] = x1;
>@@ -2698,11 +2815,11 @@
> 
>     x = pChannel->rawFilter.x;
>     y = pChannel->rawFilter.y;
>-    if (!pChannel->rawFilter.npoints) {
>+    if (pChannel->rawFilter.npoints<3) {
>+	x[pChannel->rawFilter.npoints] = ds->x;
>+	y[pChannel->rawFilter.npoints] = ds->y;
> 	++pChannel->rawFilter.npoints;
>-	DBG(2,ErrorF("xf86WcmFilterCoord: first sample NO_FILTER\n"));
>-	x[0] = x[1] = x[2] = ds->x;
>-	y[0] = y[1] = y[2] = ds->y;
>+	DBG(11,ErrorF("xf86WcmFilterCoord: first %d sample NO_FILTER\n",pChannel->rawFilter.npoints));
> 	return 0;
>     }
> 
>@@ -2731,7 +2848,7 @@
> }
> 
> /*****************************************************************************
>- * xf86WcmFilterCoord -- provide error correction to Intuos and Intuos2
>+ * xf86WcmFilterIntuos -- provide error correction to Intuos and Intuos2
>  ****************************************************************************/
> 
> static int xf86WcmFilterIntuos(WacomCommonPtr common, WacomChannelPtr pChannel,
>@@ -2748,7 +2865,24 @@
>     return 0; /* lookin' good */
> }
> 
>+/*****************************************************************************
>+ * xf86WcmHysteresisFilter -- provide noise correction to protocol IV transducers
>+ ****************************************************************************/
> 
>+static int xf86WcmHysteresisFilter(WacomCommonPtr common, WacomChannelPtr pChannel,
>+	WacomDeviceStatePtr ds)
>+{
>+    WacomDeviceState* pLast;
>+    pLast = &pChannel->valid.state;
>+
>+    if (abs(ds->x - pLast->x) < 4)
>+	ds->x = pLast->x;
>+
>+    if (abs(ds->y - pLast->y) < 4)
>+	ds->y = pLast->y;
>+
>+    return 0;
>+}
> 
> /*
>  ***************************************************************************
>@@ -2791,57 +2925,51 @@
>     }
> #endif
>     if (priv->twinview != TV_NONE && (priv->flags & ABSOLUTE_FLAG)) {
>-	v0 -= priv->topX;
>-	v1 -= priv->topY;
>+	v0 -= priv->topX - priv->tvoffsetX;
>+	v1 -= priv->topY - priv->tvoffsetY;
> 	if (priv->twinview == TV_LEFT_RIGHT) {
>-	    if (v0 > priv->bottomX)
>+	    if (v0 > priv->bottomX - priv->tvoffsetX)
> 	    {
>-		v0 -= priv->bottomX;
>-		priv->currentScreen = 1;
>-		if (priv->screen_no == 0) {
>-		    priv->currentScreen = 0;
>-		}
>-	    } else {
>-		priv->currentScreen = 0;
>-		if (priv->screen_no == 1) {
>-		    priv->currentScreen = 1;
>+		if (priv->currentScreen == 0)
>+		    v0 = priv->bottomX - priv->tvoffsetX;
>+		else {
>+		    v0 -= priv->bottomX - priv->topX - 2*priv->tvoffsetX;
>+		    if (v0 > priv->bottomX - priv->tvoffsetX)
>+			v0 = 2*(priv->bottomX - priv->tvoffsetX) - v0;
> 		}
> 	    }
> 	    if (priv->currentScreen == 1) {
> 		*x = priv->tvResolution[0] + priv->tvResolution[2]
>-                               * v0 / (priv->bottomX - priv->topX);
>+                        * v0 / (priv->bottomX - priv->topX - 2*priv->tvoffsetX);
> 		*y = v1 * priv->tvResolution[3] /
>-                               (priv->bottomY - priv->topY) + 0.5;
>+                        (priv->bottomY - priv->topY - 2*priv->tvoffsetY) + 0.5;
> 	    } else {
> 		*x = priv->tvResolution[0] * v0 /
>-                               (priv->bottomX - priv->topX);
>+                        (priv->bottomX - priv->topX - 2*priv->tvoffsetX);
> 		*y = v1 * priv->tvResolution[1] /
>-                               (priv->bottomY - priv->topY) + 0.5;
>+                        (priv->bottomY - priv->topY - 2*priv->tvoffsetY) + 0.5;
> 	    }
>  	}
> 	if (priv->twinview == TV_ABOVE_BELOW) {
>-	    if (v1 > priv->bottomY) {
>-		v1 -= priv->bottomY;
>-		priv->currentScreen = 1;
>-		if (priv->screen_no == 0) {
>-		    priv->currentScreen = 0;
>-		}
>-	    } else {
>-		priv->currentScreen = 0;
>-		if (priv->screen_no == 1) {
>-		    priv->currentScreen = 1;
>+	    if (v1 > priv->bottomY - priv->tvoffsetY) {
>+		if (priv->currentScreen == 0)
>+		    v1 = priv->bottomY - priv->tvoffsetY;
>+		else {
>+		    v1 -= priv->bottomY - priv->topY - 2*priv->tvoffsetY;
>+		    if (v1 > priv->bottomY - priv->tvoffsetY)
>+			v1 = 2*(priv->bottomY - priv->tvoffsetY) - v1;
> 		}
> 	    }
> 	    if (priv->currentScreen == 1) {
> 		*x = v0 * priv->tvResolution[2] /
>-                                   (priv->bottomX - priv->topX) + 0.5;
>+                        (priv->bottomX - priv->topX - 2*priv->tvoffsetX) + 0.5;
> 		*y = priv->tvResolution[1] + priv->tvResolution[3] * v1
>-                                   / (priv->bottomY - priv->topY);
>+                         / (priv->bottomY - priv->topY - 2*priv->tvoffsetY);
> 	    } else {
> 		*x = v0 * priv->tvResolution[0] /
>-                                  (priv->bottomX - priv->topX) + 0.5;
>+                        (priv->bottomX - priv->topX - 2*priv->tvoffsetX) + 0.5;
> 		*y = priv->tvResolution[1] * v1 /
>-                                   (priv->bottomY - priv->topY);
>+                        (priv->bottomY - priv->topY - 2*priv->tvoffsetY);
> 	    }
> 	}
>     } else {
>@@ -2874,7 +3002,7 @@
> 
> #ifdef PANORAMIX
>     if (!noPanoramiXExtension && (priv->flags & ABSOLUTE_FLAG) &&
>-                priv->common->wcmGimp) {
>+                priv->common->wcmGimp && priv->common->wcmMMonitor) {
> 	int i, totalWidth, leftPadding = 0;
> 	for (i = 0; i < priv->currentScreen; i++)
> 	    leftPadding += screenInfo.screens[i]->width;
>@@ -2886,57 +3014,41 @@
> #endif
>     if (priv->twinview != TV_NONE && (priv->flags & ABSOLUTE_FLAG)) {
>  	if (priv->twinview == TV_LEFT_RIGHT) {
>-	    if (x > priv->tvResolution[0]) {
>+	    if (x > priv->tvResolution[0])
> 		x -= priv->tvResolution[0];
>-		priv->currentScreen = 1;
>-		if (priv->screen_no == 0) {
>-		    priv->currentScreen = 0;
>-		}
>-	    } else {
>-		priv->currentScreen = 0;
>-		if (priv->screen_no == 1) {
>-		    priv->currentScreen = 1;
>-		}
>-	    }
> 	    if (priv->currentScreen == 1) {
>-		valuators[0] = x * (priv->bottomX - priv->topX)
>-			/ priv->tvResolution[2] + priv->bottomX - priv->topX + 0.5;
>-		valuators[1] = y * (priv->bottomY - priv->topY) /
>-			 priv->tvResolution[3] + 0.5;
>-	    } else {
>-		valuators[0] = x * (priv->bottomX - priv->topX)
>-			/ priv->tvResolution[0] + 0.5;
>-		valuators[1] = y * (priv->bottomY - priv->topY) /
>-			 priv->tvResolution[1] + 0.5;
>+		valuators[0] = x * (priv->bottomX - priv->topX - 2*priv->tvoffsetX)
>+			/ priv->tvResolution[2] + (priv->bottomX - priv->topX - 
>+			2*priv->tvoffsetX) +0.5;
>+		valuators[1] = y * (priv->bottomY - priv->topY - 2*priv->tvoffsetY) /
>+			priv->tvResolution[3] + 0.5;
>+	    }
>+	    else {
>+		valuators[0] = x * (priv->bottomX - priv->topX - 2*priv->tvoffsetX)
>+			 / priv->tvResolution[0] + 0.5;
>+		valuators[1] = y * (priv->bottomY - priv->topY - 2*priv->tvoffsetY) /
>+			priv->tvResolution[1] + 0.5;
> 	    }
> 	}
> 	if (priv->twinview == TV_ABOVE_BELOW) {
>-	    if (y > priv->tvResolution[1]) {
>+	    if (y > priv->tvResolution[1])
> 		y -= priv->tvResolution[1];
>-		priv->currentScreen = 1;
>-		if (priv->screen_no == 0) {
>-		    priv->currentScreen = 0;
>-		}
>-	    } else {
>-		priv->currentScreen = 0;
>-		if (priv->screen_no == 1) {
>-		    priv->currentScreen = 1;
>-		}
>-	    }
> 	    if (priv->currentScreen == 1) {
>-		valuators[0] = x * (priv->bottomX - priv->topX) /
>+		valuators[0] = x * (priv->bottomX - priv->topX - 2*priv->tvoffsetX) /
> 			priv->tvResolution[2] + 0.5;
>-		valuators[1] = y *(priv->bottomY - priv->topY) / 
>- 			priv->tvResolution[3] + priv->bottomY - priv->topY + 0.5;
>-	    } else {
>-		valuators[0] = x * (priv->bottomX - priv->topX) /
>+		valuators[1] = y *(priv->bottomY - priv->topY - 2*priv->tvoffsetY)
>+			/ priv->tvResolution[3] +
>+		priv->bottomY - priv->topY - 2*priv->tvoffsetY + 0.5;
>+	    }
>+	    else {
>+		valuators[0] = x * (priv->bottomX - priv->topX - 2*priv->tvoffsetX) /
> 			priv->tvResolution[0] + 0.5;
>-		valuators[1] = y *(priv->bottomY - priv->topY) / 
>-			priv->tvResolution[1] + 0.5;
>+		valuators[1] = y *(priv->bottomY - priv->topY - 2*priv->tvoffsetY)
>+			/ priv->tvResolution[1] + 0.5;
> 	    }
> 	}
>-	valuators[0] += priv->topX;
>-	valuators[1] += priv->topY;
>+	valuators[0] += priv->topX + priv->tvoffsetX;
>+	valuators[1] += priv->topY + priv->tvoffsetY;
>     }
>     DBG(6, ErrorF("Wacom converted x=%d y=%d to v0=%d v1=%d\n", x, y,
> 		  valuators[0], valuators[1]));
>@@ -2961,19 +3073,44 @@
>                int          *v1)
> {
>     WacomDevicePtr	priv = (WacomDevicePtr) local->private;
>-    int                 screenToSet = miPointerCurrentScreen()->myNum;
>-    int                 i;
>-    int 		x, y;
>+    int                 screenToSet = 0;
>+    int                 i, x, y;
>     int 		totalWidth = 0, maxHeight = 0, leftPadding = 0;
>-    double 		sizeX = priv->bottomX - priv->topX;
>-    double 		sizeY = priv->bottomY - priv->topY;
>+    double 		sizeX = priv->bottomX - priv->topX - 2*priv->tvoffsetX;
>+    double 		sizeY = priv->bottomY - priv->topY - 2*priv->tvoffsetY;
> 
>     /* set factorX and factorY for single screen setup since
>      * Top X Y and Bottom X Y can be changed while driver is running
>      */
>-    if (screenInfo.numScreens == 1) {
>-	priv->factorX = screenInfo.screens[0]->width / sizeX;
>-	priv->factorY = screenInfo.screens[0]->height / sizeY;
>+    if (screenInfo.numScreens == 1 || !priv->common->wcmMMonitor) {
>+	if (priv->twinview != TV_NONE && (priv->flags & ABSOLUTE_FLAG)) {
>+	    if (priv->screen_no == -1) {
>+		if (priv->twinview == TV_LEFT_RIGHT) {
>+		    if (*v0 > priv->bottomX - priv->tvoffsetX && *v0 <= priv->bottomX)
>+			priv->currentScreen = 1;
>+		    if (*v0 > priv->topX && *v0 <= priv->topX + priv->tvoffsetX)
>+			priv->currentScreen = 0;
>+		}
>+		if (priv->twinview == TV_ABOVE_BELOW) {
>+		    if (*v1 > priv->bottomY - priv->tvoffsetY && *v1 <= priv->bottomY)
>+			priv->currentScreen = 1;
>+		    if (*v1 > priv->topY && *v1 <= priv->topY + priv->tvoffsetY)
>+			priv->currentScreen = 0;
>+		}
>+	    }
>+	    else
>+		priv->currentScreen = priv->screen_no;
>+	    priv->factorX = priv->tvResolution[2*priv->currentScreen] / sizeX;
>+	    priv->factorY = priv->tvResolution[2*priv->currentScreen+1] / sizeY;
>+	}
>+	else
>+	{
>+	    /* tool on the tablet when driver starts */
>+	    if (miPointerCurrentScreen())
>+		priv->currentScreen = miPointerCurrentScreen()->myNum;
>+	    priv->factorX = screenInfo.screens[priv->currentScreen]->width / sizeX;
>+	    priv->factorY = screenInfo.screens[priv->currentScreen]->height / sizeY;
>+	}
> 	return;
>     }
> 
>@@ -3044,6 +3181,67 @@
> 		priv->currentScreen, screenToSet));
>     priv->currentScreen = screenToSet;
> }
>+
>+/*****************************************************************************
>+ * sendAButton --
>+ *   Send one button event, called by xf86WcmSendButtons
>+ ****************************************************************************/
>+
>+static void sendAButton(LocalDevicePtr local, int button, int mask,
>+		int rx, int ry, int rz, int rtx, int rty, int rrot,
>+		int rth, int rwheel)
>+{
>+    WacomDevicePtr priv = (WacomDevicePtr) local->private;
>+    int is_absolute = priv->flags & ABSOLUTE_FLAG, nbutton;
>+
>+    /* translate into Left Double Click */
>+    if (button == 17) {
>+	nbutton = 1;
>+	if ( mask ) {
>+	    /* Left button down */
>+	    if (IsCursor(priv))
>+		xf86PostButtonEvent(local->dev, is_absolute, nbutton, 
>+				1, 0, 6, rx, ry, rz, rrot, rth, rwheel);
>+	    else
>+		xf86PostButtonEvent(local->dev, is_absolute, nbutton,
>+				1, 0, 6, rx, ry, rz, rtx, rty, rwheel);
>+	    /* Left button up */
>+	    if (IsCursor(priv))
>+		xf86PostButtonEvent(local->dev, is_absolute, nbutton, 
>+				0, 0, 6, rx, ry, rz, rrot, rth, rwheel);
>+	    else
>+		xf86PostButtonEvent(local->dev, is_absolute, nbutton, 
>+				0, 0, 6, rx, ry, rz, rtx, rty, rwheel);
>+	}
>+
>+	/* Left button down/up upon mask is 1/0 */
>+	if (IsCursor(priv))
>+	    xf86PostButtonEvent(local->dev, is_absolute, nbutton, 
>+			mask != 0, 0, 6, rx, ry, rz, rrot, rth, rwheel);
>+	else
>+	    xf86PostButtonEvent(local->dev, is_absolute, nbutton, 
>+			mask != 0, 0, 6, rx, ry, rz, rtx, rty, rwheel);
>+    }
>+    /* switch absolute or relative (Mode Toggle) */
>+    if ( button == 19 && mask ) {
>+	if (is_absolute) {
>+	    priv->flags &= ~ABSOLUTE_FLAG;
>+	    xf86ReplaceStrOption(local->options, "Mode", "Relative");
>+	}
>+	else {
>+	    priv->flags |= ABSOLUTE_FLAG;
>+	    xf86ReplaceStrOption(local->options, "Mode", "Absolute");
>+	}
>+    }
>+    if (button < 17) {
>+	if (IsCursor(priv))
>+	    xf86PostButtonEvent(local->dev, is_absolute, button,
>+			mask != 0, 0, 6, rx, ry, rz, rrot, rth, rwheel);
>+	else
>+	    xf86PostButtonEvent(local->dev, is_absolute, button,
>+			mask != 0, 0, 6, rx, ry, rz, rtx, rty, rwheel);
>+    }
>+}
>  
> /*
>  ***************************************************************************
>@@ -3067,54 +3265,89 @@
> 		   int			rwheel)
> 		   
> {
>-    int             button, newb;
>+    int             button, mask, bsent = 0;
>     WacomDevicePtr  priv = (WacomDevicePtr) local->private;
>+    WacomCommonPtr  common = priv->common;
> 
>-    for (button=1; button<=16; button++) {
>-	int mask = 1 << (button-1);
>-	
>-	if ((mask & priv->oldButtons) != (mask & buttons)) {
>-	    DBG(4, ErrorF("xf86WcmSendButtons button=%d state=%d, for %s\n", 
>-			  button, (buttons & mask) != 0, local->name));
>-	    /* set to the configured buttons */
>-	    newb = button;
>-	    if (priv->button[button-1] != button)
>-		newb = priv->button[button-1];
>+    /* Tablet PC buttons. */
>+    if ( common->wcmTPCButton && !IsCursor(priv) && !IsPad(priv) ) {
>+	if ( buttons & 1 ) {
>+	    if ( !(priv->flags & TPCBUTTONS_FLAG) ) {
>+		priv->flags |= TPCBUTTONS_FLAG;
>+
>+		bsent = 0;
>+
>+		/* send all pressed buttons down */
>+		for (button=2; button<=16; button++) {
>+		    mask = 1 << (button-1);
>+		    if ( buttons & mask ) {
>+			bsent = 1;
>+			/* set to the configured button */
>+			sendAButton(local, priv->button[button-1], 1, rx, ry, 
>+					rz, rtx, rty, rrot, rth, rwheel);
>+		    }
>+		}
>+				
>+		/* only send button one when nothing else was sent 
>+		 * There is a bug in XFree86 for combined left click and 
>+		 * other button. It'll lost left up when releases.
>+		 * This should be removed if XFree86 fixes the problem.
>+		 */
>+		if ( !bsent && (buttons & 1) ) {
>+		    priv->flags |= TPCBUTTONONE_FLAG;
>+		    sendAButton(local, priv->button[0], 1, rx, ry, 
>+				rz, rtx, rty, rrot, rth, rwheel);
>+		}
>+	    }
>+	    else {
>+		bsent = 0;
>+		for (button=2; button<=16; button++) {
>+		    mask = 1 << (button-1);
>+		    if ((mask & priv->oldButtons) != (mask & buttons)) {
>+			/* Send button one up before any button down is sent.
>+			 * There is a bug in XFree86 for combined left click and 
>+			 * other button. It'll lost left up when releases.
>+			 * This should be removed if XFree86 fixes the problem.
>+			 */
>+			if (priv->flags & TPCBUTTONONE_FLAG && !bsent) {
>+			    priv->flags &= ~TPCBUTTONONE_FLAG;
>+			    sendAButton(local, 1, 0, rx, ry, rz, rtx, rty, rrot, rth, rwheel);
>+			    bsent = 1;
>+			}
>+			/* set to the configured buttons */
>+			sendAButton(local, priv->button[button-1], mask & buttons, 
>+						rx, ry, rz, rtx, rty, rrot, rth, rwheel);
>+		    }
>+		}
>+	    }
>+	}
>+	else if ( priv->flags & TPCBUTTONS_FLAG ) {
>+	    priv->flags &= ~TPCBUTTONS_FLAG;
> 
>-	    /* translate into Left Double Click */
>-	    if (newb == 17)
>-	    {
>-		newb = 1;
>-		if (buttons & mask)
>-		{
>-		    /* Left button down */
>-		    if (IsCursor(priv))
>-			xf86PostButtonEvent(local->dev,
>-				(priv->flags & ABSOLUTE_FLAG), newb, 1,
>-				0, 6, rx, ry, rz, rrot, rth, rwheel);
>-		    else
>-			xf86PostButtonEvent(local->dev,
>-				(priv->flags & ABSOLUTE_FLAG), newb, 1,
>-				0, 6, rx, ry, rz, rtx, rty, rwheel);
>-		    /* Left button up */
>-		    if (IsCursor(priv))
>-			xf86PostButtonEvent(local->dev, (priv->flags & ABSOLUTE_FLAG), 
>-				newb, 0, 0, 6, rx, ry, rz, rrot, rth, rwheel);
>-		    else
>-			xf86PostButtonEvent(local->dev, (priv->flags & ABSOLUTE_FLAG), 
>-				newb, 0, 0, 6, rx, ry, rz, rtx, rty, rwheel);
>+	    /* send all pressed buttons up */
>+	    for (button=2; button<=16; button++) {
>+		mask = 1 << (button-1);
>+		if ((mask & priv->oldButtons) != (mask & buttons) || (mask & buttons) ) {
>+		    /* set to the configured button */
>+		    sendAButton(local, priv->button[button-1], 0, rx, ry, 
>+					rz, rtx, rty, rrot, rth, rwheel);
> 		}
> 	    }
>-	    if (newb <= 17)
>-	    {
>-		if (IsCursor(priv))
>-		    xf86PostButtonEvent(local->dev, (priv->flags & ABSOLUTE_FLAG),
>-				newb, (buttons & mask) != 0,
>-				0, 6, rx, ry, rz, rrot, rth, rwheel);
>-		else
>-		    xf86PostButtonEvent(local->dev, (priv->flags & ABSOLUTE_FLAG),
>-				newb, (buttons & mask) != 0,
>-				0, 6, rx, ry, rz, rtx, rty, rwheel);
>+	    /* This is also part of the workaround of the XFree86 bug mentioned above
>+	     */
>+	    if (priv->flags & TPCBUTTONONE_FLAG) {
>+		priv->flags &= ~TPCBUTTONONE_FLAG;
>+		sendAButton(local, 1, 0, rx, ry, rz, rtx, rty, rrot, rth, rwheel);
>+	    }
>+	}
>+    }
>+    else { /* normal buttons */
>+	for (button=1; button<=16; button++) {
>+	    mask = 1 << (button-1);
>+	    if ((mask & priv->oldButtons) != (mask & buttons)) {
>+		/* set to the configured button */
>+		sendAButton(local, priv->button[button-1], mask & buttons, rx, ry, 
>+			rz, rtx, rty, rrot, rth, rwheel);
> 	    }
> 	}
>     }
>@@ -3130,7 +3363,8 @@
>  */
> static void
> xf86WcmSendEvents(LocalDevicePtr	local,
>-		  const WacomDeviceState *ds)
>+		  const WacomDeviceState *ds,
>+		  unsigned int channel)
> {
>     int 		type = ds->device_type;
>     int 		is_button = !!(ds->buttons);
>@@ -3146,18 +3380,24 @@
>     int 		wheel = ds->abswheel;
>     WacomDevicePtr	priv = (WacomDevicePtr) local->private;
>     WacomCommonPtr	common = priv->common;
>-    int			rx, ry, rz, rtx, rty, rrot, rth, rw;
>-    int			is_core_pointer, is_absolute;
>+    int			rx, ry, rz, rtx, rty, rrot, rth, rw, no_jitter;
>+    double		param, relacc;
>+    int			is_core_pointer, is_absolute, doffsetX=0, doffsetY=0;
>     int			aboveBelowSwitch = (priv->twinview == TV_ABOVE_BELOW) ? 
>  				((y < priv->topY) ? -1 : ((priv->bottomY < y) ? 1 : 0)) : 0;
>     int			leftRightSwitch = (priv->twinview == TV_LEFT_RIGHT) ? 
> 				((x < priv->topX) ? -1 : ((priv->bottomX < x) ? 1 : 0)) : 0;
> 
>+    /* use tx and ty to report stripx and stripy */
>+    if (type == PAD_ID) {
>+	tx = ds->stripx;
>+	ty = ds->stripy;
>+    }
>+
>     DBG(7, ErrorF("[%s] prox=%s\tx=%d\ty=%d\tz=%d\tbutton=%s\tbuttons=%d\ttx=%d ty=%d\twl=%d rot=%d th=%d\n",
>-		  (type == STYLUS_ID) ? "stylus" : (type == CURSOR_ID) ? "cursor" : "eraser",
>-		  is_proximity ? "true" : "false",
>-		  x, y, z,
>-		  is_button ? "true" : "false", buttons,
>+		  (type == STYLUS_ID) ? "stylus" : (type == CURSOR_ID) ? "cursor" : 
>+		  (type == ERASER_ID) ? "eraser" : "pad", is_proximity ? "true" : "false",
>+		  x, y, z, is_button ? "true" : "false", buttons,
> 		  tx, ty, wheel, rot, throttle));
> 
>     is_absolute = (priv->flags & ABSOLUTE_FLAG);
>@@ -3168,25 +3408,25 @@
> 	switch ( leftRightSwitch )
> 	{
> 	    case -1:
>-		priv->doffsetX = 0;
>+		doffsetX = 0;
> 		break;
> 	    case 1:
>-		priv->doffsetX = priv->bottomX - priv->topX;
>+		doffsetX = priv->bottomX - priv->topX - 2*priv->tvoffsetX;
> 		break;
> 	}
> 	switch ( aboveBelowSwitch )
> 	{
> 	    case -1:
>-		priv->doffsetY = 0;
>+		doffsetY = 0;
> 		break;
> 	    case 1:
>-		priv->doffsetY = priv->bottomY - priv->topY;
>+		doffsetY = priv->bottomY - priv->topY - 2*priv->tvoffsetY;
> 		break;
> 	}
>     }
> 
>-    x += priv->doffsetX;
>-    y += priv->doffsetY;
>+    x += doffsetX;
>+    y += doffsetY;
> 
>     /* sets rx and ry according to the mode */
>     if (is_absolute) {
>@@ -3220,27 +3460,32 @@
> 	    rx = 0;
> 	    ry = 0;
> 	}
>-	if (priv->speed != DEFAULT_SPEED ) {
>-            /* don't apply acceleration for fairly small
>-             * increments (but larger than speed setting).
>-             */
>-            int no_jitter = priv->speed * 3;
>-	    double param = priv->speed;
>-	    double relacc = (MAX_ACCEL-priv->accel)*(MAX_ACCEL-priv->accel);
>-            if (ABS(rx) > no_jitter)
>-	    {
>+        /* don't apply acceleration for fairly small
>+         * increments (but larger than speed setting).
>+         */
>+        no_jitter = priv->speed * 3;
>+	relacc = (MAX_ACCEL-priv->accel)*(MAX_ACCEL-priv->accel);
>+        if (ABS(rx) > no_jitter) {
>+	    param = priv->speed;
>+
>+	    /* apply acceleration only when priv->speed > DEFAULT_SPEED */
>+	    if (priv->speed > DEFAULT_SPEED ) {
>+		param += priv->accel > 0 ? abs(rx)/relacc : 0;
> 		/* don't apply acceleration when too fast. */
>-		param += priv->accel > 0 ? rx/relacc : 0;
>-		if (param > 20.00)
>-		    rx *= param;
>+		if (param < 20.00) rx *= param;
> 	    }
>-            if (ABS(ry) > no_jitter)
>-	    {
>-		param += priv->accel > 0 ? ry/relacc : 0;
>-		if (param > 20.00)
>-		    ry *= param;
>+	}
>+        if (ABS(ry) > no_jitter) {
>+ 	    param = priv->speed;
>+
>+	    /* apply acceleration only when priv->speed > DEFAULT_SPEED */
>+	    if (priv->speed > DEFAULT_SPEED ) {
>+		param += priv->accel > 0 ? abs(ry)/relacc : 0;
>+		/* don't apply acceleration when too fast. */
>+		if (param < 20.00) ry *= param;
> 	    }
>         }
>+
> 	rz = z - priv->oldZ;
> 	rtx = tx - priv->oldTiltX;
> 	rty = ty - priv->oldTiltY;
>@@ -3251,7 +3496,8 @@
> 
>     /* for multiple monitor support, we need to set the proper
>      * screen and modify the axes before posting events */
>-    xf86WcmSetScreen(local, &rx, &ry);
>+    if( !(priv->flags & BUTTONS_ONLY_FLAG) || !channel )
>+	xf86WcmSetScreen(local, &rx, &ry);
> 
>     /* coordinates are ready we can send events */
>     if (is_proximity) {
>@@ -3263,7 +3509,7 @@
> 		xf86PostProximityEvent(local->dev, 1, 0, 6, rx, ry, rz, rtx, rty, rw);
> 	}
> 
>-	if(!(priv->flags & BUTTONS_ONLY_FLAG)) {
>+	if(!(priv->flags & BUTTONS_ONLY_FLAG) || !channel) {
> 	    if (IsCursor(priv))
> 		xf86PostMotionEvent(local->dev, is_absolute, 0, 6, rx, ry, rz, rrot, rth, rw);
> 	    else
>@@ -3339,6 +3585,8 @@
>     priv->oldZ = z;
>     priv->oldTiltX = tx;
>     priv->oldTiltY = ty;
>+    priv->oldStripX = ds->stripx;
>+    priv->oldStripY = ds->stripy;
>     priv->oldRot = rot;
>     priv->oldThrottle = throttle;
> }
>@@ -3361,10 +3609,14 @@
>     if (ds1->proximity != ds2->proximity) return 0;
>     if (ABS(ds1->x - ds2->x) > suppress) return 0;
>     if (ABS(ds1->y - ds2->y) > suppress) return 0;
>+    if (ABS(ds1->tiltx - ds2->tiltx) > suppress) return 0;
>+    if (ABS(ds1->tilty - ds2->tilty) > suppress) return 0;
>+    if (ABS(ds1->stripx - ds2->stripx) > suppress) return 0;
>+    if (ABS(ds1->stripy - ds2->stripy) > suppress) return 0;
>     if (ABS(ds1->pressure - ds2->pressure) > suppress) return 0;
>     if (ABS(ds1->throttle - ds2->throttle) > suppress) return 0;
>-    if ((1800 + ds1->rotation - ds2->rotation) % 1800 > suppress &&
>-    	(1800 + ds2->rotation - ds1->rotation) % 1800 > suppress) return 0;
>+    if (ABS(ds1->rotation - ds2->rotation) > suppress ||
>+    	(1800 - ABS(ds2->rotation - ds1->rotation)) > suppress) return 0;
>     if (ABS(ds1->abswheel - ds2->abswheel) > suppress ||
> 		(ds2->relwheel) != 0) return 0;
>     return 1;
>@@ -3637,7 +3889,7 @@
> }
> 
> static void commonDispatchDevice(WacomCommonPtr common,
>-        const WacomChannelPtr pChannel)
>+	int channel, const WacomChannelPtr pChannel)
> {
>     int id, idx;
>     WacomDevicePtr priv;
>@@ -3648,6 +3900,20 @@
> 
>     DBG(10, ErrorF("commonDispatchEvents\n"));
> 
>+    if (!ds->device_type) {
>+	/* defaults to cursor if tool is on the tablet when X starts */
>+	ds->device_type = CURSOR_ID;
>+	ds->proximity = 1;
>+	if (ds->serial_num)
>+	    for (idx=0; idx<common->wcmNumDevices; idx++) {
>+		priv = common->wcmDevices[idx]->private;
>+		if (ds->serial_num == priv->serial) {
>+		    ds->device_type = DEVICE_ID(priv->flags);
>+		    break;
>+		}
>+	    }
>+    }
>+
>     /* Find the device the current events are meant for */
>     for (idx=0; idx<common->wcmNumDevices; idx++)
>     {
>@@ -3666,8 +3932,7 @@
> 		break;
> 	    }
> 	    /* Fallback to allow the cursor to move smoothly along screen edges */
>-	    else if (priv->oldProximity)
>-	    {
>+	    else if (priv->oldProximity) {
> 		pDev = common->wcmDevices[idx];
> 	    }
> 	}
>@@ -3680,7 +3945,7 @@
>     if (pLastDev && (pLastDev != pDev) && (pLast->serial_num == ds->serial_num))
>     {
> 	pLast->proximity = 0;
>-	xf86WcmSendEvents(pLastDev, pLast);
>+	xf86WcmSendEvents(pLastDev, pLast, channel);
>     }
> 
>     /* if a device matched criteria, handle filtering per device
>@@ -3692,8 +3957,16 @@
> 
> 	/* Device transformations come first */
> 
>-	/* transform pressure */
>-	transPressureCurve(priv,&filtered);
>+	/* button 1 Threshold test */
>+	int button = 1;
>+	if ( !IsCursor(priv) ) {
>+	    if (filtered.pressure < common->wcmThreshold )
>+		filtered.buttons &= ~button;
>+	    else
>+		filtered.buttons |= button;
>+	    /* transform pressure */
>+	    transPressureCurve(priv,&filtered);
>+	}
> 
>  	/* User-requested filtering comes next */
> 
>@@ -3709,7 +3982,7 @@
> 	int sampleTime, ticks;
> 
> 	/* get the sample time */
>-	sampleTime = GetTimeInMillis();
>+	sampleTime = (int)GetTimeInMillis();
> 
> 	ticks = ThrottleToRate(ds->throttle);
> 
>@@ -3746,13 +4019,13 @@
> 	 * This only applies to USB protocol V tablets
> 	 * which aimed at improving relative movement support.
> 	 */
>- 	if (ds->distance > 112 && !(priv->flags & ABSOLUTE_FLAG))
>+ 	if (filtered.distance > 112 && !(priv->flags & ABSOLUTE_FLAG) && !channel)
> 	{
> 	    ds->proximity = 0;
> 	    filtered.proximity = 0;
> 	}
> 
>-	xf86WcmSendEvents(pDev, &filtered);
>+	xf86WcmSendEvents(pDev, &filtered, channel);
>     }
> 
>     /* otherwise, if no device matched... */
>@@ -3778,6 +4051,13 @@
>     WacomDeviceState ds;
>     WacomChannelPtr pChannel;
> 
>+   /* tool on the tablet when driver starts */
>+    if (!miPointerCurrentScreen()) {
>+	DBG(6, ErrorF("xf86WcmEvent: Wacom driver can not get Current Screen ID\n"));
>+	DBG(6, ErrorF("Please remove Wacom tool from the tablet.\n"));
>+	return;
>+    }
>+
>     /* sanity check the channel */
>     if (channel >= MAX_CHANNELS)
>  	return;
>@@ -3790,7 +4070,7 @@
>     ds = *pState;
> 
>     /* timestamp the state for velocity and acceleration analysis */
>-    ds.sample = GetTimeInMillis();
>+    ds.sample = (int)GetTimeInMillis();
> 
>     DBG(10, ErrorF("xf86WcmEvent: c=%d i=%d t=%d s=0x%X x=%d y=%d b=0x%X "
>                 "p=%d rz=%d tx=%d ty=%d aw=%d rw=%d t=%d df=%d px=%d st=%d\n",
>@@ -3803,6 +4083,15 @@
>                 ds.tilty, ds.abswheel, ds.relwheel, ds.throttle,
>                 ds.discard_first, ds.proximity, ds.sample));
> 
>+    /* Discard the first 2 USB packages due to events delay */
>+    if ( (pChannel->nSamples < 2) && (common->wcmDevCls == &gWacomUSBDevice) ) {
>+	/* store channel device state for later use */
>+	memmove(pChannel->valid.states + 1, pChannel->valid.states,
>+		sizeof(WacomDeviceState) * (MAX_SAMPLES - 1));
>+	++pChannel->nSamples;
>+	return; /* discard */
>+    }
>+
>     /* Filter raw data, fix hardware defects, perform error correction */
>     if (RAW_FILTERING(common) && common->wcmModel->FilterRaw)
>     {
>@@ -3815,7 +4104,7 @@
>     }
> 
>     /* Discard unwanted data */
>-    if (xf86WcmSuppress(common->wcmSuppress, pLast, &ds))
>+    if (xf86WcmSuppress(common->wcmSuppress, pLast, &ds) && pChannel->rawFilter.npoints == 4)
>     {
> 	DBG(10, ErrorF("Suppressing data according to filter\n"));
> 
>@@ -3845,9 +4134,9 @@
>     memmove(pChannel->valid.states + 1, pChannel->valid.states,
>                 sizeof(WacomDeviceState) * (MAX_SAMPLES - 1));
>     pChannel->valid.state = ds; /*save last raw sample */
>-    if (pChannel->nSamples < 4) ++pChannel->nSamples;
>+    if (pChannel->rawFilter.npoints < 4) ++pChannel->nSamples;
> 
>-    commonDispatchDevice(common,pChannel);
>+    commonDispatchDevice(common,channel,pChannel);
> 
>     resetSampleCounter(pChannel);
> }
>@@ -3938,8 +4227,9 @@
>     WacomDevicePtr	priv = (WacomDevicePtr)PRIVATE(pWcm);
>     WacomCommonPtr	common = priv->common;
>     double		screenRatio, tabletRatio;
>-    int 		totalWidth = 0, maxHeight = 0;
>-    
>+    int 		totalWidth = 0, maxHeight = 0, tabletSize = 0;
>+    char		m1[32], m2[32];			
>+   
>     if (local->fd < 0) {
> 	if (!xf86WcmInitDevice(local) || (local->fd < 0))
> 	{
>@@ -3950,23 +4240,10 @@
> 
>     if (priv->factorX == 0.0) {
> 	
>-	if (priv->twinview != TV_NONE && priv->bottomX == 0 && 
>-		priv->bottomY == 0 && priv->topX == 0 && priv->topY == 0)
>+	if (priv->twinview != TV_NONE && priv->screen_no == -1)
> 	{
>-	    if (IsCursor(priv))
>-	    {
>-		/* for absolute cursor */
>-		priv->topX = 80;
>-		priv->topY = 80;
>-	    }
>-	    else
>-	    {
>-		/* for absolute stylus and eraser */
>-		priv->topX = 50;
>-		priv->topY = 50;
>-	    }
>-	    priv->bottomX = common->wcmMaxX - priv->topX;
>-	    priv->bottomY = common->wcmMaxY - priv->topY;
>+	    priv->tvoffsetX = 60;
>+	    priv->tvoffsetY = 60;
> 	}
> 	if (priv->bottomX == 0) priv->bottomX = common->wcmMaxX;
> 
>@@ -4067,36 +4344,52 @@
>     }
> 
> 	/* x and y axes */
>-    InitValuatorAxisStruct(pWcm, 0, 0,
>-			((priv->bottomX - priv->topX) * priv->dscaleX), /* max val */
>+    if (priv->twinview == TV_LEFT_RIGHT)
>+	tabletSize = 2*(priv->bottomX - priv->topX - 2*priv->tvoffsetX);
>+    else
>+	tabletSize = priv->bottomX - priv->topX;
>+
>+    InitValuatorAxisStruct(pWcm, 0, 0, tabletSize, /* max val */
> 			mils(common->wcmResolX), /* tablet resolution */
> 			0, mils(common->wcmResolX)); /* max_res */
> 
>-    InitValuatorAxisStruct(pWcm, 1, 0,
>-			((priv->bottomY - priv->topY) * priv->dscaleY), /* max val */
>+    if (priv->twinview == TV_ABOVE_BELOW)
>+	tabletSize = 2*(priv->bottomY - priv->topY - 2*priv->tvoffsetY);
>+    else
>+	tabletSize = priv->bottomY - priv->topY;
>+
>+    InitValuatorAxisStruct(pWcm, 1, 0, tabletSize, /* max val */
> 			mils(common->wcmResolY), /* tablet resolution */
> 			0, mils(common->wcmResolY)); /* max_res */
> 
> 	/* pressure */
>     InitValuatorAxisStruct(pWcm, 2, 0, common->wcmMaxZ, 1, 1, 1);
> 
>-    if (IsCursor(priv))
>-    {
>+    if (IsCursor(priv)) {
> 	/* z-rot and throttle */
>     	InitValuatorAxisStruct(pWcm, 3, -900, 899, 1, 1, 1);
>     	InitValuatorAxisStruct(pWcm, 4, -1023, 1023, 1, 1, 1);
>     }
>-    else
>-    {
>+    else if (IsPad(priv)) {
>+	/* strip-x and strip-y */
>+	InitValuatorAxisStruct(pWcm, 3, 0, 4097, 1, 1, 1);
>+	InitValuatorAxisStruct(pWcm, 4, 0, 4097, 1, 1, 1);
>+    }
>+    else {
> 	/* tilt-x and tilt-y */
>     	InitValuatorAxisStruct(pWcm, 3, -64, 63, 1, 1, 1);
>     	InitValuatorAxisStruct(pWcm, 4, -64, 63, 1, 1, 1);
>     }
> 
>-	/* wheel */
>-    InitValuatorAxisStruct(pWcm, 5, 0, 1023, 1, 1, 1);
>-    
>-    return (local->fd != -1);
>+    sscanf((char*)(common->wcmModel)->name, "%s %s", m1, m2);
>+    if (strstr(m2, "Intuos3") && IsStylus(priv))
>+	/* Intuos3 Marker Pen rotation */
>+	InitValuatorAxisStruct(pWcm, 5, -900, 899, 1, 1, 1);
>+    else
>+	/* absulate wheel */
>+	InitValuatorAxisStruct(pWcm, 5, 0, 1023, 1, 1, 1);
>+
>+    return TRUE;
> }
> 
> /*
>@@ -4260,40 +4553,45 @@
> 	    priv->bottomY = xf86SetIntOption(local->options, "BottomY", 0);
> 	    break;
> 	case XWACOM_PARAM_BUTTON1:
>-	    if ((value < 0) || (value > 18)) return BadValue;
>+	    if ((value < 0) || (value > 19)) return BadValue;
> 	    xf86ReplaceIntOption(local->options,"Button1",value);
> 	    priv->button[0] = xf86SetIntOption(local->options,"Button1",1);
> 	    break;
> 	case XWACOM_PARAM_BUTTON2:
>-	    if ((value < 0) || (value > 18)) return BadValue;
>+	    if ((value < 0) || (value > 19)) return BadValue;
> 	    xf86ReplaceIntOption(local->options, "Button2", value);
> 	    priv->button[1] = xf86SetIntOption(local->options,"Button2",2);
> 	    break;
> 	case XWACOM_PARAM_BUTTON3:
>-	    if ((value < 0) || (value > 18)) return BadValue;
>+	    if ((value < 0) || (value > 19)) return BadValue;
> 	    xf86ReplaceIntOption(local->options, "Button3", value);
> 	    priv->button[2] = xf86SetIntOption(local->options,"Button3",3);
> 	    break;
> 	case XWACOM_PARAM_BUTTON4:
>-	    if ((value < 0) || (value > 18)) return BadValue;
>+	    if ((value < 0) || (value > 19)) return BadValue;
> 	    xf86ReplaceIntOption(local->options, "Button4", value);
> 	    priv->button[3] = xf86SetIntOption(local->options,"Button4",4);
> 	    break;
> 	case XWACOM_PARAM_BUTTON5:
>-	    if ((value < 0) || (value > 18)) return BadValue;
>+	    if ((value < 0) || (value > 19)) return BadValue;
> 	    xf86ReplaceIntOption(local->options, "Button5", value);
> 	    priv->button[4] = xf86SetIntOption(local->options,"Button5",5);
> 	    break;
> 	case XWACOM_PARAM_DEBUGLEVEL:
>-	    if ((value < 0) || (value > 100)) return BadValue;
>+	    if ((value < 1) || (value > 100)) return BadValue;
> 	    xf86ReplaceIntOption(local->options, "DebugLevel", value);
> 	    gWacomModule.debugLevel = value;
> 	    break;
> 	case XWACOM_PARAM_RAWFILTER:
> 	    if ((value < 0) || (value > 1)) return BadValue;
>-	    xf86ReplaceIntOption(local->options, "RawFilter", value);
>-	    if (value) priv->common->wcmFlags |= RAW_FILTERING_FLAG;
>-	    else priv->common->wcmFlags &= ~(RAW_FILTERING_FLAG);
>+	    if (value) {
>+		priv->common->wcmFlags |= RAW_FILTERING_FLAG;
>+		xf86ReplaceStrOption(local->options, "RawFilter", "On");
>+	    }
>+	    else {
>+		priv->common->wcmFlags &= ~(RAW_FILTERING_FLAG);
>+		xf86ReplaceStrOption(local->options, "RawFilter", "Off");
>+	    }
> 	    break;
> 	case XWACOM_PARAM_PRESSCURVE: {
> 	    char chBuf[64];
>@@ -4303,7 +4601,7 @@
> 	    int y1 = value & 0xFF;
> 	    if ((x0 > 100) || (y0 > 100) || (x1 > 100) || (y1 > 100))
> 		return BadValue;
>-	    snprintf(chBuf,sizeof(chBuf),"%d %d %d %d",x0,y0,x1,y1);
>+	    snprintf(chBuf,sizeof(chBuf),"%d,%d,%d,%d",x0,y0,x1,y1);
> 	    xf86ReplaceStrOption(local->options, "PressCurve",chBuf);
> 	    xf86WcmSetPressureCurve(priv,x0,y0,x1,y1);
> 	    break;
>@@ -4319,19 +4617,19 @@
> 	    }
> 	    break;
> 	case XWACOM_PARAM_SPEEDLEVEL:
>-	    if ((value < 0) || (value > 10)) return BadValue;
>-	    if (value > 5) priv->speed = 2.00*((double)value - 5.00);
>-	    else priv->speed = ((double)value + 1.00) / 6.00;
>+	    if ((value < 1) || (value > 11)) return BadValue;
>+	    if (value > 6) priv->speed = 2.00*((double)value - 6.00);
>+	    else priv->speed = ((double)value) / 6.00;
> 	    sprintf(st, "%.3f", priv->speed);
> 	    xf86AddNewOption(local->options, "Speed", st);
> 	    break;
> 	case XWACOM_PARAM_ACCEL:
>-	    if ((value < 0) || (value > MAX_ACCEL-1)) return BadValue;
>-	    priv->accel = value;
>+	    if ((value < 1) || (value > MAX_ACCEL)) return BadValue;
>+	    priv->accel = value-1;
> 	    xf86ReplaceIntOption(local->options, "Accel", priv->accel);
> 	    break;
> 	case XWACOM_PARAM_CLICKFORCE:
>-	    if ((value < 0) || (value > 20)) return BadValue;
>+	    if ((value < 1) || (value > 21)) return BadValue;
> 		 priv->common->wcmThreshold = 
> 			(int)((double)(value*priv->common->wcmMaxZ)/100.00+0.5);
> 	    xf86ReplaceIntOption(local->options, "Threshold",
>@@ -4353,7 +4651,21 @@
> 	    break;
> 	case XWACOM_PARAM_GIMP:
> 	    if ((value != 0) && (value != 1)) return BadValue;
>-		priv->common->wcmGimp = value;
>+	    priv->common->wcmMMonitor = value;
>+	    break;
>+	case XWACOM_PARAM_MMT:
>+	    if ((value != 0) && (value != 1)) return BadValue;
>+	    priv->common->wcmMMonitor = value;
>+	    break;
>+	case XWACOM_PARAM_TPCBUTTON:
>+	    if ((value != 0) && (value != 1)) return BadValue;
>+	    priv->common->wcmTPCButton = value;
>+	    if (value) {
>+		xf86ReplaceStrOption(local->options, "TPCButton", "on");
>+	    }
>+	    else {
>+		xf86ReplaceStrOption(local->options, "TPCButton", "off");
>+	    }
> 	    break;
> 	default:
> 	    DBG(10, ErrorF("xf86WcmSetParam invalid param %d\n",param));
>@@ -4372,7 +4684,7 @@
>     char            fileName[80] = "/etc/X11/wcm.";
>     char            command[256];
>     FILE            *fp = 0;
>-    int             value;
>+    int             value,p1,p2,p3,p4;
>     double          speed;
>     char	    *s;
> 
>@@ -4417,8 +4729,12 @@
> 	    fprintf(fp, "xsetwacom set %s Button5 %s\n", local->name, s);
> 
> 	s = xf86FindOptionValue(local->options, "PressCurve");
>-	if ( s && !IsCursor(priv) )
>-	    fprintf(fp, "xsetwacom set %s PressCurve %s\n", local->name, s);
>+	if ( s && !IsCursor(priv) ) {
>+	    sscanf(s, "%d,%d,%d,%d", &p1, &p2, &p3, &p4);
>+	    if ( p1 || p2 || p3 != 100 || p4 != 100 )
>+		fprintf(fp, "xsetwacom set %s PressCurve %d %d %d %d\n", 
>+			local->name, p1, p2, p3, p4);
>+	}
> 
> 	s = xf86FindOptionValue(local->options, "Mode");
> 	if ( s && (((priv->flags & ABSOLUTE_FLAG) && IsCursor(priv))
>@@ -4431,21 +4747,18 @@
> 
> 	s = xf86FindOptionValue(local->options, "Accel");
> 	if ( s && priv->accel )
>-	    fprintf(fp, "xsetwacom set %s Accel %s\n", local->name, s);
>-
>-	s = xf86FindOptionValue(local->options, "Suppress");
>-	if ( s )
>-	    fprintf(fp, "xsetwacom set %s Suppress %s\n", local->name, s);
>+	    fprintf(fp, "xsetwacom set %s Accel %d\n", local->name, priv->accel+1);
> 
> 	s = xf86FindOptionValue(local->options, "Speed");
> 	if ( s && priv->speed != DEFAULT_SPEED )
> 	{
> 	     speed = strtod(s, NULL);
>-	     if(speed > 10.00) value = 10;
>-	     else if(speed >= 1.00) value = (int)(speed/2.00 + 5.00);
>-	     else if(speed < (double)(1.00/6.00)) value = 0;
>-	     else value = (int)(speed*6.00 - 0.50);
>-	     fprintf(fp, "xsetwacom set %s SpeedLevel %d\n", local->name, value);
>+	     if(speed >= 10.00) value = 11;
>+	     else if(speed >= 1.00) value = (int)(speed/2.00 + 6.00);
>+	     else if(speed < (double)(1.00/6.00)) value = 1;
>+	     else value = (int)(speed*6.00 + 0.50);
>+	     if ( value != 6 )
>+		fprintf(fp, "xsetwacom set %s SpeedLevel %d\n", local->name, value);
> 	}
> 
> 	s = xf86FindOptionValue(local->options, "Threshold");
>@@ -4453,19 +4766,32 @@
> 	{
> 	    value = atoi(s);
> 	    value = (int)((double)value*100.00/(double)priv->common->wcmMaxZ+0.5);
>-	    fprintf(fp, "xsetwacom set %s ClickForce %d\n", local->name, value);
>+	    if ( value != 6 )
>+		fprintf(fp, "xsetwacom set %s ClickForce %d\n", local->name, value);
>+	}
>+
>+	s = xf86FindOptionValue(local->options, "ForceDevice");
>+	if ( s ) {
>+	    if ( !priv->common->wcmTPCButton )
>+		fprintf(fp, "xsetwacom set %s TPCButton off\n", local->name);
>+	    fprintf(fp, "default TPCButton on\n");
>+	}
>+	else {
>+	    if ( priv->common->wcmTPCButton )
>+		fprintf(fp, "xsetwacom set %s TPCButton on\n", local->name);
>+	    fprintf(fp, "default TPCButton off\n");
> 	}
> 
> 	fprintf(fp, "%s", "default TopX 0\n");
> 	fprintf(fp, "%s", "default TopY 0\n");
> 	fprintf(fp, "default BottomX %d\n", priv->common->wcmMaxX);
>  	fprintf(fp, "default BottomY %d\n", priv->common->wcmMaxY);
>-	if (IsCursor(priv))
>+	if (IsCursor(priv) || IsPad(priv))
> 	    sprintf(command, "default Mode Relative\n");
>  	else
> 	    sprintf(command, "default Mode Absolute\n");
> 	fprintf(fp, "%s", command);
>-	fprintf(fp, "%s", "default SpeedLevel 5\n");
>+	fprintf(fp, "%s", "default SpeedLevel 6\n");
> 	fprintf(fp, "%s", "default ClickForce 6\n");
> 	fprintf(fp, "%s", "default Accel 0\n");
> 	fclose(fp);
>@@ -4494,9 +4820,10 @@
> 		lprv = (WacomDevicePtr)localDevices->private;
>             else
>                 lprv = NULL;
>-	    if (lprv && lprv->common) {
>+	    if (lprv && lprv->common && lprv->common->wcmModel) {
> 		sscanf((char*)(lprv->common->wcmModel)->name, "%s %s", m1, m2);
>-		fprintf(fp, "%s %s %s\n", localDevices->name, m2, m3);
>+		if ( lprv->common->wcmEraserID )
>+		fprintf(fp, "%s %s %s %s\n", localDevices->name, m2, m3, lprv->common->wcmEraserID);
> 	    	if (lprv->twinview != TV_NONE) {
> 		    priv = lprv;
>  	    	}
>@@ -4680,11 +5007,9 @@
> 	priv->button[i] = i+1;		/* button i value */
>     priv->numScreen = screenInfo.numScreens; /* number of configureed screens */
>     priv->currentScreen = 0;		/* current screen in display */
>-    priv->dscaleX = 1.0;		/* dual screen scale X factor */
>-    priv->dscaleY = 1.0;		/* dual screen scale Y factor */
>-    priv->doffsetX = 0;			/* dual screen offset X */
>-    priv->doffsetY = 0;			/* dual screen offset Y */
>     priv->twinview = TV_NONE;		/* not using twinview gfx */
>+    priv->tvoffsetX = 0;		/* none X edge offset for TwinView setup */
>+    priv->tvoffsetY = 0;		/* none Y edge offset for TwinView setup */
>     for (i=0; i<4; i++)
> 	priv->tvResolution[i] = 0;      /* unconfigured twinview resolution */
>     priv->throttleValue = 0;
>@@ -4710,7 +5035,12 @@
>     common->wcmLinkSpeed = 9600;        /* serial link speed */
>     common->wcmDevCls = &gWacomSerialDevice; /* device-specific functions */
>     common->wcmModel = NULL;		/* model-specific functions */
>-    common->wcmGimp = 1;		/* enabled (=1) to support Gimp when Xinerama Enabled in multi-monitor desktop. Needs to be disabled (=0) for Cintiq calibration */
>+    common->wcmEraserID = 0;		/* eraser id associated with the stylus */
>+    common->wcmGimp = 1;		/* enabled (=1) to support Gimp when Xinerama Enabled in multi-monitor desktop. Needs to be disabled (=0) for Cintiq and ISDV4 calibration */
>+    common->wcmMMonitor = 1;		/* enabled (=1) to support multi-monitor desktop. */
>+					/* disabled (=0) when user doesn't want to move the */
>+					/* cursor from one screen to another screen */
>+    common->wcmTPCButton = 0;       	/* set Tablet PC button on/off, default is off */
>     return local;
> }
> 
>@@ -4724,7 +5054,7 @@
> static LocalDevicePtr
> xf86WcmAllocateStylus()
> {
>-    LocalDevicePtr        local = xf86WcmAllocate(XI_STYLUS, STYLUS_ID);
>+    LocalDevicePtr        local = xf86WcmAllocate(XI_STYLUS, ABSOLUTE_FLAG|STYLUS_ID);
> 
>     if (local)
> 	local->type_name = "Wacom Stylus";
>@@ -4765,6 +5095,17 @@
>     return local;
> }
> 
>+/* xf86WcmAllocatePad */
>+
>+LocalDevicePtr xf86WcmAllocatePad(void)
>+{
>+    LocalDevicePtr local = xf86WcmAllocate(XI_PAD, PAD_ID);
>+
>+    if (local) local->type_name = "Wacom Pad";
>+
>+    return local;
>+}
>+
> /*
>  * xf86WcmUninit --
>  *
>@@ -4798,11 +5139,20 @@
>     WacomDevicePtr privMatch = (WacomDevicePtr)pMatch->private;
>     WacomDevicePtr priv = (WacomDevicePtr)pLocal->private;
>     WacomCommonPtr common = priv->common;
>+    char 	   *type;
> 
>     if ((pLocal != pMatch) && (pMatch->device_control == gWacomModule.DevProc) &&
>                 !strcmp(privMatch->common->wcmDevice, common->wcmDevice)) {
> 	DBG(2, ErrorF("xf86WcmInit wacom port share between"
>                                 " %s and %s\n", pLocal->name, pMatch->name));
>+	type = xf86FindOptionValue(pMatch->options, "Type");
>+	if ( type && (strstr(type, "eraser")) )
>+	    privMatch->common->wcmEraserID=pMatch->name;
>+	else {
>+	    type = xf86FindOptionValue(pLocal->options, "Type");
>+	    if ( type && (strstr(type, "eraser")) ) 
>+		privMatch->common->wcmEraserID=pLocal->name;
>+	}
> 	xfree(common->wcmDevices);
> 	xfree(common);
> 	common = priv->common = privMatch->common;
>@@ -4859,7 +5209,9 @@
>     else if (s && (xf86NameCmp(s, "eraser") == 0)) {
> 	local = xf86WcmAllocateEraser();
>     }
>-    else {
>+    else if (s && (xf86NameCmp(s, "pad") == 0))
>+	local = xf86WcmAllocatePad();
>+   else {
> 	xf86Msg(X_ERROR, "%s: No type or invalid type specified.\n"
> 		"Must be one of stylus, cursor or eraser\n",
> 		dev->identifier);
>@@ -4934,6 +5286,9 @@
> 	else
> 	    priv->flags |= ABSOLUTE_FLAG;
>     }
>+    /* pad always in relative mode since it doesn't move the cursor */
>+    if (IsPad(priv)) priv->flags &= ~ABSOLUTE_FLAG;
>+
>     xf86Msg(X_CONFIG, "%s is in %s mode\n", local->name,
> 	    (priv->flags & ABSOLUTE_FLAG) ? "absolute" : "relative");
> 
>@@ -5102,6 +5457,13 @@
> 	xf86Msg(X_CONFIG, "%s: buttons only\n", dev->identifier);
>     }
> 
>+    /* Tablet PC button applied to the whole tablet. Not just one tool */
>+    if ( !common->wcmTPCButton ) {
>+	common->wcmTPCButton = xf86SetBoolOption(local->options, "TPCButton", 0);
>+	if ( common->wcmTPCButton )
>+	    xf86Msg(X_CONFIG, "%s: Tablet PC buttons on \n", common->wcmDevice);
>+    }
>+
>     for (i=0; i<16; i++)
>     {
> 	sprintf(b, "Button%d", i+1);
>@@ -5149,16 +5511,8 @@
>     if (s) xf86Msg(X_CONFIG, "%s: Twinview = %s\n", dev->identifier, s);
>     if (s && xf86NameCmp(s, "none") == 0) {
> 	priv->twinview = TV_NONE;
>-	priv->dscaleX = 1.0;
>-	priv->dscaleY = 1.0;
>-	priv->doffsetX = 0;
>-	priv->doffsetY = 0;
>     } else if (s && xf86NameCmp(s, "horizontal") == 0) {
> 	priv->twinview = TV_LEFT_RIGHT;
>-	priv->dscaleX = 2.0;
>-	priv->dscaleY = 1.0;
>-	priv->doffsetX = 0;
>-	priv->doffsetY = 0;
> 	/* default resolution */
> 	if(!priv->tvResolution[0]) {
> 	    priv->tvResolution[0] = screenInfo.screens[0]->width/2;
>@@ -5168,10 +5522,6 @@
> 	}
>     } else if (s && xf86NameCmp(s, "vertical") == 0) {
> 	priv->twinview = TV_ABOVE_BELOW;
>-	priv->dscaleX = 1.0;
>-	priv->dscaleY = 2.0;
>-	priv->doffsetX = 0;
>-	priv->doffsetY = 0;
> 	/* default resolution */
> 	if(!priv->tvResolution[0]) {
> 	    priv->tvResolution[0] = screenInfo.screens[0]->width;
>@@ -5183,10 +5533,6 @@
> 	xf86Msg(X_ERROR, "%s: invalid Twinview (should be none, vertical or horizontal). Using none.\n",
>                         dev->identifier);
> 	priv->twinview = TV_NONE;
>-	priv->dscaleX = 1.0;
>-	priv->dscaleY = 1.0;
>-	priv->doffsetX = 0;
>-	priv->doffsetY = 0;
>     }
> 
>     /* mark the device configured */

Actions: View | Splinter Review

Attachments on bug 1917: 1366 | 1367 | 1422

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.