svn merge file:///D:/svnrepos/vcxsrv/branches/released .

1 files changed, 575 insertions, 21 deletions

diff --git a/xorg-server/hw/xfree86/modes/xf86RandR12.c b/xorg-server/hw/xfree86/modes/xf86RandR12.c
index 6f8ccdf84..454649213 100644
--- a/xorg-server/hw/xfree86/modes/xf86RandR12.c
+++ b/xorg-server/hw/xfree86/modes/xf86RandR12.c
@@ -37,6 +37,7 @@
 #include "xf86DDC.h"
 #include "mipointer.h"
 #include "windowstr.h"
+#include "inputstr.h"
 #include <randrstr.h>
 #include <X11/extensions/render.h>
 
@@ -50,6 +51,8 @@ typedef struct _xf86RandR12Info {
     int				    mmHeight;
     int				    maxX;
     int				    maxY;
+    int				    pointerX;
+    int				    pointerY;
     Rotation			    rotation; /* current mode */
     Rotation                        supported_rotations; /* driver supported */
 } XF86RandRInfoRec, *XF86RandRInfoPtr;
@@ -60,11 +63,22 @@ static Bool xf86RandR12CreateScreenResources12 (ScreenPtr pScreen);
 #endif
 
 static int xf86RandR12Generation;
-static DevPrivateKey xf86RandR12Key;
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
 
+static int xf86RandR12KeyIndex;
+static DevPrivateKey xf86RandR12Key;
 #define XF86RANDRINFO(p) ((XF86RandRInfoPtr) \
     dixLookupPrivate(&(p)->devPrivates, xf86RandR12Key))
 
+#else /* XORG_VERSION_CURRENT < 7.0 */
+
+static int xf86RandR12Index;
+#define XF86RANDRINFO(p) \
+    ((XF86RandRInfoPtr)(p)->devPrivates[xf86RandR12Index].ptr)
+
+#endif /* XORG_VERSION_CURRENT < 7.0 */
+
+
 static int
 xf86RandR12ModeRefresh (DisplayModePtr mode)
 {
@@ -74,6 +88,355 @@ xf86RandR12ModeRefresh (DisplayModePtr mode)
 	return (int) (mode->Clock * 1000.0 / mode->HTotal / mode->VTotal + 0.5);
 }
 
