Attachment #80559 for bug #123858

Lines 432-437 Link Here

(-)linuxwacom-0.7.2-orig/src/wcmCommon.c (+5 lines)
432	y = x;	432	y = x;
433	x = common->wcmMaxX - tmp_coord;	433	x = common->wcmMaxX - tmp_coord;
434	}	434	}
		435	else if (common->wcmRotate == ROTATE_HALF)
		436	{
		437	x = common->wcmMaxX - x;
		438	y = common->wcmMaxY - y;
		439	}
435		440
436	is_absolute = (priv->flags & ABSOLUTE_FLAG);	441	is_absolute = (priv->flags & ABSOLUTE_FLAG);
437	is_core_pointer = xf86IsCorePointer(local->dev);	442	is_core_pointer = xf86IsCorePointer(local->dev);




	LocalDevicePtr local = (LocalDevicePtr)pWcm->public.devicePrivate;
	WacomDevicePtr priv = (WacomDevicePtr)PRIVATE(pWcm);
	WacomCommonPtr common = priv->common;
	int totalWidth = 0, maxHeight = 0;
	double screenRatio, tabletRatio;
	char m1[32], m2[32];			
 

	} /* end bounding rect */

	/* x and y axes */
        InitValuatorAxisStruct(pWcm, 0, priv->topX, priv->bottomX, /* max val */
                common->wcmResolX, /* tablet resolution */
                0, common->wcmResolX); /* max_res */

        InitValuatorAxisStruct(pWcm, 1, priv->topY, priv->bottomY, /* max val */
                common->wcmResolY, /* tablet resolution */
                0, common->wcmResolY); /* max_res */
		0, common->wcmResolX); /* max_res */

	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 */
		common->wcmResolY, /* tablet resolution */
		0, common->wcmResolY); /* max_res */

	/* pressure */
	InitValuatorAxisStruct(pWcm, 2, 0,

static int xf86WcmSetParam(LocalDevicePtr local, int param, int value)
{
	WacomDevicePtr priv = (WacomDevicePtr)local->private;
	WacomDevicePtr tmppriv;
	char st[32];
	int oldRotation, dev;
	int tmpTopX, tmpTopY, tmpBottomX, tmpBottomY, oldMaxX, oldMaxY;

	switch (param) 
	{
	    case XWACOM_PARAM_TOPX:
		xf86ReplaceIntOption(local->options, "TopX", value);
		priv->topX = xf86SetIntOption(local->options, "TopX", 0);
                InitValuatorAxisStruct(local->dev, 0, priv->topX, priv->bottomX,
                    priv->common->wcmResolX, /* tablet resolution */
                    0, priv->common->wcmResolX); /* max_res */
		break;
	    case XWACOM_PARAM_TOPY:
		xf86ReplaceIntOption(local->options, "TopY", value);
		priv->topY = xf86SetIntOption(local->options, "TopY", 0);
                InitValuatorAxisStruct(local->dev, 1, priv->topY, priv->bottomY, /* max val */
                    priv->common->wcmResolY, /* tablet resolution */
                    0, priv->common->wcmResolY); /* max_res */
		break;
	    case XWACOM_PARAM_BOTTOMX:
		xf86ReplaceIntOption(local->options, "BottomX", value);
		priv->bottomX = xf86SetIntOption(local->options, "BottomX", 0);
                InitValuatorAxisStruct(local->dev, 0, priv->topX, priv->bottomX,
                    priv->common->wcmResolX, /* tablet resolution */
                    0, priv->common->wcmResolX); /* max_res */
		break;
	    case XWACOM_PARAM_BOTTOMY:
		xf86ReplaceIntOption(local->options, "BottomY", value);
		priv->bottomY = xf86SetIntOption(local->options, "BottomY", 0);
                InitValuatorAxisStruct(local->dev, 1, priv->topY, priv->bottomY, /* max val */
                    priv->common->wcmResolY, /* tablet resolution */
                    0, priv->common->wcmResolY); /* max_res */
		break;
	    case XWACOM_PARAM_BUTTON1:
		if ((value < 0) || (value > 19)) return BadValue;

				"BottomY", priv->common->wcmMaxY);
		priv->bottomY = xf86SetIntOption(local->options,
				"BottomY", priv->common->wcmMaxY);
                InitValuatorAxisStruct(local->dev, 0, priv->topX, priv->bottomX,
                    priv->common->wcmResolX, /* tablet resolution */
                    0, priv->common->wcmResolX); /* max_res */
                InitValuatorAxisStruct(local->dev, 1, priv->topY, priv->bottomY, /* max val */
                    priv->common->wcmResolY, /* tablet resolution */
                    0, priv->common->wcmResolY); /* max_res */
		break;
	    case XWACOM_PARAM_GIMP:
		if ((value != 0) && (value != 1)) return BadValue;

			xf86ReplaceStrOption(local->options, "Gimp", "off");
		}
		break;
	    case XWACOM_PARAM_ROTATE:
		if ((value < 0) || (value > 3)) return BadValue;
		switch(value) {
		  case ROTATE_NONE:
		    xf86ReplaceStrOption(local->options, "Rotate", "NONE");
		    break;
		  case ROTATE_CW:
		    xf86ReplaceStrOption(local->options, "Rotate", "CW");
		    break;
		  case ROTATE_CCW:
		    xf86ReplaceStrOption(local->options, "Rotate", "CCW");
		    break;
		  case ROTATE_HALF:
		    xf86ReplaceStrOption(local->options, "Rotate", "HALF");
		    break;
		  default:
		    return BadValue;
		}
		oldRotation = priv->common->wcmRotate;
		oldMaxX = priv->common->wcmMaxX;
		oldMaxY = priv->common->wcmMaxY;
		priv->common->wcmRotate = value;
		if (((oldRotation == ROTATE_NONE || oldRotation == ROTATE_HALF) && (value == ROTATE_CW || value == ROTATE_CCW)) ||
                    ((oldRotation == ROTATE_CW || oldRotation == ROTATE_CCW) && (value == ROTATE_NONE || value == ROTATE_HALF)))
                {
                   priv->common->wcmMaxX = oldMaxY;
                   priv->common->wcmMaxY = oldMaxX;
                }

                /* rotate all devices at once! else they get misaligned */
                for (dev=0; dev < priv->common->wcmNumDevices; dev++)
                {
                   tmppriv = (WacomDevicePtr)priv->common->wcmDevices[dev]->private;
                   /* recover the unrotated xy-rectangles */
                   switch (oldRotation) {
                     case ROTATE_CW:
                       tmpTopX = oldMaxY - tmppriv->bottomY;
                       tmpBottomX = oldMaxY - tmppriv->topY;
                       tmpTopY = tmppriv->topX;
                       tmpBottomY = tmppriv->bottomX;
                       break;
                     case ROTATE_CCW:
                       tmpTopX = tmppriv->topY;
                       tmpBottomX = tmppriv->bottomY;
                       tmpTopY = oldMaxX - tmppriv->bottomX;
                       tmpBottomY = oldMaxX - tmppriv->topX;
                       break;
                     case ROTATE_HALF:
                       tmpTopX = oldMaxX - tmppriv->bottomX;
                       tmpBottomX = oldMaxX - tmppriv->topX;
                       tmpTopY = oldMaxY - tmppriv->bottomY;
                       tmpBottomY = oldMaxY - tmppriv->topY;
                       break;
                     default: /* ROTATE_NONE */
                       tmpTopX = tmppriv->topX;
                       tmpBottomX = tmppriv->bottomX;
                       tmpTopY = tmppriv->topY;
                       tmpBottomY = tmppriv->bottomY;
                       break;
                   } 
                   /* and rotate them back */
                   switch (value) {
                     case ROTATE_CW:
                       tmppriv->topX = tmpTopY;
                       tmppriv->bottomX = tmpBottomY;
                       tmppriv->topY = priv->common->wcmMaxY - tmpBottomX;
                       tmppriv->bottomY = priv->common->wcmMaxY - tmpTopX;
                       break;
                     case ROTATE_CCW:
                       tmppriv->topX = priv->common->wcmMaxX - tmpBottomY;
                       tmppriv->bottomX = priv->common->wcmMaxX - tmpTopY;
                       tmppriv->topY = tmpTopX;
                       tmppriv->bottomY = tmpBottomX;
                       break;
                     case ROTATE_HALF:
                       tmppriv->topX = priv->common->wcmMaxX - tmpBottomX;
                       tmppriv->bottomX = priv->common->wcmMaxX - tmpTopX;
                       tmppriv->topY= priv->common->wcmMaxY - tmpBottomY;
                       tmppriv->bottomY = priv->common->wcmMaxY - tmpTopY;
                       break;
                     default: /* ROTATE_NONE */
                       tmppriv->topX = tmpTopX;
                       tmppriv->bottomX = tmpBottomX;
                       tmppriv->topY = tmpTopY;
                       tmppriv->bottomY = tmpBottomY;
                       break;
                   } 

                   InitValuatorAxisStruct(priv->common->wcmDevices[dev]->dev,
                       0, tmppriv->topX, tmppriv->bottomX, priv->common->wcmResolX, /* tablet resolution */
                       0, priv->common->wcmResolX); /* max_res */

                   InitValuatorAxisStruct(priv->common->wcmDevices[dev]->dev,
                       1, tmppriv->topY, tmppriv->bottomY, priv->common->wcmResolY, /* tablet resolution */
                       0, priv->common->wcmResolY); /* max_res */
                }
		break;
	    case XWACOM_PARAM_MMT:
		if ((value != 0) && (value != 1)) return BadValue;
		priv->common->wcmMMonitor = value;




#define ERASER_PROX     4
#define OTHER_PROX      1

#define ROTATE_NONE XWACOM_VALUE_ROTATE_NONE
#define ROTATE_CW XWACOM_VALUE_ROTATE_CW
#define ROTATE_CCW XWACOM_VALUE_ROTATE_CCW
#define ROTATE_HALF XWACOM_VALUE_ROTATE_HALF

/******************************************************************************
 * Forward Declarations
 *****************************************************************************/


#define DEVICE_ISDV4 0x000C

#define ROTATE_NONE 0
#define ROTATE_CW 1
#define ROTATE_CCW 2

#define MAX_CHANNELS 2
#define MAX_USB_EVENTS 32


Lines 186-191 Link Here

(-)linuxwacom-0.7.2-orig/src/xsetwacom.c (+24 lines)
186	XWACOM_PARAM_MMT, VALUE_OPTIONAL,	186	XWACOM_PARAM_MMT, VALUE_OPTIONAL,
187	RANGE, 0, 1, BOOLEAN_VALUE, 1 },	187	RANGE, 0, 1, BOOLEAN_VALUE, 1 },
188		188
		189	{ "Rotate",
		190	"Sets the rotation of the tablet. "
		191	"Values = NONE, CW, CCW, HALF (default is NONE).",
		192	XWACOM_PARAM_ROTATE, VALUE_OPTIONAL,
		193	RANGE, XWACOM_VALUE_ROTATE_NONE, XWACOM_VALUE_ROTATE_HALF, SINGLE_VALUE,
		194	XWACOM_VALUE_ROTATE_NONE },
		195