+/* Adapt panning area; return TRUE if panning area was valid without adaption */
+static int
+xf86RandR13VerifyPanningArea (xf86CrtcPtr crtc, int screenWidth, int screenHeight)
+{
+    int ret = TRUE;
+
+    if (crtc->version < 2)
+	return FALSE;
+
+    if (crtc->panningTotalArea.x2 <= crtc->panningTotalArea.x1) {
+	/* Panning in X is disabled */
+	if (crtc->panningTotalArea.x1 || crtc->panningTotalArea.x2)
+	    /* Illegal configuration -> fail/disable */
+	    ret = FALSE;
+	crtc->panningTotalArea.x1    = crtc->panningTotalArea.x2    = 0;
+	crtc->panningTrackingArea.x1 = crtc->panningTrackingArea.x2 = 0;
+	crtc->panningBorder[0]       = crtc->panningBorder[2]       = 0;
+    } else {
+	/* Panning in X is enabled */
+	if (crtc->panningTotalArea.x1 < 0) {
+	    /* Panning region outside screen -> move inside */
+	    crtc->panningTotalArea.x2 -= crtc->panningTotalArea.x1;
+	    crtc->panningTotalArea.x1 = 0;
+	    ret = FALSE;
+	}
+	if (crtc->panningTotalArea.x2 < crtc->panningTotalArea.x1 + crtc->mode.HDisplay) {
+	    /* Panning region smaller than displayed area -> crop to displayed area */
+	    crtc->panningTotalArea.x2 = crtc->panningTotalArea.x1 + crtc->mode.HDisplay;
+	    ret = FALSE;
+	}
+	if (crtc->panningTotalArea.x2 > screenWidth) {
+	    /* Panning region larger than screen -> move inside, then crop to screen */
+	    crtc->panningTotalArea.x1 -= crtc->panningTotalArea.x2 - screenWidth;
+	    crtc->panningTotalArea.x2 = screenWidth;
+	    ret = FALSE;
+	    if (crtc->panningTotalArea.x1 < 0)
+		crtc->panningTotalArea.x1 = 0;
+	}
+	if (crtc->panningBorder[0] + crtc->panningBorder[2] > crtc->mode.HDisplay) {
+	    /* Borders too large -> set to 0 */
+	    crtc->panningBorder[0] = crtc->panningBorder[2] = 0;
+	    ret = FALSE;
+	}
+    }
+
+    if (crtc->panningTotalArea.y2 <= crtc->panningTotalArea.y1) {
+	/* Panning in Y is disabled */
+	if (crtc->panningTotalArea.y1 || crtc->panningTotalArea.y2)
+	    /* Illegal configuration -> fail/disable */
+	    ret = FALSE;
+	crtc->panningTotalArea.y1    = crtc->panningTotalArea.y2    = 0;
+	crtc->panningTrackingArea.y1 = crtc->panningTrackingArea.y2 = 0;
+	crtc->panningBorder[1]       = crtc->panningBorder[3]       = 0;
+    } else {
+	/* Panning in Y is enabled */
+	if (crtc->panningTotalArea.y1 < 0) {
+	    /* Panning region outside screen -> move inside */
+	    crtc->panningTotalArea.y2 -= crtc->panningTotalArea.y1;
+	    crtc->panningTotalArea.y1 = 0;
+	    ret = FALSE;
+	}
+	if (crtc->panningTotalArea.y2 < crtc->panningTotalArea.y1 + crtc->mode.VDisplay) {
+	    /* Panning region smaller than displayed area -> crop to displayed area */
+	    crtc->panningTotalArea.y2 = crtc->panningTotalArea.y1 + crtc->mode.VDisplay;
+	    ret = FALSE;
+	}
+	if (crtc->panningTotalArea.y2 > screenHeight) {
+	    /* Panning region larger than screen -> move inside, then crop to screen */
+	    crtc->panningTotalArea.y1 -= crtc->panningTotalArea.y2 - screenHeight;
+	    crtc->panningTotalArea.y2 = screenHeight;
+	    ret = FALSE;
+	    if (crtc->panningTotalArea.y1 < 0)
+		crtc->panningTotalArea.y1 = 0;
+	}
+	if (crtc->panningBorder[1] + crtc->panningBorder[3] > crtc->mode.VDisplay) {
+	    /* Borders too large -> set to 0 */
+	    crtc->panningBorder[1] = crtc->panningBorder[3] = 0;
+	    ret = FALSE;
+	}
+    }
+
+    return ret;
+}
+
+/*
+ * The heart of the panning operation:
+ *
+ * Given a frame buffer position (fb_x, fb_y),
+ * and a crtc position (crtc_x, crtc_y),
+ * and a transform matrix which maps frame buffer to crtc,
+ * compute a panning position (pan_x, pan_y) that
+ * makes the resulting transform line those two up
+ */
+
+static void
+xf86ComputeCrtcPan (Bool transform_in_use,
+		    struct pixman_f_transform *m,
+		    double screen_x, double screen_y,
+		    double crtc_x, double crtc_y,
+		    int old_pan_x, int old_pan_y,
+		    int *new_pan_x, int *new_pan_y)
+{
+    if (transform_in_use) {
+	/*
+	 * Given the current transform, M, the current position
+	 * on the Screen, S, and the desired position on the CRTC,
+	 * C, compute a translation, T, such that:
+	 *
+	 * M T S = C
+	 *
+	 * where T is of the form
+	 *
+	 * | 1 0 dx |
+	 * | 0 1 dy |
+	 * | 0 0 1  |
+	 *
+	 * M T S =
+	 *   | M00 Sx + M01 Sy + M00 dx + M01 dy + M02 |   | Cx F |
+	 *   | M10 Sx + M11 Sy + M10 dx + M11 dy + M12 | = | Cy F |
+	 *   | M20 Sx + M21 Sy + M20 dx + M21 dy + M22 |   |  F   |
+	 *
+	 * R = M S
+	 *
+	 *   Cx F = M00 dx + M01 dy + R0
+	 *   Cy F = M10 dx + M11 dy + R1
+	 *      F = M20 dx + M21 dy + R2
+	 *
+	 * Zero out dx, then dy
+	 *
+	 * F (Cx M10 - Cy M00) =
+	 *	    (M10 M01 - M00 M11) dy + M10 R0 - M00 R1
+	 * F (M10 - Cy M20) =
+	 *	    (M10 M21 - M20 M11) dy + M10 R2 - M20 R1
+	 *
+	 * F (Cx M11 - Cy M01) =
+	 *	    (M11 M00 - M01 M10) dx + M11 R0 - M01 R1
+	 * F (M11 - Cy M21) =
+	 *	    (M11 M20 - M21 M10) dx + M11 R2 - M21 R1
+	 *
+	 * Make some temporaries
+	 *
+	 * T = | Cx M10 - Cy M00 |
+	 *     | Cx M11 - Cy M01 |
+	 *
+	 * U = | M10 M01 - M00 M11 |
+	 *     | M11 M00 - M01 M10 |
+	 *
+	 * Q = | M10 R0 - M00 R1 |
+	 *     | M11 R0 - M01 R1 |
+	 *
+	 * P = | M10 - Cy M20 |
+	 *     | M11 - Cy M21 |
+	 *
+	 * W = | M10 M21 - M20 M11 |
+	 *     | M11 M20 - M21 M10 |
+	 *
+	 * V = | M10 R2 - M20 R1 |
+	 *	   | M11 R2 - M21 R1 |
+	 *
+	 * Rewrite:
+	 *
+	 * F T0 = U0 dy + Q0
+	 * F P0 = W0 dy + V0
+	 * F T1 = U1 dx + Q1
+	 * F P1 = W1 dx + V1
+	 *
+	 * Solve for F (two ways)
+	 *
+	 * F (W0 T0 - U0 P0)  = W0 Q0 - U0 V0
+	 *
+	 *     W0 Q0 - U0 V0
+	 * F = -------------
+	 *     W0 T0 - U0 P0
+	 *
+	 * F (W1 T1 - U1 P1) = W1 Q1 - U1 V1
+	 *
+	 *     W1 Q1 - U1 V1
+	 * F = -------------
+	 *     W1 T1 - U1 P1
+	 *
+	 * We'll use which ever solution works (denominator != 0)
+	 *
+	 * Finally, solve for dx and dy:
+	 *
+	 * dx = (F T1 - Q1) / U1
+	 * dx = (F P1 - V1) / W1
+	 *
+	 * dy = (F T0 - Q0) / U0
+	 * dy = (F P0 - V0) / W0
+	 */
+	double			    r[3];
+	double			    q[2], u[2], t[2], v[2], w[2], p[2];
+	double			    f;
+	struct pict_f_vector	    d;
+	int			    i;
+
+	/* Get the un-normalized crtc coordinates again */
+	for (i = 0; i < 3; i++)
+	    r[i] = m->m[i][0] * screen_x + m->m[i][1] * screen_y + m->m[i][2];
+
+	/* Combine values into temporaries */
+	for (i = 0; i < 2; i++) {
+	    q[i] = m->m[1][i] * r[0] - m->m[0][i] * r[1];
+	    u[i] = m->m[1][i] * m->m[0][1-i] - m->m[0][i] * m->m[1][1-i];
+	    t[i] = m->m[1][i] * crtc_x - m->m[0][i] * crtc_y;
+
+	    v[i] = m->m[1][i] * r[2] - m->m[2][i] * r[1];
+	    w[i] = m->m[1][i] * m->m[2][1-i] - m->m[2][i] * m->m[1][1-i];
+	    p[i] = m->m[1][i] - m->m[2][i] * crtc_y;
+	}
+
+	/* Find a way to compute f */
+	f = 0;
+	for (i = 0; i < 2; i++) {
+	    double a = w[i] * q[i] - u[i] * v[i];
+	    double b = w[i] * t[i] - u[i] * p[i];
+	    if (b != 0) {
+		f = a/b;
+		break;
+	    }
+	}
+
+	/* Solve for the resulting transform vector */
+	for (i = 0; i < 2; i++) {
+	    if (u[i])
+		d.v[1-i] = (t[i] * f - q[i]) / u[i];
+	    else if (w[1])
+		d.v[1-i] = (p[i] * f - v[i]) / w[i];
+	    else
+		d.v[1-i] = 0;
+	}
+	*new_pan_x = old_pan_x - floor (d.v[0] + 0.5);
+	*new_pan_y = old_pan_y - floor (d.v[1] + 0.5);
+    } else {
+	*new_pan_x = screen_x - crtc_x;
+	*new_pan_y = screen_y - crtc_y;
+    }
+}
+
+static void
+xf86RandR13Pan (xf86CrtcPtr crtc, int x, int y)
+{
+    int newX, newY;
+    int width, height;
+    Bool panned = FALSE;
+
+    if (crtc->version < 2)
+	return;
+
+    if (! crtc->enabled						||
+	(crtc->panningTotalArea.x2 <= crtc->panningTotalArea.x1	&&
+	 crtc->panningTotalArea.y2 <= crtc->panningTotalArea.y1))
+	return;
+
+    newX   = crtc->x;
+    newY   = crtc->y;
+    width  = crtc->mode.HDisplay;
+    height = crtc->mode.VDisplay;
+
+    if ((crtc->panningTrackingArea.x2 <= crtc->panningTrackingArea.x1 ||
+	 (x >= crtc->panningTrackingArea.x1 && x < crtc->panningTrackingArea.x2)) &&
+	(crtc->panningTrackingArea.y2 <= crtc->panningTrackingArea.y1 ||
+	 (y >= crtc->panningTrackingArea.y1 && y < crtc->panningTrackingArea.y2)))
+    {
+	struct pict_f_vector    c;
+
+	/*
+	 * Pre-clip the mouse position to the panning area so that we don't
+	 * push the crtc outside. This doesn't deal with changes to the
+	 * panning values, only mouse position changes.
+	 */
+	if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1)
+	{
+	    if (x < crtc->panningTotalArea.x1)
+		x = crtc->panningTotalArea.x1;
+	    if (x >= crtc->panningTotalArea.x2)
+		x = crtc->panningTotalArea.x2 - 1;
+	}
+	if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1)
+	{
+	    if (y < crtc->panningTotalArea.y1)
+		y = crtc->panningTotalArea.y1;
+	    if (y >= crtc->panningTotalArea.y2)
+		y = crtc->panningTotalArea.y2 - 1;
+	}
+
+	c.v[0] = x;
+	c.v[1] = y;
+	c.v[2] = 1.0;
+	if (crtc->transform_in_use) {
+	    pixman_f_transform_point(&crtc->f_framebuffer_to_crtc, &c);
+	} else {
+	    c.v[0] -= crtc->x;
+	    c.v[1] -= crtc->y;
+	}
+
+	if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
+	    if (c.v[0] < crtc->panningBorder[0]) {
+		c.v[0] = crtc->panningBorder[0];
+		panned = TRUE;
+	    }
+	    if (c.v[0] >= width - crtc->panningBorder[2]) {
+		c.v[0] = width - crtc->panningBorder[2] - 1;
+		panned = TRUE;
+	    }
+	}
+	if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
+	    if (c.v[1] < crtc->panningBorder[1]) {
+		c.v[1] = crtc->panningBorder[1];
+		panned = TRUE;
+	    }
+	    if (c.v[1] >= height - crtc->panningBorder[3]) {
+		c.v[1] = height - crtc->panningBorder[3] - 1;
+		panned = TRUE;
+	    }
+	}
+	if (panned)
+	    xf86ComputeCrtcPan (crtc->transform_in_use,
+				&crtc->f_framebuffer_to_crtc,
+				x, y, c.v[0], c.v[1],
+				newX, newY, &newX, &newY);
+    }
+
+    /*
+     * Ensure that the crtc is within the panning region.
+     *
+     * XXX This computation only works when we do not have a transform
+     * in use.
+     */
+    if (!crtc->transform_in_use)
+    {
+	/* Validate against [xy]1 after [xy]2, to be sure that results are > 0 for [xy]1 > 0 */
+	if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1) {
+	    if (newX > crtc->panningTotalArea.x2 - width)
+		newX =  crtc->panningTotalArea.x2 - width;
+	    if (newX <  crtc->panningTotalArea.x1)
+		newX =  crtc->panningTotalArea.x1;
+	}
+	if (crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
+	    if (newY > crtc->panningTotalArea.y2 - height)
+		newY =  crtc->panningTotalArea.y2 - height;
+	    if (newY <  crtc->panningTotalArea.y1)
+		newY =  crtc->panningTotalArea.y1;
+	}
+    }
+    if (newX != crtc->x || newY != crtc->y)
+	xf86CrtcSetOrigin (crtc, newX, newY);
+}
+
 static Bool
 xf86RandR12GetInfo (ScreenPtr pScreen, Rotation *rotations)
 {
@@ -247,7 +610,7 @@ xf86RandR12SetConfig (ScreenPtr		pScreen,
 	randrp->virtualY = scrp->virtualY;
     }
 
-    miPointerPosition (&px, &py);
+    miPointerGetPosition (inputInfo.pointer, &px, &py);
     for (mode = scrp->modes; ; mode = mode->next)
     {
 	if (randrp->maxX == 0 || randrp->maxY == 0)
@@ -294,14 +657,14 @@ xf86RandR12SetConfig (ScreenPtr		pScreen,
     /*
      * Move the cursor back where it belongs; SwitchMode repositions it
      */
-    if (pScreen == miPointerCurrentScreen ())
+    if (pScreen == miPointerGetScreen(inputInfo.pointer))
     {
         px = (px >= pScreen->width ? (pScreen->width - 1) : px);
         py = (py >= pScreen->height ? (pScreen->height - 1) : py);
 
 	xf86SetViewport(pScreen, px, py);
 
-	(*pScreen->SetCursorPosition) (pScreen, px, py, FALSE);
+	(*pScreen->SetCursorPosition) (inputInfo.pointer, pScreen, px, py, FALSE);
     }
 
     return TRUE;
@@ -320,14 +683,19 @@ xf86RandR12ScreenSetSize (ScreenPtr	pScreen,
     WindowPtr		pRoot = WindowTable[pScreen->myNum];
     PixmapPtr		pScrnPix = (*pScreen->GetScreenPixmap)(pScreen);
     Bool		ret = FALSE;
+    int                 c;
 
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
     if (xf86RandR12Key) {
+#endif
         if (randrp->virtualX == -1 || randrp->virtualY == -1)
         {
 	    randrp->virtualX = pScrn->virtualX;
 	    randrp->virtualY = pScrn->virtualY;
         }
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
     }
+#endif
     if (pRoot && pScrn->vtSema)
 	(*pScrn->EnableDisableFBAccess) (pScreen->myNum, FALSE);
 
@@ -336,6 +704,23 @@ xf86RandR12ScreenSetSize (ScreenPtr	pScreen,
 	goto finish;
 
     ret = TRUE;
+    /* Update panning information */
+    for (c = 0; c < config->num_crtc; c++) {
+	xf86CrtcPtr crtc = config->crtc[c];
+	if (crtc->panningTotalArea.x2 > crtc->panningTotalArea.x1 ||
+	    crtc->panningTotalArea.y2 > crtc->panningTotalArea.y1) {
+	    if (crtc->panningTotalArea.x2 > crtc->panningTrackingArea.x1)
+		crtc->panningTotalArea.x2 += width  - pScreen->width;
+	    if (crtc->panningTotalArea.y2 > crtc->panningTrackingArea.y1)
+		crtc->panningTotalArea.y2 += height - pScreen->height;
+	    if (crtc->panningTrackingArea.x2 > crtc->panningTrackingArea.x1)
+		crtc->panningTrackingArea.x2 += width  - pScreen->width;
+	    if (crtc->panningTrackingArea.y2 > crtc->panningTrackingArea.y1)
+		crtc->panningTrackingArea.y2 += height - pScreen->height;
+	    xf86RandR13VerifyPanningArea (crtc, width, height);
+	    xf86RandR13Pan (crtc, randrp->pointerX, randrp->pointerY);
+	}
+    }
 
     pScreen->width = pScrnPix->drawable.width = width;
     pScreen->height = pScrnPix->drawable.height = height;
@@ -367,8 +752,8 @@ _X_EXPORT Bool
 xf86RandR12CreateScreenResources (ScreenPtr pScreen)
 {
     ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
+    xf86CrtcConfigPtr   config;
+    XF86RandRInfoPtr	randrp;
     int			c;
     int			width, height;
     int			mmWidth, mmHeight;
@@ -378,6 +763,8 @@ xf86RandR12CreateScreenResources (ScreenPtr pScreen)
 	return TRUE;
 #endif
 
+    config = XF86_CRTC_CONFIG_PTR(pScrn);
+    randrp = XF86RANDRINFO(pScreen);
     /*
      * Compute size of screen
      */
@@ -388,10 +775,16 @@ xf86RandR12CreateScreenResources (ScreenPtr pScreen)
 	int	    crtc_width = crtc->x + xf86ModeWidth (&crtc->mode, crtc->rotation);
 	int	    crtc_height = crtc->y + xf86ModeHeight (&crtc->mode, crtc->rotation);
 	
-	if (crtc->enabled && crtc_width > width)
-	    width = crtc_width;
-	if (crtc->enabled && crtc_height > height)
-	    height = crtc_height;
+	if (crtc->enabled) {
+	    if (crtc_width > width)
+		width = crtc_width;
+	    if (crtc_height > height)
+		height = crtc_height;
+	    if (crtc->panningTotalArea.x2 > width)
+		width = crtc->panningTotalArea.x2;
+	    if (crtc->panningTotalArea.y2 > height)
+		height = crtc->panningTotalArea.y2;
+	}
     }
     
     if (width && height)
@@ -442,6 +835,13 @@ xf86RandR12CreateScreenResources (ScreenPtr pScreen)
 	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 		   "Setting screen physical size to %d x %d\n",
 		   mmWidth, mmHeight);
+	/*
+	 * This is the initial setting of the screen size.
+	 * We have to pre-set it here, otherwise panning would be adapted
+	 * to the new screen size.
+	 */
+	pScreen->width  = width;
+	pScreen->height = height;
 	xf86RandR12ScreenSetSize (pScreen,
 				  width,
 				  height,
@@ -449,8 +849,10 @@ xf86RandR12CreateScreenResources (ScreenPtr pScreen)
 				  mmHeight);
     }
 
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
     if (xf86RandR12Key == NULL)
 	return TRUE;
+#endif
 
     if (randrp->virtualX == -1 || randrp->virtualY == -1)
     {
@@ -481,7 +883,11 @@ xf86RandR12Init (ScreenPtr pScreen)
     if (xf86RandR12Generation != serverGeneration)
 	xf86RandR12Generation = serverGeneration;
 
-    xf86RandR12Key = &xf86RandR12Key;
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
+    xf86RandR12Key = &xf86RandR12KeyIndex;
+#else
+    xf86RandR12Index = AllocateScreenPrivateIndex();
+#endif
 
     randrp = xalloc (sizeof (XF86RandRInfoRec));
     if (!randrp)
@@ -507,7 +913,11 @@ xf86RandR12Init (ScreenPtr pScreen)
 
     randrp->maxX = randrp->maxY = 0;
 
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
     dixSetPrivate(&pScreen->devPrivates, xf86RandR12Key, randrp);
+#else
+    pScreen->devPrivates[xf86RandR12Index].ptr = randrp;
+#endif
 
 #if RANDR_12_INTERFACE
     if (!xf86RandR12Init12 (pScreen))
@@ -526,8 +936,10 @@ xf86RandR12SetRotations (ScreenPtr pScreen, Rotation rotations)
     xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
 #endif
 
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
     if (xf86RandR12Key == NULL)
 	return;
+#endif
 
     randrp = XF86RANDRINFO(pScreen);
 #if RANDR_12_INTERFACE
@@ -541,6 +953,31 @@ xf86RandR12SetRotations (ScreenPtr pScreen, Rotation rotations)
 }
 
 _X_EXPORT void
+xf86RandR12SetTransformSupport (ScreenPtr pScreen, Bool transforms)
+{
+    XF86RandRInfoPtr	randrp;
+#if RANDR_13_INTERFACE
+    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
+    int			c;
+    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
+#endif
+
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
+    if (xf86RandR12Key == NULL)
+	return;
+#endif
+
+    randrp = XF86RANDRINFO(pScreen);
+#if RANDR_13_INTERFACE
+    for (c = 0; c < config->num_crtc; c++) {
+	xf86CrtcPtr    crtc = config->crtc[c];
+
+	RRCrtcSetTransformSupport (crtc->randr_crtc, transforms);
+    }
+#endif
+}
+
+_X_EXPORT void
 xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn, int *x, int *y)
 {
     ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
@@ -662,7 +1099,9 @@ xf86RandR12CrtcNotify (RRCrtcPtr	randr_crtc)
 	}
     }
     ret = RRCrtcNotify (randr_crtc, randr_mode, x, y,
-			rotation, numOutputs, randr_outputs);
+			rotation, 
+			crtc->transformPresent ? &crtc->transform : NULL,
+			numOutputs, randr_outputs);
     xfree(randr_outputs);
     return ret;
 }
@@ -698,18 +1137,20 @@ xf86RandRModeConvert (ScrnInfoPtr	scrn,
 }
 
 static Bool
-xf86RandR12CrtcSet (ScreenPtr	pScreen,
-		  RRCrtcPtr	randr_crtc,
-		  RRModePtr	randr_mode,
-		  int		x,
-		  int		y,
-		  Rotation	rotation,
-		  int		num_randr_outputs,
-		  RROutputPtr	*randr_outputs)
+xf86RandR12CrtcSet (ScreenPtr	    pScreen,
+		    RRCrtcPtr	    randr_crtc,
+		    RRModePtr	    randr_mode,
+		    int		    x,
+		    int		    y,
+		    Rotation	    rotation,
+		    int		    num_randr_outputs,
+		    RROutputPtr	    *randr_outputs)
 {
+    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
     ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
     xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
     xf86CrtcPtr		crtc = randr_crtc->devPrivate;
+    RRTransformPtr	transform;
     Bool		changed = FALSE;
     int			o, ro;
     xf86CrtcPtr		*save_crtcs;
@@ -727,6 +1168,13 @@ xf86RandR12CrtcSet (ScreenPtr	pScreen,
     if (rotation != crtc->rotation)
 	changed = TRUE;
 
+    transform = RRCrtcGetTransform (randr_crtc);
+    if ((transform != NULL) != crtc->transformPresent)
+	changed = TRUE;
+    else if (transform && memcmp (&transform->transform, &crtc->transform.transform,
+				  sizeof (transform->transform)) != 0)
+	changed = TRUE;
+
     if (x != crtc->x || y != crtc->y)
 	changed = TRUE;
     for (o = 0; o < config->num_output; o++) 
@@ -764,9 +1212,10 @@ xf86RandR12CrtcSet (ScreenPtr	pScreen,
 	if (randr_mode)
 	{
 	    DisplayModeRec  mode;
+	    RRTransformPtr  transform = RRCrtcGetTransform (randr_crtc);
 
 	    xf86RandRModeConvert (pScrn, randr_mode, &mode);
-	    if (!xf86CrtcSetMode (crtc, &mode, rotation, x, y))
+	    if (!xf86CrtcSetModeTransform (crtc, &mode, rotation, transform, x, y))
 	    {
 		crtc->enabled = save_enabled;
 		for (o = 0; o < config->num_output; o++)
@@ -777,11 +1226,19 @@ xf86RandR12CrtcSet (ScreenPtr	pScreen,
 		xfree(save_crtcs);
 		return FALSE;
 	    }
+	    xf86RandR13VerifyPanningArea (crtc, pScreen->width, pScreen->height);
+	    xf86RandR13Pan (crtc, randrp->pointerX, randrp->pointerY);
 	    /*
 	     * Save the last successful setting for EnterVT
 	     */
 	    crtc->desiredMode = mode;
 	    crtc->desiredRotation = rotation;
+	    if (transform) {
+		crtc->desiredTransform = *transform;
+		crtc->desiredTransformPresent = TRUE;
+	    } else
+		crtc->desiredTransformPresent = FALSE;
+
 	    crtc->desiredX = x;
 	    crtc->desiredY = y;
 	}
@@ -832,6 +1289,20 @@ xf86RandR12OutputSetProperty (ScreenPtr pScreen,
 }
 
 static Bool
+xf86RandR13OutputGetProperty (ScreenPtr pScreen,
+			      RROutputPtr randr_output,
+			      Atom property)
+{
+    xf86OutputPtr output = randr_output->devPrivate;
+
+    if (output->funcs->get_property == NULL)
+	return TRUE;
+
+    /* Should be safe even w/o vtSema */
+    return output->funcs->get_property(output, property);
+}
+
+static Bool
 xf86RandR12OutputValidateMode (ScreenPtr    pScreen,
 			       RROutputPtr  randr_output,
 			       RRModePtr    randr_mode)
@@ -1060,8 +1531,10 @@ xf86RandR12CreateScreenResources12 (ScreenPtr pScreen)
     ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
     xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
 
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
     if (xf86RandR12Key == NULL)
 	return TRUE;
+#endif
 
     for (c = 0; c < config->num_crtc; c++)
         xf86RandR12CrtcNotify (config->crtc[c]->randr_crtc);
@@ -1083,8 +1556,13 @@ xf86RandR12TellChanged (ScreenPtr pScreen)
     xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
     int			c;
 
+#if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(7,0,0,0,0)
     if (xf86RandR12Key == NULL)
 	return;
+#else
+    if (!XF86RANDRINFO(pScreen))
+	return;
+#endif
 
     xf86RandR12SetInfo12 (pScreen);
     for (c = 0; c < config->num_crtc; c++)
@@ -1096,6 +1574,77 @@ xf86RandR12TellChanged (ScreenPtr pScreen)
 static void
 xf86RandR12PointerMoved (int scrnIndex, int x, int y)
 {
+    ScreenPtr		pScreen = screenInfo.screens[scrnIndex];
+    ScrnInfoPtr		pScrn   = XF86SCRNINFO(pScreen);
+    xf86CrtcConfigPtr	config  = XF86_CRTC_CONFIG_PTR(pScrn);
+    XF86RandRInfoPtr	randrp  = XF86RANDRINFO(pScreen);
+    int c;
+
+    randrp->pointerX = x;
+    randrp->pointerY = y;
+    for (c = 0; c < config->num_crtc; c++)
+	xf86RandR13Pan (config->crtc[c], x, y);
+}
+
+static Bool
+xf86RandR13GetPanning (ScreenPtr           pScreen,
+		       RRCrtcPtr           randr_crtc,
+		       BoxPtr              totalArea,
+		       BoxPtr              trackingArea,
+		       INT16               *border)
+{
+    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
+
+    if (crtc->version < 2)
+	return FALSE;
+    if (totalArea)
+	memcpy (totalArea,    &crtc->panningTotalArea,    sizeof(BoxRec));
+    if (trackingArea)
+	memcpy (trackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
+    if (border)
+	memcpy (border,        crtc->panningBorder,       4*sizeof(INT16));
+
+    return TRUE;
+}
+
+static Bool
+xf86RandR13SetPanning (ScreenPtr           pScreen,
+		       RRCrtcPtr           randr_crtc,
+		       BoxPtr              totalArea,
+		       BoxPtr              trackingArea,
+		       INT16               *border)
+{
+    XF86RandRInfoPtr	randrp  = XF86RANDRINFO(pScreen);
+    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
+    BoxRec		oldTotalArea;
+    BoxRec		oldTrackingArea;
+    INT16		oldBorder[4];
+
+
+    if (crtc->version < 2)
+	return FALSE;
+
+    memcpy (&oldTotalArea,    &crtc->panningTotalArea,    sizeof(BoxRec));
+    memcpy (&oldTrackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
+    memcpy (oldBorder,         crtc->panningBorder,       4*sizeof(INT16));
+
+    if (totalArea)
+	memcpy (&crtc->panningTotalArea, totalArea, sizeof(BoxRec));
+    if (trackingArea)
+	memcpy (&crtc->panningTrackingArea, trackingArea, sizeof(BoxRec));
+    if (border)
+	memcpy (crtc->panningBorder, border, 4*sizeof(INT16));
+
+    if (xf86RandR13VerifyPanningArea (crtc, pScreen->width, pScreen->height)) {
+	xf86RandR13Pan (crtc, randrp->pointerX, randrp->pointerY);
+	return TRUE;
+    } else {
+	/* Restore old settings */
+	memcpy (&crtc->panningTotalArea,    &oldTotalArea,    sizeof(BoxRec));
+	memcpy (&crtc->panningTrackingArea, &oldTrackingArea, sizeof(BoxRec));
+	memcpy (crtc->panningBorder,         oldBorder,       4*sizeof(INT16));
+	return FALSE;
+    }
 }
 
 static Bool
@@ -1110,6 +1659,11 @@ xf86RandR12Init12 (ScreenPtr pScreen)
     rp->rrCrtcSetGamma = xf86RandR12CrtcSetGamma;
     rp->rrOutputSetProperty = xf86RandR12OutputSetProperty;
     rp->rrOutputValidateMode = xf86RandR12OutputValidateMode;
+#if RANDR_13_INTERFACE
+    rp->rrOutputGetProperty = xf86RandR13OutputGetProperty;
+    rp->rrGetPanning = xf86RandR13GetPanning;
+    rp->rrSetPanning = xf86RandR13SetPanning;
+#endif
     rp->rrModeDestroy = xf86RandR12ModeDestroy;
     rp->rrSetConfig = NULL;
     pScrn->PointerMoved = xf86RandR12PointerMoved;