189	{ "TPCButton",	196	{ "TPCButton",
190	"Turns on/off Tablet PC buttons."	197	"Turns on/off Tablet PC buttons."
191	"default is off for regular tablets, "	198	"default is off for regular tablets, "
Lines 406-411 Link Here
406	!strcasecmp(pszValues[i],"false") \|\|	413	!strcasecmp(pszValues[i],"false") \|\|
407	!strcasecmp(pszValues[i],"relative")))	414	!strcasecmp(pszValues[i],"relative")))
408	nValues[i] = 0;	415	nValues[i] = 0;
		416	else if (p->nParamID == XWACOM_PARAM_ROTATE)
		417	{
		418	if (!strcasecmp(pszValues[i],"none"))
		419	nValues[i] = XWACOM_VALUE_ROTATE_NONE;
		420	else if (!strcasecmp(pszValues[i],"cw"))
		421	nValues[i] = XWACOM_VALUE_ROTATE_CW;
		422	else if (!strcasecmp(pszValues[i],"ccw"))
		423	nValues[i] = XWACOM_VALUE_ROTATE_CCW;
		424	else if (!strcasecmp(pszValues[i],"half"))
		425	nValues[i] = XWACOM_VALUE_ROTATE_HALF;
		426	else
		427	{
		428	fprintf(stderr,"Set: Value '%s' is "
		429	"invalid.\n",pszValues[i]);
		430	return 1;
		431	}
		432	}
409	else	433	else
410	{	434	{
411	fprintf(stderr,"Set: Value '%s' is "	435	fprintf(stderr,"Set: Value '%s' is "

Lines 44-48 Link Here

(-)linuxwacom-0.7.2-orig/src/Xwacom.h (+6 lines)
44	#define XWACOM_PARAM_GIMP 102	44	#define XWACOM_PARAM_GIMP 102
45	#define XWACOM_PARAM_MMT 103	45	#define XWACOM_PARAM_MMT 103
46	#define XWACOM_PARAM_TPCBUTTON 104	46	#define XWACOM_PARAM_TPCBUTTON 104
		47	#define XWACOM_PARAM_ROTATE 105
		48
		49	#define XWACOM_VALUE_ROTATE_NONE 0
		50	#define XWACOM_VALUE_ROTATE_CW 1
		51	#define XWACOM_VALUE_ROTATE_CCW 2
		52	#define XWACOM_VALUE_ROTATE_HALF 3
47		53
48	#endif /* __XF86_XWACOM_H */	54	#endif /* __XF86_XWACOM_H */

Return to bug 123858

Lines 203-209 Link Here

(-)linuxwacom-0.7.2-orig/src/xf86Wacom.c (-18 / +126 lines)
203	LocalDevicePtr local = (LocalDevicePtr)pWcm->public.devicePrivate;	203	LocalDevicePtr local = (LocalDevicePtr)pWcm->public.devicePrivate;
204	WacomDevicePtr priv = (WacomDevicePtr)PRIVATE(pWcm);	204	WacomDevicePtr priv = (WacomDevicePtr)PRIVATE(pWcm);
205	WacomCommonPtr common = priv->common;	205	WacomCommonPtr common = priv->common;
206	int totalWidth = 0, maxHeight = 0, tabletSize = 0;	206	int totalWidth = 0, maxHeight = 0;
207	double screenRatio, tabletRatio;	207	double screenRatio, tabletRatio;
208	char m1[32], m2[32];	208	char m1[32], m2[32];
209		209
Lines 339-361 Link Here
339	} /* end bounding rect */	339	} /* end bounding rect */
340		340
341	/* x and y axes */	341	/* x and y axes */
342	if (priv->twinview == TV_LEFT_RIGHT)	342	InitValuatorAxisStruct(pWcm, 0, priv->topX, priv->bottomX, /* max val */
343	tabletSize = 2(priv->bottomX - priv->topX - 2priv->tvoffsetX);	343	common->wcmResolX, /* tablet resolution */
344	else	344	0, common->wcmResolX); /* max_res */
345	tabletSize = priv->bottomX - priv->topX;	345
346		346	InitValuatorAxisStruct(pWcm, 1, priv->topY, priv->bottomY, /* max val */
347	InitValuatorAxisStruct(pWcm, 0, 0, tabletSize, /* max val */	347	common->wcmResolY, /* tablet resolution */
348	common->wcmResolX, /* tablet resolution */	348	0, common->wcmResolY); /* max_res */
349	0, common->wcmResolX); /* max_res */
350
351	if (priv->twinview == TV_ABOVE_BELOW)
352	tabletSize = 2(priv->bottomY - priv->topY - 2priv->tvoffsetY);
353	else
354	tabletSize = priv->bottomY - priv->topY;
355
356	InitValuatorAxisStruct(pWcm, 1, 0, tabletSize, /* max val */
357	common->wcmResolY, /* tablet resolution */
358	0, common->wcmResolY); /* max_res */
359		349
360	/* pressure */	350	/* pressure */
361	InitValuatorAxisStruct(pWcm, 2, 0,	351	InitValuatorAxisStruct(pWcm, 2, 0,
Lines 663-687 Link Here
663	static int xf86WcmSetParam(LocalDevicePtr local, int param, int value)	653	static int xf86WcmSetParam(LocalDevicePtr local, int param, int value)
664	{	654	{
665	WacomDevicePtr priv = (WacomDevicePtr)local->private;	655	WacomDevicePtr priv = (WacomDevicePtr)local->private;
		656	WacomDevicePtr tmppriv;
666	char st[32];	657	char st[32];
		658	int oldRotation, dev;
		659	int tmpTopX, tmpTopY, tmpBottomX, tmpBottomY, oldMaxX, oldMaxY;
667		660
668	switch (param)	661	switch (param)
669	{	662	{
670	case XWACOM_PARAM_TOPX:	663	case XWACOM_PARAM_TOPX:
671	xf86ReplaceIntOption(local->options, "TopX", value);	664	xf86ReplaceIntOption(local->options, "TopX", value);
672	priv->topX = xf86SetIntOption(local->options, "TopX", 0);	665	priv->topX = xf86SetIntOption(local->options, "TopX", 0);
		666	InitValuatorAxisStruct(local->dev, 0, priv->topX, priv->bottomX,
		667	priv->common->wcmResolX, /* tablet resolution */
		668	0, priv->common->wcmResolX); /* max_res */
673	break;	669	break;
674	case XWACOM_PARAM_TOPY:	670	case XWACOM_PARAM_TOPY:
675	xf86ReplaceIntOption(local->options, "TopY", value);	671	xf86ReplaceIntOption(local->options, "TopY", value);
676	priv->topY = xf86SetIntOption(local->options, "TopY", 0);	672	priv->topY = xf86SetIntOption(local->options, "TopY", 0);
		673	InitValuatorAxisStruct(local->dev, 1, priv->topY, priv->bottomY, /* max val */
		674	priv->common->wcmResolY, /* tablet resolution */
		675	0, priv->common->wcmResolY); /* max_res */
677	break;	676	break;
678	case XWACOM_PARAM_BOTTOMX:	677	case XWACOM_PARAM_BOTTOMX:
679	xf86ReplaceIntOption(local->options, "BottomX", value);	678	xf86ReplaceIntOption(local->options, "BottomX", value);
680	priv->bottomX = xf86SetIntOption(local->options, "BottomX", 0);	679	priv->bottomX = xf86SetIntOption(local->options, "BottomX", 0);
		680	InitValuatorAxisStruct(local->dev, 0, priv->topX, priv->bottomX,
		681	priv->common->wcmResolX, /* tablet resolution */
		682	0, priv->common->wcmResolX); /* max_res */
681	break;	683	break;
682	case XWACOM_PARAM_BOTTOMY:	684	case XWACOM_PARAM_BOTTOMY:
683	xf86ReplaceIntOption(local->options, "BottomY", value);	685	xf86ReplaceIntOption(local->options, "BottomY", value);
684	priv->bottomY = xf86SetIntOption(local->options, "BottomY", 0);	686	priv->bottomY = xf86SetIntOption(local->options, "BottomY", 0);
		687	InitValuatorAxisStruct(local->dev, 1, priv->topY, priv->bottomY, /* max val */
		688	priv->common->wcmResolY, /* tablet resolution */
		689	0, priv->common->wcmResolY); /* max_res */
685	break;	690	break;
686	case XWACOM_PARAM_BUTTON1:	691	case XWACOM_PARAM_BUTTON1:
687	if ((value < 0) \|\| (value > 19)) return BadValue;	692	if ((value < 0) \|\| (value > 19)) return BadValue;
Lines 788-793 Link Here
788	"BottomY", priv->common->wcmMaxY);	793	"BottomY", priv->common->wcmMaxY);
789	priv->bottomY = xf86SetIntOption(local->options,	794	priv->bottomY = xf86SetIntOption(local->options,
790	"BottomY", priv->common->wcmMaxY);	795	"BottomY", priv->common->wcmMaxY);
		796	InitValuatorAxisStruct(local->dev, 0, priv->topX, priv->bottomX,
		797	priv->common->wcmResolX, /* tablet resolution */
		798	0, priv->common->wcmResolX); /* max_res */
		799	InitValuatorAxisStruct(local->dev, 1, priv->topY, priv->bottomY, /* max val */
		800	priv->common->wcmResolY, /* tablet resolution */
		801	0, priv->common->wcmResolY); /* max_res */
791	break;	802	break;
792	case XWACOM_PARAM_GIMP:	803	case XWACOM_PARAM_GIMP:
793	if ((value != 0) && (value != 1)) return BadValue;	804	if ((value != 0) && (value != 1)) return BadValue;
Lines 801-806 Link Here
801	xf86ReplaceStrOption(local->options, "Gimp", "off");	812	xf86ReplaceStrOption(local->options, "Gimp", "off");
802	}	813	}
803	break;	814	break;
		815	case XWACOM_PARAM_ROTATE:
		816	if ((value < 0) \|\| (value > 3)) return BadValue;
		817	switch(value) {
		818	case ROTATE_NONE:
		819	xf86ReplaceStrOption(local->options, "Rotate", "NONE");
		820	break;
		821	case ROTATE_CW:
		822	xf86ReplaceStrOption(local->options, "Rotate", "CW");
		823	break;
		824	case ROTATE_CCW:
		825	xf86ReplaceStrOption(local->options, "Rotate", "CCW");
		826	break;
		827	case ROTATE_HALF:
		828	xf86ReplaceStrOption(local->options, "Rotate", "HALF");
		829	break;
		830	default:
		831	return BadValue;
		832	}
		833	oldRotation = priv->common->wcmRotate;
		834	oldMaxX = priv->common->wcmMaxX;
		835	oldMaxY = priv->common->wcmMaxY;
		836	priv->common->wcmRotate = value;
		837	if (((oldRotation == ROTATE_NONE \|\| oldRotation == ROTATE_HALF) && (value == ROTATE_CW \|\| value == ROTATE_CCW)) \|\|
		838	((oldRotation == ROTATE_CW \|\| oldRotation == ROTATE_CCW) && (value == ROTATE_NONE \|\| value == ROTATE_HALF)))
		839	{
		840	priv->common->wcmMaxX = oldMaxY;
		841	priv->common->wcmMaxY = oldMaxX;
		842	}
		843
		844	/* rotate all devices at once! else they get misaligned */
		845	for (dev=0; dev < priv->common->wcmNumDevices; dev++)
		846	{
		847	tmppriv = (WacomDevicePtr)priv->common->wcmDevices[dev]->private;
		848	/* recover the unrotated xy-rectangles */
		849	switch (oldRotation) {
		850	case ROTATE_CW:
		851	tmpTopX = oldMaxY - tmppriv->bottomY;
		852	tmpBottomX = oldMaxY - tmppriv->topY;
		853	tmpTopY = tmppriv->topX;
		854	tmpBottomY = tmppriv->bottomX;
		855	break;
		856	case ROTATE_CCW:
		857	tmpTopX = tmppriv->topY;
		858	tmpBottomX = tmppriv->bottomY;
		859	tmpTopY = oldMaxX - tmppriv->bottomX;
		860	tmpBottomY = oldMaxX - tmppriv->topX;
		861	break;
		862	case ROTATE_HALF:
		863	tmpTopX = oldMaxX - tmppriv->bottomX;
		864	tmpBottomX = oldMaxX - tmppriv->topX;
		865	tmpTopY = oldMaxY - tmppriv->bottomY;
		866	tmpBottomY = oldMaxY - tmppriv->topY;
		867	break;
		868	default: /* ROTATE_NONE */
		869	tmpTopX = tmppriv->topX;
		870	tmpBottomX = tmppriv->bottomX;
		871	tmpTopY = tmppriv->topY;
		872	tmpBottomY = tmppriv->bottomY;
		873	break;
		874	}
		875	/* and rotate them back */
		876	switch (value) {
		877	case ROTATE_CW:
		878	tmppriv->topX = tmpTopY;
879	tmppriv->bottomX = tmpBottomY;
880	tmppriv->topY = priv->common->wcmMaxY - tmpBottomX;
881	tmppriv->bottomY = priv->common->wcmMaxY - tmpTopX;
882	break;
883	case ROTATE_CCW:
884	tmppriv->topX = priv->common->wcmMaxX - tmpBottomY;
885	tmppriv->bottomX = priv->common->wcmMaxX - tmpTopY;
886	tmppriv->topY = tmpTopX;
887	tmppriv->bottomY = tmpBottomX;
888	break;
889	case ROTATE_HALF:
890	tmppriv->topX = priv->common->wcmMaxX - tmpBottomX;
891	tmppriv->bottomX = priv->common->wcmMaxX - tmpTopX;
892	tmppriv->topY= priv->common->wcmMaxY - tmpBottomY;
893	tmppriv->bottomY = priv->common->wcmMaxY - tmpTopY;
894	break;
895	default: /* ROTATE_NONE */
896	tmppriv->topX = tmpTopX;
897	tmppriv->bottomX = tmpBottomX;
898	tmppriv->topY = tmpTopY;
899	tmppriv->bottomY = tmpBottomY;
900	break;
901	}
902
903	InitValuatorAxisStruct(priv->common->wcmDevices[dev]->dev,
904	0, tmppriv->topX, tmppriv->bottomX, priv->common->wcmResolX, /* tablet resolution */
905	0, priv->common->wcmResolX); /* max_res */
906
907	InitValuatorAxisStruct(priv->common->wcmDevices[dev]->dev,
908	1, tmppriv->topY, tmppriv->bottomY, priv->common->wcmResolY, /* tablet resolution */
909	0, priv->common->wcmResolY); /* max_res */
910	}
911	break;
804	case XWACOM_PARAM_MMT:	912	case XWACOM_PARAM_MMT:
805	if ((value != 0) && (value != 1)) return BadValue;	913	if ((value != 0) && (value != 1)) return BadValue;
806	priv->common->wcmMMonitor = value;	914	priv->common->wcmMMonitor = value;

Lines 150-155 Link Here

(-)linuxwacom-0.7.2-orig/src/xf86Wacom.h (-4 / +5 lines)
150	#define ERASER_PROX 4	150	#define ERASER_PROX 4
151	#define OTHER_PROX 1	151	#define OTHER_PROX 1
152		152
		153	#define ROTATE_NONE XWACOM_VALUE_ROTATE_NONE
		154	#define ROTATE_CW XWACOM_VALUE_ROTATE_CW
		155	#define ROTATE_CCW XWACOM_VALUE_ROTATE_CCW
		156	#define ROTATE_HALF XWACOM_VALUE_ROTATE_HALF
		157
153	/******************************************************************************	158	/******************************************************************************
154	* Forward Declarations	159	* Forward Declarations
155	*****************************************************************************/	160	*****************************************************************************/
Lines 414-423 Link Here
414		419
415	#define DEVICE_ISDV4 0x000C	420	#define DEVICE_ISDV4 0x000C
416		421
417	#define ROTATE_NONE 0
418	#define ROTATE_CW 1
419	#define ROTATE_CCW 2
420
421	#define MAX_CHANNELS 2	422	#define MAX_CHANNELS 2
422	#define MAX_USB_EVENTS 32	423	#define MAX_USB_EVENTS 32
423		424