Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 1060 insertions, 1086 deletions

diff --git a/xorg-server/hw/xfree86/modes/xf86RandR12.c b/xorg-server/hw/xfree86/modes/xf86RandR12.c
index d5031a2f1..a773c34c6 100644
--- a/xorg-server/hw/xfree86/modes/xf86RandR12.c
+++ b/xorg-server/hw/xfree86/modes/xf86RandR12.c
@@ -43,16 +43,16 @@
 #include "xf86RandR12.h"
 
 typedef struct _xf86RandR12Info {
-    int				    virtualX;
-    int				    virtualY;
-    int				    mmWidth;
-    int				    mmHeight;
-    int				    maxX;
-    int				    maxY;
-    int				    pointerX;
-    int				    pointerY;
-    Rotation			    rotation; /* current mode */
-    Rotation                        supported_rotations; /* driver supported */
+    int virtualX;
+    int virtualY;
+    int mmWidth;
+    int mmHeight;
+    int maxX;
+    int maxY;
+    int pointerX;
+    int pointerY;
+    Rotation rotation;          /* current mode */
+    Rotation supported_rotations;       /* driver supported */
 
     /* Used to wrap EnterVT so we can re-probe the outputs when a laptop unsuspends
      * (actually, any time that we switch back into our VT).
@@ -63,106 +63,117 @@ typedef struct _xf86RandR12Info {
 } XF86RandRInfoRec, *XF86RandRInfoPtr;
 
 #ifdef RANDR_12_INTERFACE
-static Bool xf86RandR12Init12 (ScreenPtr pScreen);
-static Bool xf86RandR12CreateScreenResources12 (ScreenPtr pScreen);
+static Bool xf86RandR12Init12(ScreenPtr pScreen);
+static Bool xf86RandR12CreateScreenResources12(ScreenPtr pScreen);
 #endif
 
 static int xf86RandR12Generation;
 
 static DevPrivateKeyRec xf86RandR12KeyRec;
 static DevPrivateKey xf86RandR12Key;
+
 #define XF86RANDRINFO(p) ((XF86RandRInfoPtr) \
     dixLookupPrivate(&(p)->devPrivates, xf86RandR12Key))
 
-
 static int
-xf86RandR12ModeRefresh (DisplayModePtr mode)
+xf86RandR12ModeRefresh(DisplayModePtr mode)
 {
     if (mode->VRefresh)
-	return (int) (mode->VRefresh + 0.5);
+        return (int) (mode->VRefresh + 0.5);
     else
-	return (int) (mode->Clock * 1000.0 / mode->HTotal / mode->VTotal + 0.5);
+        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)
+xf86RandR13VerifyPanningArea(xf86CrtcPtr crtc, int screenWidth,
+                             int screenHeight)
 {
     int ret = TRUE;
 
     if (crtc->version < 2)
-	return FALSE;
+        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;
-	}
+        /* 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;
-	}
+        /* 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;
@@ -179,232 +190,232 @@ xf86RandR13VerifyPanningArea (xf86CrtcPtr crtc, int screenWidth, int screenHeigh
  */
 
 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)
+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;
+        /*
+         * 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)
+xf86RandR13Pan(xf86CrtcPtr crtc, int x, int y)
 {
     int newX, newY;
     int width, height;
     Bool panned = FALSE;
 
     if (crtc->version < 2)
-	return;
+        return;
 
-    if (! crtc->enabled						||
-	(crtc->panningTotalArea.x2 <= crtc->panningTotalArea.x1	&&
-	 crtc->panningTotalArea.y2 <= crtc->panningTotalArea.y1))
-	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;
+    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);
+         (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);
     }
 
     /*
@@ -413,131 +424,119 @@ xf86RandR13Pan (xf86CrtcPtr crtc, int x, int y)
      * 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 (!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);
+        xf86CrtcSetOrigin(crtc, newX, newY);
 }
 
 static Bool
-xf86RandR12GetInfo (ScreenPtr pScreen, Rotation *rotations)
+xf86RandR12GetInfo(ScreenPtr pScreen, Rotation * rotations)
 {
-    RRScreenSizePtr	    pSize;
-    ScrnInfoPtr		    scrp = XF86SCRNINFO(pScreen);
-    XF86RandRInfoPtr	    randrp = XF86RANDRINFO(pScreen);
-    DisplayModePtr	    mode;
-    int			    refresh0 = 60;
-    int			    maxX = 0, maxY = 0;
+    RRScreenSizePtr pSize;
+    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    DisplayModePtr mode;
+    int refresh0 = 60;
+    int maxX = 0, maxY = 0;
 
     *rotations = randrp->supported_rotations;
 
-    if (randrp->virtualX == -1 || randrp->virtualY == -1)
-    {
-	randrp->virtualX = scrp->virtualX;
-	randrp->virtualY = scrp->virtualY;
+    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
+        randrp->virtualX = scrp->virtualX;
+        randrp->virtualY = scrp->virtualY;
     }
 
     /* Re-probe the outputs for new monitors or modes */
-    if (scrp->vtSema)
-    {
-	xf86ProbeOutputModes (scrp, 0, 0);
-	xf86SetScrnInfoModes (scrp);
+    if (scrp->vtSema) {
+        xf86ProbeOutputModes(scrp, 0, 0);
+        xf86SetScrnInfoModes(scrp);
     }
 
-    for (mode = scrp->modes; ; mode = mode->next)
-    {
-	int refresh = xf86RandR12ModeRefresh (mode);
-	if (randrp->maxX == 0 || randrp->maxY == 0)
-	{
-		if (maxX < mode->HDisplay)
-			maxX = mode->HDisplay;
-		if (maxY < mode->VDisplay)
-			maxY = mode->VDisplay;
-	}
-	if (mode == scrp->modes)
-	    refresh0 = refresh;
-	pSize = RRRegisterSize (pScreen,
-				mode->HDisplay, mode->VDisplay,
-				randrp->mmWidth, randrp->mmHeight);
-	if (!pSize)
-	    return FALSE;
-	RRRegisterRate (pScreen, pSize, refresh);
-
-	if (xf86ModesEqual(mode, scrp->currentMode))
-	{
-	    RRSetCurrentConfig (pScreen, randrp->rotation, refresh, pSize);
-	}
-	if (mode->next == scrp->modes)
-	    break;
+    for (mode = scrp->modes;; mode = mode->next) {
+        int refresh = xf86RandR12ModeRefresh(mode);
+
+        if (randrp->maxX == 0 || randrp->maxY == 0) {
+            if (maxX < mode->HDisplay)
+                maxX = mode->HDisplay;
+            if (maxY < mode->VDisplay)
+                maxY = mode->VDisplay;
+        }
+        if (mode == scrp->modes)
+            refresh0 = refresh;
+        pSize = RRRegisterSize(pScreen,
+                               mode->HDisplay, mode->VDisplay,
+                               randrp->mmWidth, randrp->mmHeight);
+        if (!pSize)
+            return FALSE;
+        RRRegisterRate(pScreen, pSize, refresh);
+
+        if (xf86ModesEqual(mode, scrp->currentMode)) {
+            RRSetCurrentConfig(pScreen, randrp->rotation, refresh, pSize);
+        }
+        if (mode->next == scrp->modes)
+            break;
     }
 
-    if (randrp->maxX == 0 || randrp->maxY == 0)
-    {
-	randrp->maxX = maxX;
-	randrp->maxY = maxY;
+    if (randrp->maxX == 0 || randrp->maxY == 0) {
+        randrp->maxX = maxX;
+        randrp->maxY = maxY;
     }
 
     return TRUE;
 }
 
 static Bool
-xf86RandR12SetMode (ScreenPtr	    pScreen,
-		  DisplayModePtr    mode,
-		  Bool		    useVirtual,
-		  int		    mmWidth,
-		  int		    mmHeight)
+xf86RandR12SetMode(ScreenPtr pScreen,
+                   DisplayModePtr mode,
+                   Bool useVirtual, int mmWidth, int mmHeight)
 {
-    ScrnInfoPtr		scrp = XF86SCRNINFO(pScreen);
-    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
-    int			oldWidth = pScreen->width;
-    int			oldHeight = pScreen->height;
-    int			oldmmWidth = pScreen->mmWidth;
-    int			oldmmHeight = pScreen->mmHeight;
-    WindowPtr		pRoot = pScreen->root;
-    DisplayModePtr      currentMode = NULL;
-    Bool 		ret = TRUE;
+    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    int oldWidth = pScreen->width;
+    int oldHeight = pScreen->height;
+    int oldmmWidth = pScreen->mmWidth;
+    int oldmmHeight = pScreen->mmHeight;
+    WindowPtr pRoot = pScreen->root;
+    DisplayModePtr currentMode = NULL;
+    Bool ret = TRUE;
 
     if (pRoot)
-	(*scrp->EnableDisableFBAccess) (pScreen->myNum, FALSE);
-    if (useVirtual)
-    {
-	scrp->virtualX = randrp->virtualX;
-	scrp->virtualY = randrp->virtualY;
+        (*scrp->EnableDisableFBAccess) (pScreen->myNum, FALSE);
+    if (useVirtual) {
+        scrp->virtualX = randrp->virtualX;
+        scrp->virtualY = randrp->virtualY;
     }
-    else
-    {
-	scrp->virtualX = mode->HDisplay;
-	scrp->virtualY = mode->VDisplay;
+    else {
+        scrp->virtualX = mode->HDisplay;
+        scrp->virtualY = mode->VDisplay;
     }
 
-    if(randrp->rotation & (RR_Rotate_90 | RR_Rotate_270))
-    {
-	/* If the screen is rotated 90 or 270 degrees, swap the sizes. */
-	pScreen->width = scrp->virtualY;
-	pScreen->height = scrp->virtualX;
-	pScreen->mmWidth = mmHeight;
-	pScreen->mmHeight = mmWidth;
+    if (randrp->rotation & (RR_Rotate_90 | RR_Rotate_270)) {
+        /* If the screen is rotated 90 or 270 degrees, swap the sizes. */
+        pScreen->width = scrp->virtualY;
+        pScreen->height = scrp->virtualX;
+        pScreen->mmWidth = mmHeight;
+        pScreen->mmHeight = mmWidth;
     }
-    else
-    {
-	pScreen->width = scrp->virtualX;
-	pScreen->height = scrp->virtualY;
-	pScreen->mmWidth = mmWidth;
-	pScreen->mmHeight = mmHeight;
+    else {
+        pScreen->width = scrp->virtualX;
+        pScreen->height = scrp->virtualY;
+        pScreen->mmWidth = mmWidth;
+        pScreen->mmHeight = mmHeight;
     }
     if (scrp->currentMode == mode) {
         /* Save current mode */
@@ -549,13 +548,12 @@ xf86RandR12SetMode (ScreenPtr	    pScreen,
      * We know that if the driver failed to SwitchMode to the rotated
      * version, then it should revert back to it's prior mode.
      */
-    if (!xf86SwitchMode (pScreen, mode))
-    {
+    if (!xf86SwitchMode(pScreen, mode)) {
         ret = FALSE;
-	scrp->virtualX = pScreen->width = oldWidth;
-	scrp->virtualY = pScreen->height = oldHeight;
-	pScreen->mmWidth = oldmmWidth;
-	pScreen->mmHeight = oldmmHeight;
+        scrp->virtualX = pScreen->width = oldWidth;
+        scrp->virtualY = pScreen->height = oldHeight;
+        pScreen->mmWidth = oldmmWidth;
+        pScreen->mmHeight = oldmmHeight;
         scrp->currentMode = currentMode;
     }
 
@@ -567,182 +565,169 @@ xf86RandR12SetMode (ScreenPtr	    pScreen,
     /*
      * Make sure the whole screen is visible
      */
-    xf86SetViewport (pScreen, pScreen->width, pScreen->height);
-    xf86SetViewport (pScreen, 0, 0);
+    xf86SetViewport(pScreen, pScreen->width, pScreen->height);
+    xf86SetViewport(pScreen, 0, 0);
     if (pRoot)
-	(*scrp->EnableDisableFBAccess) (pScreen->myNum, TRUE);
+        (*scrp->EnableDisableFBAccess) (pScreen->myNum, TRUE);
     return ret;
 }
 
 Bool
-xf86RandR12SetConfig (ScreenPtr		pScreen,
-		    Rotation		rotation,
-		    int			rate,
-		    RRScreenSizePtr	pSize)
+xf86RandR12SetConfig(ScreenPtr pScreen,
+                     Rotation rotation, int rate, RRScreenSizePtr pSize)
 {
-    ScrnInfoPtr		scrp = XF86SCRNINFO(pScreen);
-    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
-    DisplayModePtr	mode;
-    int			pos[MAXDEVICES][2];
-    Bool		useVirtual = FALSE;
-    int			maxX = 0, maxY = 0;
-    Rotation		oldRotation = randrp->rotation;
-    DeviceIntPtr	dev;
-    Bool		view_adjusted = FALSE;
+    ScrnInfoPtr scrp = XF86SCRNINFO(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    DisplayModePtr mode;
+    int pos[MAXDEVICES][2];
+    Bool useVirtual = FALSE;
+    int maxX = 0, maxY = 0;
+    Rotation oldRotation = randrp->rotation;
+    DeviceIntPtr dev;
+    Bool view_adjusted = FALSE;
 
     randrp->rotation = rotation;
 
-    if (randrp->virtualX == -1 || randrp->virtualY == -1)
-    {
-	randrp->virtualX = scrp->virtualX;
-	randrp->virtualY = scrp->virtualY;
+    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
+        randrp->virtualX = scrp->virtualX;
+        randrp->virtualY = scrp->virtualY;
     }
 
-    for (dev = inputInfo.devices; dev; dev = dev->next)
-    {
-	if (!IsMaster(dev) && !IsFloating(dev))
-		continue;
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+        if (!IsMaster(dev) && !IsFloating(dev))
+            continue;
 
-	miPointerGetPosition(dev, &pos[dev->id][0], &pos[dev->id][1]);
+        miPointerGetPosition(dev, &pos[dev->id][0], &pos[dev->id][1]);
     }
 
-    for (mode = scrp->modes; ; mode = mode->next)
-    {
-	if (randrp->maxX == 0 || randrp->maxY == 0)
-	{
-		if (maxX < mode->HDisplay)
-			maxX = mode->HDisplay;
-		if (maxY < mode->VDisplay)
-			maxY = mode->VDisplay;
-	}
-	if (mode->HDisplay == pSize->width &&
-	    mode->VDisplay == pSize->height &&
-	    (rate == 0 || xf86RandR12ModeRefresh (mode) == rate))
-	    break;
-	if (mode->next == scrp->modes)
-	{
-	    if (pSize->width == randrp->virtualX &&
-		pSize->height == randrp->virtualY)
-	    {
-		mode = scrp->modes;
-		useVirtual = TRUE;
-		break;
-	    }
-    	    if (randrp->maxX == 0 || randrp->maxY == 0)
-    	    {
-		randrp->maxX = maxX;
-		randrp->maxY = maxY;
-    	    }
-	    return FALSE;
-	}
+    for (mode = scrp->modes;; mode = mode->next) {
+        if (randrp->maxX == 0 || randrp->maxY == 0) {
+            if (maxX < mode->HDisplay)
+                maxX = mode->HDisplay;
+            if (maxY < mode->VDisplay)
+                maxY = mode->VDisplay;
+        }
+        if (mode->HDisplay == pSize->width &&
+            mode->VDisplay == pSize->height &&
+            (rate == 0 || xf86RandR12ModeRefresh(mode) == rate))
+            break;
+        if (mode->next == scrp->modes) {
+            if (pSize->width == randrp->virtualX &&
+                pSize->height == randrp->virtualY) {
+                mode = scrp->modes;
+                useVirtual = TRUE;
+                break;
+            }
+            if (randrp->maxX == 0 || randrp->maxY == 0) {
+                randrp->maxX = maxX;
+                randrp->maxY = maxY;
+            }
+            return FALSE;
+        }
     }
 
-    if (randrp->maxX == 0 || randrp->maxY == 0)
-    {
-	randrp->maxX = maxX;
-	randrp->maxY = maxY;
+    if (randrp->maxX == 0 || randrp->maxY == 0) {
+        randrp->maxX = maxX;
+        randrp->maxY = maxY;
     }
 
-    if (!xf86RandR12SetMode (pScreen, mode, useVirtual, pSize->mmWidth,
-			   pSize->mmHeight)) {
+    if (!xf86RandR12SetMode(pScreen, mode, useVirtual, pSize->mmWidth,
+                            pSize->mmHeight)) {
         randrp->rotation = oldRotation;
-	return FALSE;
+        return FALSE;
     }
 
     /*
      * Move the cursor back where it belongs; SwitchMode repositions it
      * FIXME: duplicated code, see modes/xf86RandR12.c
      */
-    for (dev = inputInfo.devices; dev; dev = dev->next)
-    {
-	if (!IsMaster(dev) && !IsFloating(dev))
-		continue;
-
-	if (pScreen == miPointerGetScreen(dev)) {
-	    int px = pos[dev->id][0];
-	    int py = pos[dev->id][1];
-
-	    px = (px >= pScreen->width ? (pScreen->width - 1) : px);
-	    py = (py >= pScreen->height ? (pScreen->height - 1) : py);
-
-	    /* Setting the viewpoint makes only sense on one device */
-	    if (!view_adjusted && IsMaster(dev)) {
-		xf86SetViewport(pScreen, px, py);
-		view_adjusted = TRUE;
-	    }
-
-	    (*pScreen->SetCursorPosition) (dev, pScreen, px, py, FALSE);
-	}
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+        if (!IsMaster(dev) && !IsFloating(dev))
+            continue;
+
+        if (pScreen == miPointerGetScreen(dev)) {
+            int px = pos[dev->id][0];
+            int py = pos[dev->id][1];
+
+            px = (px >= pScreen->width ? (pScreen->width - 1) : px);
+            py = (py >= pScreen->height ? (pScreen->height - 1) : py);
+
+            /* Setting the viewpoint makes only sense on one device */
+            if (!view_adjusted && IsMaster(dev)) {
+                xf86SetViewport(pScreen, px, py);
+                view_adjusted = TRUE;
+            }
+
+            (*pScreen->SetCursorPosition) (dev, pScreen, px, py, FALSE);
+        }
     }
 
     return TRUE;
 }
 
 static Bool
-xf86RandR12ScreenSetSize (ScreenPtr	pScreen,
-			CARD16		width,
-			CARD16		height,
-			CARD32		mmWidth,
-			CARD32		mmHeight)
+xf86RandR12ScreenSetSize(ScreenPtr pScreen,
+                         CARD16 width,
+                         CARD16 height, CARD32 mmWidth, CARD32 mmHeight)
 {
-    XF86RandRInfoPtr	randrp = XF86RANDRINFO(pScreen);
-    ScrnInfoPtr		pScrn = XF86SCRNINFO(pScreen);
-    xf86CrtcConfigPtr	config = XF86_CRTC_CONFIG_PTR(pScrn);
-    WindowPtr		pRoot = pScreen->root;
-    PixmapPtr		pScrnPix;
-    Bool		ret = FALSE;
-    int                 c;
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen);
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    WindowPtr pRoot = pScreen->root;
+    PixmapPtr pScrnPix;
+    Bool ret = FALSE;
+    int c;
 
     if (xf86RandR12Key) {
-        if (randrp->virtualX == -1 || randrp->virtualY == -1)
-        {
-	    randrp->virtualX = pScrn->virtualX;
-	    randrp->virtualY = pScrn->virtualY;
+        if (randrp->virtualX == -1 || randrp->virtualY == -1) {
+            randrp->virtualX = pScrn->virtualX;
+            randrp->virtualY = pScrn->virtualY;
         }
     }
     if (pRoot && pScrn->vtSema)
-	(*pScrn->EnableDisableFBAccess) (pScreen->myNum, FALSE);
+        (*pScrn->EnableDisableFBAccess) (pScreen->myNum, FALSE);
 
     /* Let the driver update virtualX and virtualY */
-    if (!(*config->funcs->resize)(pScrn, width, height))
-	goto finish;
+    if (!(*config->funcs->resize) (pScrn, width, height))
+        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);
-	}
+        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);
+        }
     }
 
-    pScrnPix = (*pScreen->GetScreenPixmap)(pScreen);
+    pScrnPix = (*pScreen->GetScreenPixmap) (pScreen);
     pScreen->width = pScrnPix->drawable.width = width;
     pScreen->height = pScrnPix->drawable.height = height;
     randrp->mmWidth = pScreen->mmWidth = mmWidth;
     randrp->mmHeight = pScreen->mmHeight = mmHeight;
 
-    xf86SetViewport (pScreen, pScreen->width-1, pScreen->height-1);
-    xf86SetViewport (pScreen, 0, 0);
+    xf86SetViewport(pScreen, pScreen->width - 1, pScreen->height - 1);
+    xf86SetViewport(pScreen, 0, 0);
 
-finish:
+ finish:
     update_desktop_dimensions();
 
     if (pRoot && pScrn->vtSema)
-	(*pScrn->EnableDisableFBAccess) (pScreen->myNum, TRUE);
+        (*pScrn->EnableDisableFBAccess) (pScreen->myNum, TRUE);
 #if RANDR_12_INTERFACE
     if (xf86RandR12Key && pScreen->root && ret)
-	RRScreenSizeNotify (pScreen);
+        RRScreenSizeNotify(pScreen);
 #endif
     return ret;
 }
@@ -750,24 +735,25 @@ finish:
 Rotation
 xf86RandR12GetRotation(ScreenPtr pScreen)
 {
-    XF86RandRInfoPtr	    randrp = XF86RANDRINFO(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
 
     return randrp->rotation;
 }
 
 Bool
-xf86RandR12CreateScreenResources (ScreenPtr pScreen)
+xf86RandR12CreateScreenResources(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config;
-    XF86RandRInfoPtr	randrp;
-    int			c;
-    int			width, height;
-    int			mmWidth, mmHeight;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config;
+    XF86RandRInfoPtr randrp;
+    int c;
+    int width, height;
+    int mmWidth, mmHeight;
+
 #ifdef PANORAMIX
     /* XXX disable RandR when using Xinerama */
     if (!noPanoramiXExtension)
-	return TRUE;
+        return TRUE;
 #endif
 
     config = XF86_CRTC_CONFIG_PTR(pScrn);
@@ -775,103 +761,91 @@ xf86RandR12CreateScreenResources (ScreenPtr pScreen)
     /*
      * Compute size of screen
      */
-    width = 0; height = 0;
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86CrtcPtr crtc = config->crtc[c];
-	int	    crtc_width = crtc->x + xf86ModeWidth (&crtc->mode, crtc->rotation);
-	int	    crtc_height = crtc->y + xf86ModeHeight (&crtc->mode, crtc->rotation);
-	
-	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;
-	}
+    width = 0;
+    height = 0;
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
+        int crtc_width = crtc->x + xf86ModeWidth(&crtc->mode, crtc->rotation);
+        int crtc_height = crtc->y + xf86ModeHeight(&crtc->mode, crtc->rotation);
+
+        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)
-    {
-	/*
-	 * Compute physical size of screen
-	 */
-	if (monitorResolution) 
-	{
-	    mmWidth = width * 25.4 / monitorResolution;
-	    mmHeight = height * 25.4 / monitorResolution;
-	}
-	else
-	{
-	    xf86OutputPtr   output = xf86CompatOutput(pScrn);
-
-	    if (output &&
-		output->conf_monitor &&
-		(output->conf_monitor->mon_width  > 0 &&
-		 output->conf_monitor->mon_height > 0))
-	    {
-		/*
-		 * Prefer user configured DisplaySize
-		 */
-		mmWidth = output->conf_monitor->mon_width;
-		mmHeight = output->conf_monitor->mon_height;
-	    }
-	    else
-	    {
-		/*
-		 * Otherwise, just set the screen to DEFAULT_DPI
-		 */
-		mmWidth = width * 25.4 / DEFAULT_DPI;
-		mmHeight = height * 25.4 / DEFAULT_DPI;
-	    }
-	}
-	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,
-				  mmWidth,
-				  mmHeight);
+
+    if (width && height) {
+        /*
+         * Compute physical size of screen
+         */
+        if (monitorResolution) {
+            mmWidth = width * 25.4 / monitorResolution;
+            mmHeight = height * 25.4 / monitorResolution;
+        }
+        else {
+            xf86OutputPtr output = xf86CompatOutput(pScrn);
+
+            if (output &&
+                output->conf_monitor &&
+                (output->conf_monitor->mon_width > 0 &&
+                 output->conf_monitor->mon_height > 0)) {
+                /*
+                 * Prefer user configured DisplaySize
+                 */
+                mmWidth = output->conf_monitor->mon_width;
+                mmHeight = output->conf_monitor->mon_height;
+            }
+            else {
+                /*
+                 * Otherwise, just set the screen to DEFAULT_DPI
+                 */
+                mmWidth = width * 25.4 / DEFAULT_DPI;
+                mmHeight = height * 25.4 / DEFAULT_DPI;
+            }
+        }
+        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, mmWidth, mmHeight);
     }
 
     if (xf86RandR12Key == NULL)
-	return TRUE;
+        return TRUE;
 
-    if (randrp->virtualX == -1 || randrp->virtualY == -1)
-    {
-	randrp->virtualX = pScrn->virtualX;
-	randrp->virtualY = pScrn->virtualY;
+    if (randrp->virtualX == -1 || randrp->virtualY == -1) {
+        randrp->virtualX = pScrn->virtualX;
+        randrp->virtualY = pScrn->virtualY;
     }
-    xf86CrtcSetScreenSubpixelOrder (pScreen);
+    xf86CrtcSetScreenSubpixelOrder(pScreen);
 #if RANDR_12_INTERFACE
-    if (xf86RandR12CreateScreenResources12 (pScreen))
-	return TRUE;
+    if (xf86RandR12CreateScreenResources12(pScreen))
+        return TRUE;
 #endif
     return TRUE;
 }
 
-
 Bool
-xf86RandR12Init (ScreenPtr pScreen)
+xf86RandR12Init(ScreenPtr pScreen)
 {
-    rrScrPrivPtr	rp;
-    XF86RandRInfoPtr	randrp;
+    rrScrPrivPtr rp;
+    XF86RandRInfoPtr randrp;
 
 #ifdef PANORAMIX
     /* XXX disable RandR when using Xinerama */
-    if (!noPanoramiXExtension)
-    {
+    if (!noPanoramiXExtension) {
         if (xf86NumScreens == 1)
             noPanoramiXExtension = TRUE;
         else
@@ -880,20 +854,19 @@ xf86RandR12Init (ScreenPtr pScreen)
 #endif
 
     if (xf86RandR12Generation != serverGeneration)
-	xf86RandR12Generation = serverGeneration;
+        xf86RandR12Generation = serverGeneration;
 
     xf86RandR12Key = &xf86RandR12KeyRec;
     if (!dixRegisterPrivateKey(&xf86RandR12KeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
+        return FALSE;
 
-    randrp = malloc(sizeof (XF86RandRInfoRec));
+    randrp = malloc(sizeof(XF86RandRInfoRec));
     if (!randrp)
-	return FALSE;
+        return FALSE;
 
-    if (!RRScreenInit(pScreen))
-    {
-	free(randrp);
-	return FALSE;
+    if (!RRScreenInit(pScreen)) {
+        free(randrp);
+        return FALSE;
     }
     rp = rrGetScrPriv(pScreen);
     rp->rrGetInfo = xf86RandR12GetInfo;
@@ -904,7 +877,7 @@ xf86RandR12Init (ScreenPtr pScreen)
     randrp->mmWidth = pScreen->mmWidth;
     randrp->mmHeight = pScreen->mmHeight;
 
-    randrp->rotation = RR_Rotate_0; /* initial rotated mode */
+    randrp->rotation = RR_Rotate_0;     /* initial rotated mode */
 
     randrp->supported_rotations = RR_Rotate_0;
 
@@ -913,19 +886,19 @@ xf86RandR12Init (ScreenPtr pScreen)
     dixSetPrivate(&pScreen->devPrivates, xf86RandR12Key, randrp);
 
 #if RANDR_12_INTERFACE
-    if (!xf86RandR12Init12 (pScreen))
-	return FALSE;
+    if (!xf86RandR12Init12(pScreen))
+        return FALSE;
 #endif
     return TRUE;
 }
 
 void
-xf86RandR12CloseScreen (ScreenPtr pScreen)
+xf86RandR12CloseScreen(ScreenPtr pScreen)
 {
-    XF86RandRInfoPtr	randrp;
+    XF86RandRInfoPtr randrp;
 
     if (xf86RandR12Key == NULL)
-	return;
+        return;
 
     randrp = XF86RANDRINFO(pScreen);
 #if RANDR_12_INTERFACE
@@ -936,48 +909,50 @@ xf86RandR12CloseScreen (ScreenPtr pScreen)
 }
 
 void
-xf86RandR12SetRotations (ScreenPtr pScreen, Rotation rotations)
+xf86RandR12SetRotations(ScreenPtr pScreen, Rotation rotations)
 {
-    XF86RandRInfoPtr	randrp;
+    XF86RandRInfoPtr randrp;
+
 #if RANDR_12_INTERFACE
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    int			c;
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    int c;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 #endif
 
     if (xf86RandR12Key == NULL)
-	return;
+        return;
 
     randrp = XF86RANDRINFO(pScreen);
 #if RANDR_12_INTERFACE
     for (c = 0; c < config->num_crtc; c++) {
-	xf86CrtcPtr    crtc = config->crtc[c];
+        xf86CrtcPtr crtc = config->crtc[c];
 
-	RRCrtcSetRotations (crtc->randr_crtc, rotations);
+        RRCrtcSetRotations(crtc->randr_crtc, rotations);
     }
 #endif
     randrp->supported_rotations = rotations;
 }
 
 void
-xf86RandR12SetTransformSupport (ScreenPtr pScreen, Bool transforms)
+xf86RandR12SetTransformSupport(ScreenPtr pScreen, Bool transforms)
 {
-    XF86RandRInfoPtr	randrp;
+    XF86RandRInfoPtr randrp;
+
 #if RANDR_13_INTERFACE
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    int			c;
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    int c;
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 #endif
 
     if (xf86RandR12Key == NULL)
-	return;
+        return;
 
     randrp = XF86RANDRINFO(pScreen);
 #if RANDR_13_INTERFACE
     for (c = 0; c < config->num_crtc; c++) {
-	xf86CrtcPtr    crtc = config->crtc[c];
+        xf86CrtcPtr crtc = config->crtc[c];
 
-	RRCrtcSetTransformSupport (crtc->randr_crtc, transforms);
+        RRCrtcSetTransformSupport(crtc->randr_crtc, transforms);
     }
 #endif
 }
@@ -988,15 +963,15 @@ xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn, int *x, int *y)
     ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
 
     if (xf86RandR12Generation != serverGeneration ||
-	XF86RANDRINFO(pScreen)->virtualX == -1)
-    {
-	*x = pScrn->virtualX;
-	*y = pScrn->virtualY;
-    } else {
-	XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
-
-	*x = randrp->virtualX;
-	*y = randrp->virtualY;
+        XF86RANDRINFO(pScreen)->virtualX == -1) {
+        *x = pScrn->virtualX;
+        *y = pScrn->virtualY;
+    }
+    else {
+        XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+
+        *x = randrp->virtualX;
+        *y = randrp->virtualY;
     }
 }
 
@@ -1018,95 +993,106 @@ xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn, int *x, int *y)
 		   RR_ClockDivideBy2)
 
 static Bool
-xf86RandRModeMatches (RRModePtr		randr_mode,
-		      DisplayModePtr	mode)
+xf86RandRModeMatches(RRModePtr randr_mode, DisplayModePtr mode)
 {
 #if 0
-    if (match_name)
-    {
-	/* check for same name */
-	int	len = strlen (mode->name);
-	if (randr_mode->mode.nameLength != len)			return FALSE;
-	if (memcmp (randr_mode->name, mode->name, len) != 0)	return FALSE;
+    if (match_name) {
+        /* check for same name */
+        int len = strlen(mode->name);
+
+        if (randr_mode->mode.nameLength != len)
+            return FALSE;
+        if (memcmp(randr_mode->name, mode->name, len) != 0)
+            return FALSE;
     }
 #endif
-    
+
     /* check for same timings */
-    if (randr_mode->mode.dotClock / 1000 != mode->Clock)    return FALSE;
-    if (randr_mode->mode.width        != mode->HDisplay)    return FALSE;
-    if (randr_mode->mode.hSyncStart   != mode->HSyncStart)  return FALSE;
-    if (randr_mode->mode.hSyncEnd     != mode->HSyncEnd)    return FALSE;
-    if (randr_mode->mode.hTotal       != mode->HTotal)	    return FALSE;
-    if (randr_mode->mode.hSkew        != mode->HSkew)	    return FALSE;
-    if (randr_mode->mode.height       != mode->VDisplay)    return FALSE;
-    if (randr_mode->mode.vSyncStart   != mode->VSyncStart)  return FALSE;
-    if (randr_mode->mode.vSyncEnd     != mode->VSyncEnd)    return FALSE;
-    if (randr_mode->mode.vTotal       != mode->VTotal)	    return FALSE;
-    
+    if (randr_mode->mode.dotClock / 1000 != mode->Clock)
+        return FALSE;
+    if (randr_mode->mode.width != mode->HDisplay)
+        return FALSE;
+    if (randr_mode->mode.hSyncStart != mode->HSyncStart)
+        return FALSE;
+    if (randr_mode->mode.hSyncEnd != mode->HSyncEnd)
+        return FALSE;
+    if (randr_mode->mode.hTotal != mode->HTotal)
+        return FALSE;
+    if (randr_mode->mode.hSkew != mode->HSkew)
+        return FALSE;
+    if (randr_mode->mode.height != mode->VDisplay)
+        return FALSE;
+    if (randr_mode->mode.vSyncStart != mode->VSyncStart)
+        return FALSE;
+    if (randr_mode->mode.vSyncEnd != mode->VSyncEnd)
+        return FALSE;
+    if (randr_mode->mode.vTotal != mode->VTotal)
+        return FALSE;
+
     /* check for same flags (using only the XF86 valid flag bits) */
     if ((randr_mode->mode.modeFlags & FLAG_BITS) != (mode->Flags & FLAG_BITS))
-	return FALSE;
-    
+        return FALSE;
+
     /* everything matches */
     return TRUE;
 }
 
 static Bool
-xf86RandR12CrtcNotify (RRCrtcPtr	randr_crtc)
+xf86RandR12CrtcNotify(RRCrtcPtr randr_crtc)
 {
-    ScreenPtr		pScreen = randr_crtc->pScreen;
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    RRModePtr		randr_mode = NULL;
-    int			x;
-    int			y;
-    Rotation		rotation;
-    int			numOutputs;
-    RROutputPtr		*randr_outputs;
-    RROutputPtr		randr_output;
-    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
-    xf86OutputPtr	output;
-    int			i, j;
-    DisplayModePtr	mode = &crtc->mode;
-    Bool		ret;
-
-    randr_outputs = malloc(config->num_output * sizeof (RROutputPtr));
+    ScreenPtr pScreen = randr_crtc->pScreen;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    RRModePtr randr_mode = NULL;
+    int x;
+    int y;
+    Rotation rotation;
+    int numOutputs;
+    RROutputPtr *randr_outputs;
+    RROutputPtr randr_output;
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
+    xf86OutputPtr output;
+    int i, j;
+    DisplayModePtr mode = &crtc->mode;
+    Bool ret;
+
+    randr_outputs = malloc(config->num_output * sizeof(RROutputPtr));
     if (!randr_outputs)
-	return FALSE;
+        return FALSE;
     x = crtc->x;
     y = crtc->y;
     rotation = crtc->rotation;
     numOutputs = 0;
     randr_mode = NULL;
-    for (i = 0; i < config->num_output; i++)
-    {
-	output = config->output[i];
-	if (output->crtc == crtc)
-	{
-	    randr_output = output->randr_output;
-	    randr_outputs[numOutputs++] = randr_output;
-	    /*
-	     * We make copies of modes, so pointer equality 
-	     * isn't sufficient
-	     */
-	    for (j = 0; j < randr_output->numModes + randr_output->numUserModes; j++)
-	    {
-		RRModePtr   m = (j < randr_output->numModes ?
-				 randr_output->modes[j] :
-				 randr_output->userModes[j-randr_output->numModes]);
-					 
-		if (xf86RandRModeMatches (m, mode))
-		{
-		    randr_mode = m;
-		    break;
-		}
-	    }
-	}
+    for (i = 0; i < config->num_output; i++) {
+        output = config->output[i];
+        if (output->crtc == crtc) {
+            randr_output = output->randr_output;
+            randr_outputs[numOutputs++] = randr_output;
+            /*
+             * We make copies of modes, so pointer equality 
+             * isn't sufficient
+             */
+            for (j = 0; j < randr_output->numModes + randr_output->numUserModes;
+                 j++) {
+                RRModePtr m =
+                    (j <
+                     randr_output->numModes ? randr_output->
+                     modes[j] : randr_output->userModes[j -
+                                                        randr_output->
+                                                        numModes]);
+
+                if (xf86RandRModeMatches(m, mode)) {
+                    randr_mode = m;
+                    break;
+                }
+            }
+        }
     }
-    ret = RRCrtcNotify (randr_crtc, randr_mode, x, y,
-			rotation, 
-			crtc->transformPresent ? &crtc->transform : NULL,
-			numOutputs, randr_outputs);
+    ret = RRCrtcNotify(randr_crtc, randr_mode, x, y,
+                       rotation,
+                       crtc->transformPresent ? &crtc->transform : NULL,
+                       numOutputs, randr_outputs);
     free(randr_outputs);
     return ret;
 }
@@ -1115,21 +1101,20 @@ xf86RandR12CrtcNotify (RRCrtcPtr	randr_crtc)
  * Convert a RandR mode to a DisplayMode
  */
 static void
-xf86RandRModeConvert (ScrnInfoPtr	scrn,
-		      RRModePtr		randr_mode,
-		      DisplayModePtr	mode)
+xf86RandRModeConvert(ScrnInfoPtr scrn,
+                     RRModePtr randr_mode, DisplayModePtr mode)
 {
     memset(mode, 0, sizeof(DisplayModeRec));
     mode->status = MODE_OK;
 
     mode->Clock = randr_mode->mode.dotClock / 1000;
-    
+
     mode->HDisplay = randr_mode->mode.width;
     mode->HSyncStart = randr_mode->mode.hSyncStart;
     mode->HSyncEnd = randr_mode->mode.hSyncEnd;
     mode->HTotal = randr_mode->mode.hTotal;
     mode->HSkew = randr_mode->mode.hSkew;
-    
+
     mode->VDisplay = randr_mode->mode.height;
     mode->VSyncStart = randr_mode->mode.vSyncStart;
     mode->VSyncEnd = randr_mode->mode.vSyncEnd;
@@ -1138,137 +1123,134 @@ xf86RandRModeConvert (ScrnInfoPtr	scrn,
 
     mode->Flags = randr_mode->mode.modeFlags & FLAG_BITS;
 
-    xf86SetModeCrtc (mode, scrn->adjustFlags);
+    xf86SetModeCrtc(mode, scrn->adjustFlags);
 }
 
 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;
-    Bool		save_enabled = crtc->enabled;
+    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;
+    Bool save_enabled = crtc->enabled;
 
     if (!crtc->scrn->vtSema)
-	return FALSE;
+        return FALSE;
 
-    save_crtcs = malloc(config->num_output * sizeof (xf86CrtcPtr));
+    save_crtcs = malloc(config->num_output * sizeof(xf86CrtcPtr));
     if ((randr_mode != NULL) != crtc->enabled)
-	changed = TRUE;
-    else if (randr_mode && !xf86RandRModeMatches (randr_mode, &crtc->mode))
-	changed = TRUE;
-    
+        changed = TRUE;
+    else if (randr_mode && !xf86RandRModeMatches(randr_mode, &crtc->mode))
+        changed = TRUE;
+
     if (rotation != crtc->rotation)
-	changed = TRUE;
+        changed = TRUE;
 
-    transform = RRCrtcGetTransform (randr_crtc);
+    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;
+        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++) 
-    {
-	xf86OutputPtr  output = config->output[o];
-	xf86CrtcPtr    new_crtc;
-
-	save_crtcs[o] = output->crtc;
-	
-	if (output->crtc == crtc)
-	    new_crtc = NULL;
-	else
-	    new_crtc = output->crtc;
-	for (ro = 0; ro < num_randr_outputs; ro++) 
-	    if (output->randr_output == randr_outputs[ro])
-	    {
-		new_crtc = crtc;
-		break;
-	    }
-	if (new_crtc != output->crtc)
-	{
-	    changed = TRUE;
-	    output->crtc = new_crtc;
-	}
+        changed = TRUE;
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+        xf86CrtcPtr new_crtc;
+
+        save_crtcs[o] = output->crtc;
+
+        if (output->crtc == crtc)
+            new_crtc = NULL;
+        else
+            new_crtc = output->crtc;
+        for (ro = 0; ro < num_randr_outputs; ro++)
+            if (output->randr_output == randr_outputs[ro]) {
+                new_crtc = crtc;
+                break;
+            }
+        if (new_crtc != output->crtc) {
+            changed = TRUE;
+            output->crtc = new_crtc;
+        }
     }
-    for (ro = 0; ro < num_randr_outputs; ro++) 
+    for (ro = 0; ro < num_randr_outputs; ro++)
         if (randr_outputs[ro]->pendingProperties)
-	    changed = TRUE;
+            changed = TRUE;
 
     /* XXX need device-independent mode setting code through an API */
-    if (changed)
-    {
-	crtc->enabled = randr_mode != NULL;
-
-	if (randr_mode)
-	{
-	    DisplayModeRec  mode;
-	    RRTransformPtr  transform = RRCrtcGetTransform (randr_crtc);
-
-	    xf86RandRModeConvert (pScrn, randr_mode, &mode);
-	    if (!xf86CrtcSetModeTransform (crtc, &mode, rotation, transform, x, y))
-	    {
-		crtc->enabled = save_enabled;
-		for (o = 0; o < config->num_output; o++)
-		{
-		    xf86OutputPtr	output = config->output[o];
-		    output->crtc = save_crtcs[o];
-		}
-		free(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;
-	}
-	xf86DisableUnusedFunctions (pScrn);
+    if (changed) {
+        crtc->enabled = randr_mode != NULL;
+
+        if (randr_mode) {
+            DisplayModeRec mode;
+            RRTransformPtr transform = RRCrtcGetTransform(randr_crtc);
+
+            xf86RandRModeConvert(pScrn, randr_mode, &mode);
+            if (!xf86CrtcSetModeTransform
+                (crtc, &mode, rotation, transform, x, y)) {
+                crtc->enabled = save_enabled;
+                for (o = 0; o < config->num_output; o++) {
+                    xf86OutputPtr output = config->output[o];
+
+                    output->crtc = save_crtcs[o];
+                }
+                free(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;
+        }
+        xf86DisableUnusedFunctions(pScrn);
     }
     free(save_crtcs);
-    return xf86RandR12CrtcNotify (randr_crtc);
+    return xf86RandR12CrtcNotify(randr_crtc);
 }
 
 static Bool
-xf86RandR12CrtcSetGamma (ScreenPtr    pScreen,
-			 RRCrtcPtr    randr_crtc)
+xf86RandR12CrtcSetGamma(ScreenPtr pScreen, RRCrtcPtr randr_crtc)
 {
-    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
 
     if (crtc->funcs->gamma_set == NULL)
-	return FALSE;
+        return FALSE;
 
     if (!crtc->scrn->vtSema)
-	return TRUE;
+        return TRUE;
 
     /* Realloc local gamma if needed. */
     if (randr_crtc->gammaSize != crtc->gamma_size) {
         CARD16 *tmp_ptr;
-        tmp_ptr = realloc(crtc->gamma_red, 3 * crtc->gamma_size * sizeof (CARD16));
+
+        tmp_ptr =
+            realloc(crtc->gamma_red, 3 * crtc->gamma_size * sizeof(CARD16));
         if (!tmp_ptr)
             return FALSE;
         crtc->gamma_red = tmp_ptr;
@@ -1277,23 +1259,25 @@ xf86RandR12CrtcSetGamma (ScreenPtr    pScreen,
     }
 
     crtc->gamma_size = randr_crtc->gammaSize;
-    memcpy (crtc->gamma_red, randr_crtc->gammaRed, crtc->gamma_size * sizeof (CARD16));
-    memcpy (crtc->gamma_green, randr_crtc->gammaGreen, crtc->gamma_size * sizeof (CARD16));
-    memcpy (crtc->gamma_blue, randr_crtc->gammaBlue, crtc->gamma_size * sizeof (CARD16));
+    memcpy(crtc->gamma_red, randr_crtc->gammaRed,
+           crtc->gamma_size * sizeof(CARD16));
+    memcpy(crtc->gamma_green, randr_crtc->gammaGreen,
+           crtc->gamma_size * sizeof(CARD16));
+    memcpy(crtc->gamma_blue, randr_crtc->gammaBlue,
+           crtc->gamma_size * sizeof(CARD16));
 
     /* Only set it when the crtc is actually running.
      * Otherwise it will be set when it's activated.
      */
     if (crtc->active)
-	crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
-						crtc->gamma_blue, crtc->gamma_size);
+        crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
+                               crtc->gamma_blue, crtc->gamma_size);
 
     return TRUE;
 }
 
 static Bool
-xf86RandR12CrtcGetGamma (ScreenPtr    pScreen,
-			 RRCrtcPtr    randr_crtc)
+xf86RandR12CrtcGetGamma(ScreenPtr pScreen, RRCrtcPtr randr_crtc)
 {
     xf86CrtcPtr crtc = randr_crtc->devPrivate;
 
@@ -1306,7 +1290,10 @@ xf86RandR12CrtcGetGamma (ScreenPtr    pScreen,
     /* Realloc randr gamma if needed. */
     if (randr_crtc->gammaSize != crtc->gamma_size) {
         CARD16 *tmp_ptr;
-        tmp_ptr = realloc(randr_crtc->gammaRed, 3 * crtc->gamma_size * sizeof (CARD16));
+
+        tmp_ptr =
+            realloc(randr_crtc->gammaRed,
+                    3 * crtc->gamma_size * sizeof(CARD16));
         if (!tmp_ptr)
             return FALSE;
         randr_crtc->gammaRed = tmp_ptr;
@@ -1314,18 +1301,20 @@ xf86RandR12CrtcGetGamma (ScreenPtr    pScreen,
         randr_crtc->gammaBlue = randr_crtc->gammaGreen + crtc->gamma_size;
     }
     randr_crtc->gammaSize = crtc->gamma_size;
-    memcpy (randr_crtc->gammaRed, crtc->gamma_red, crtc->gamma_size * sizeof (CARD16));
-    memcpy (randr_crtc->gammaGreen, crtc->gamma_green, crtc->gamma_size * sizeof (CARD16));
-    memcpy (randr_crtc->gammaBlue, crtc->gamma_blue, crtc->gamma_size * sizeof (CARD16));
+    memcpy(randr_crtc->gammaRed, crtc->gamma_red,
+           crtc->gamma_size * sizeof(CARD16));
+    memcpy(randr_crtc->gammaGreen, crtc->gamma_green,
+           crtc->gamma_size * sizeof(CARD16));
+    memcpy(randr_crtc->gammaBlue, crtc->gamma_blue,
+           crtc->gamma_size * sizeof(CARD16));
 
     return TRUE;
 }
 
 static Bool
-xf86RandR12OutputSetProperty (ScreenPtr pScreen,
-			      RROutputPtr randr_output,
-			      Atom property,
-			      RRPropertyValuePtr value)
+xf86RandR12OutputSetProperty(ScreenPtr pScreen,
+                             RROutputPtr randr_output,
+                             Atom property, RRPropertyValuePtr value)
 {
     xf86OutputPtr output = randr_output->devPrivate;
 
@@ -1333,7 +1322,7 @@ xf86RandR12OutputSetProperty (ScreenPtr pScreen,
      * user is setting properties to.
      */
     if (output->funcs->set_property == NULL)
-	return TRUE;
+        return TRUE;
 
     /*
      * This function gets called even when vtSema is FALSE, as
@@ -1344,41 +1333,39 @@ xf86RandR12OutputSetProperty (ScreenPtr pScreen,
 }
 
 static Bool
-xf86RandR13OutputGetProperty (ScreenPtr pScreen,
-			      RROutputPtr randr_output,
-			      Atom property)
+xf86RandR13OutputGetProperty(ScreenPtr pScreen,
+                             RROutputPtr randr_output, Atom property)
 {
     xf86OutputPtr output = randr_output->devPrivate;
 
     if (output->funcs->get_property == NULL)
-	return TRUE;
+        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)
+xf86RandR12OutputValidateMode(ScreenPtr pScreen,
+                              RROutputPtr randr_output, RRModePtr randr_mode)
 {
-    ScrnInfoPtr	    pScrn = xf86Screens[pScreen->myNum];
-    xf86OutputPtr   output = randr_output->devPrivate;
-    DisplayModeRec  mode;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86OutputPtr output = randr_output->devPrivate;
+    DisplayModeRec mode;
 
-    xf86RandRModeConvert (pScrn, randr_mode, &mode);
+    xf86RandRModeConvert(pScrn, randr_mode, &mode);
     /*
      * This function may be called when vtSema is FALSE, so
      * the underlying function must either avoid touching the hardware
      * or return FALSE when vtSema is FALSE
      */
-    if (output->funcs->mode_valid (output, &mode) != MODE_OK)
-	return FALSE;
+    if (output->funcs->mode_valid(output, &mode) != MODE_OK)
+        return FALSE;
     return TRUE;
 }
 
 static void
-xf86RandR12ModeDestroy (ScreenPtr pScreen, RRModePtr randr_mode)
+xf86RandR12ModeDestroy(ScreenPtr pScreen, RRModePtr randr_mode)
 {
 }
 
@@ -1387,56 +1374,56 @@ xf86RandR12ModeDestroy (ScreenPtr pScreen, RRModePtr randr_mode)
  * RandR modes and assign them to the output
  */
 static Bool
-xf86RROutputSetModes (RROutputPtr randr_output, DisplayModePtr modes)
+xf86RROutputSetModes(RROutputPtr randr_output, DisplayModePtr modes)
 {
-    DisplayModePtr  mode;
-    RRModePtr	    *rrmodes = NULL;
-    int		    nmode = 0;
-    int		    npreferred = 0;
-    Bool	    ret = TRUE;
-    int		    pref;
+    DisplayModePtr mode;
+    RRModePtr *rrmodes = NULL;
+    int nmode = 0;
+    int npreferred = 0;
+    Bool ret = TRUE;
+    int pref;
 
     for (mode = modes; mode; mode = mode->next)
-	nmode++;
+        nmode++;
 
     if (nmode) {
-	rrmodes = malloc(nmode * sizeof (RRModePtr));
-	
-	if (!rrmodes)
-	    return FALSE;
-	nmode = 0;
-
-	for (pref = 1; pref >= 0; pref--) {
-	    for (mode = modes; mode; mode = mode->next) {
-		if ((pref != 0) == ((mode->type & M_T_PREFERRED) != 0)) {
-		    xRRModeInfo		modeInfo;
-		    RRModePtr		rrmode;
-		    
-		    modeInfo.nameLength = strlen (mode->name);
-		    modeInfo.width = mode->HDisplay;
-		    modeInfo.dotClock = mode->Clock * 1000;
-		    modeInfo.hSyncStart = mode->HSyncStart;
-		    modeInfo.hSyncEnd = mode->HSyncEnd;
-		    modeInfo.hTotal = mode->HTotal;
-		    modeInfo.hSkew = mode->HSkew;
-
-		    modeInfo.height = mode->VDisplay;
-		    modeInfo.vSyncStart = mode->VSyncStart;
-		    modeInfo.vSyncEnd = mode->VSyncEnd;
-		    modeInfo.vTotal = mode->VTotal;
-		    modeInfo.modeFlags = mode->Flags;
-
-		    rrmode = RRModeGet (&modeInfo, mode->name);
-		    if (rrmode) {
-			rrmodes[nmode++] = rrmode;
-			npreferred += pref;
-		    }
-		}
-	    }
-	}
+        rrmodes = malloc(nmode * sizeof(RRModePtr));
+
+        if (!rrmodes)
+            return FALSE;
+        nmode = 0;
+
+        for (pref = 1; pref >= 0; pref--) {
+            for (mode = modes; mode; mode = mode->next) {
+                if ((pref != 0) == ((mode->type & M_T_PREFERRED) != 0)) {
+                    xRRModeInfo modeInfo;
+                    RRModePtr rrmode;
+
+                    modeInfo.nameLength = strlen(mode->name);
+                    modeInfo.width = mode->HDisplay;
+                    modeInfo.dotClock = mode->Clock * 1000;
+                    modeInfo.hSyncStart = mode->HSyncStart;
+                    modeInfo.hSyncEnd = mode->HSyncEnd;
+                    modeInfo.hTotal = mode->HTotal;
+                    modeInfo.hSkew = mode->HSkew;
+
+                    modeInfo.height = mode->VDisplay;
+                    modeInfo.vSyncStart = mode->VSyncStart;
+                    modeInfo.vSyncEnd = mode->VSyncEnd;
+                    modeInfo.vTotal = mode->VTotal;
+                    modeInfo.modeFlags = mode->Flags;
+
+                    rrmode = RRModeGet(&modeInfo, mode->name);
+                    if (rrmode) {
+                        rrmodes[nmode++] = rrmode;
+                        npreferred += pref;
+                    }
+                }
+            }
+        }
     }
-    
-    ret = RROutputSetModes (randr_output, rrmodes, nmode, npreferred);
+
+    ret = RROutputSetModes(randr_output, rrmodes, nmode, npreferred);
     free(rrmodes);
     return ret;
 }
@@ -1445,154 +1432,144 @@ xf86RROutputSetModes (RROutputPtr randr_output, DisplayModePtr modes)
  * Mirror the current mode configuration to RandR
  */
 static Bool
-xf86RandR12SetInfo12 (ScreenPtr pScreen)
+xf86RandR12SetInfo12(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    RROutputPtr		*clones;
-    RRCrtcPtr		*crtcs;
-    int			ncrtc;
-    int			o, c, l;
-    RRCrtcPtr		randr_crtc;
-    int			nclone;
-    
-    clones = malloc(config->num_output * sizeof (RROutputPtr));
-    crtcs = malloc(config->num_crtc * sizeof (RRCrtcPtr));
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
-	
-	ncrtc = 0;
-	for (c = 0; c < config->num_crtc; c++)
-	    if (output->possible_crtcs & (1 << c))
-		crtcs[ncrtc++] = config->crtc[c]->randr_crtc;
-
-	if (output->crtc)
-	    randr_crtc = output->crtc->randr_crtc;
-	else
-	    randr_crtc = NULL;
-
-	if (!RROutputSetCrtcs (output->randr_output, crtcs, ncrtc))
-	{
-	    free(crtcs);
-	    free(clones);
-	    return FALSE;
-	}
-
-	RROutputSetPhysicalSize(output->randr_output, 
-				output->mm_width,
-				output->mm_height);
-	xf86RROutputSetModes (output->randr_output, output->probed_modes);
-
-	switch (output->status) {
-	case XF86OutputStatusConnected:
-	    RROutputSetConnection (output->randr_output, RR_Connected);
-	    break;
-	case XF86OutputStatusDisconnected:
-	    RROutputSetConnection (output->randr_output, RR_Disconnected);
-	    break;
-	case XF86OutputStatusUnknown:
-	    RROutputSetConnection (output->randr_output, RR_UnknownConnection);
-	    break;
-	}
-
-	RROutputSetSubpixelOrder (output->randr_output, output->subpixel_order);
-
-	/*
-	 * Valid clones
-	 */
-	nclone = 0;
-	for (l = 0; l < config->num_output; l++)
-	{
-	    xf86OutputPtr	    clone = config->output[l];
-	    
-	    if (l != o && (output->possible_clones & (1 << l)))
-		clones[nclone++] = clone->randr_output;
-	}
-	if (!RROutputSetClones (output->randr_output, clones, nclone))
-	{
-	    free(crtcs);
-	    free(clones);
-	    return FALSE;
-	}
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    RROutputPtr *clones;
+    RRCrtcPtr *crtcs;
+    int ncrtc;
+    int o, c, l;
+    RRCrtcPtr randr_crtc;
+    int nclone;
+
+    clones = malloc(config->num_output * sizeof(RROutputPtr));
+    crtcs = malloc(config->num_crtc * sizeof(RRCrtcPtr));
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
+
+        ncrtc = 0;
+        for (c = 0; c < config->num_crtc; c++)
+            if (output->possible_crtcs & (1 << c))
+                crtcs[ncrtc++] = config->crtc[c]->randr_crtc;
+
+        if (output->crtc)
+            randr_crtc = output->crtc->randr_crtc;
+        else
+            randr_crtc = NULL;
+
+        if (!RROutputSetCrtcs(output->randr_output, crtcs, ncrtc)) {
+            free(crtcs);
+            free(clones);
+            return FALSE;
+        }
+
+        RROutputSetPhysicalSize(output->randr_output,
+                                output->mm_width, output->mm_height);
+        xf86RROutputSetModes(output->randr_output, output->probed_modes);
+
+        switch (output->status) {
+        case XF86OutputStatusConnected:
+            RROutputSetConnection(output->randr_output, RR_Connected);
+            break;
+        case XF86OutputStatusDisconnected:
+            RROutputSetConnection(output->randr_output, RR_Disconnected);
+            break;
+        case XF86OutputStatusUnknown:
+            RROutputSetConnection(output->randr_output, RR_UnknownConnection);
+            break;
+        }
+
+        RROutputSetSubpixelOrder(output->randr_output, output->subpixel_order);
+
+        /*
+         * Valid clones
+         */
+        nclone = 0;
+        for (l = 0; l < config->num_output; l++) {
+            xf86OutputPtr clone = config->output[l];
+
+            if (l != o && (output->possible_clones & (1 << l)))
+                clones[nclone++] = clone->randr_output;
+        }
+        if (!RROutputSetClones(output->randr_output, clones, nclone)) {
+            free(crtcs);
+            free(clones);
+            return FALSE;
+        }
     }
     free(crtcs);
     free(clones);
     return TRUE;
 }
 
-
-
 /*
  * Query the hardware for the current state, then mirror
  * that to RandR
  */
 static Bool
-xf86RandR12GetInfo12 (ScreenPtr pScreen, Rotation *rotations)
+xf86RandR12GetInfo12(ScreenPtr pScreen, Rotation * rotations)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 
     if (!pScrn->vtSema)
-	return TRUE;
-    xf86ProbeOutputModes (pScrn, 0, 0);
-    xf86SetScrnInfoModes (pScrn);
-    return xf86RandR12SetInfo12 (pScreen);
+        return TRUE;
+    xf86ProbeOutputModes(pScrn, 0, 0);
+    xf86SetScrnInfoModes(pScrn);
+    return xf86RandR12SetInfo12(pScreen);
 }
 
 static Bool
-xf86RandR12CreateObjects12 (ScreenPtr pScreen)
+xf86RandR12CreateObjects12(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    int			c;
-    int			o;
-    
-    if (!RRInit ())
-	return FALSE;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
+    int o;
+
+    if (!RRInit())
+        return FALSE;
 
     /*
      * Configure crtcs
      */
-    for (c = 0; c < config->num_crtc; c++)
-    {
-	xf86CrtcPtr    crtc = config->crtc[c];
-	
-	crtc->randr_crtc = RRCrtcCreate (pScreen, crtc);
-	RRCrtcGammaSetSize (crtc->randr_crtc, 256);
+    for (c = 0; c < config->num_crtc; c++) {
+        xf86CrtcPtr crtc = config->crtc[c];
+
+        crtc->randr_crtc = RRCrtcCreate(pScreen, crtc);
+        RRCrtcGammaSetSize(crtc->randr_crtc, 256);
     }
     /*
      * Configure outputs
      */
-    for (o = 0; o < config->num_output; o++)
-    {
-	xf86OutputPtr	output = config->output[o];
+    for (o = 0; o < config->num_output; o++) {
+        xf86OutputPtr output = config->output[o];
 
-	output->randr_output = RROutputCreate (pScreen, output->name, 
-					       strlen (output->name),
-					       output);
+        output->randr_output = RROutputCreate(pScreen, output->name,
+                                              strlen(output->name), output);
 
-	if (output->funcs->create_resources != NULL)
-	    output->funcs->create_resources(output);
-	RRPostPendingProperties (output->randr_output);
+        if (output->funcs->create_resources != NULL)
+            output->funcs->create_resources(output);
+        RRPostPendingProperties(output->randr_output);
     }
     return TRUE;
 }
 
 static Bool
-xf86RandR12CreateScreenResources12 (ScreenPtr pScreen)
+xf86RandR12CreateScreenResources12(ScreenPtr pScreen)
 {
-    int			c;
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
 
     if (xf86RandR12Key == NULL)
-	return TRUE;
+        return TRUE;
 
     for (c = 0; c < config->num_crtc; c++)
-        xf86RandR12CrtcNotify (config->crtc[c]->randr_crtc);
-    
-    RRScreenSetSizeRange (pScreen, config->minWidth, config->minHeight,
-			  config->maxWidth, config->maxHeight);
+        xf86RandR12CrtcNotify(config->crtc[c]->randr_crtc);
+
+    RRScreenSetSizeRange(pScreen, config->minWidth, config->minHeight,
+                         config->maxWidth, config->maxHeight);
     return TRUE;
 }
 
@@ -1602,95 +1579,91 @@ xf86RandR12CreateScreenResources12 (ScreenPtr pScreen)
  */
 
 void
-xf86RandR12TellChanged (ScreenPtr pScreen)
+xf86RandR12TellChanged(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    xf86CrtcConfigPtr   config = XF86_CRTC_CONFIG_PTR(pScrn);
-    int			c;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+    int c;
 
     if (xf86RandR12Key == NULL)
-	return;
+        return;
 
-    xf86RandR12SetInfo12 (pScreen);
+    xf86RandR12SetInfo12(pScreen);
     for (c = 0; c < config->num_crtc; c++)
-	xf86RandR12CrtcNotify (config->crtc[c]->randr_crtc);
+        xf86RandR12CrtcNotify(config->crtc[c]->randr_crtc);
 
-    RRTellChanged (pScreen);
+    RRTellChanged(pScreen);
 }
 
 static void
-xf86RandR12PointerMoved (int scrnIndex, int x, int y)
+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);
+    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);
+        xf86RandR13Pan(config->crtc[c], x, y);
 }
 
 static Bool
-xf86RandR13GetPanning (ScreenPtr           pScreen,
-		       RRCrtcPtr           randr_crtc,
-		       BoxPtr              totalArea,
-		       BoxPtr              trackingArea,
-		       INT16               *border)
+xf86RandR13GetPanning(ScreenPtr pScreen,
+                      RRCrtcPtr randr_crtc,
+                      BoxPtr totalArea, BoxPtr trackingArea, INT16 *border)
 {
-    xf86CrtcPtr		crtc = randr_crtc->devPrivate;
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
 
     if (crtc->version < 2)
-	return FALSE;
+        return FALSE;
     if (totalArea)
-	memcpy (totalArea,    &crtc->panningTotalArea,    sizeof(BoxRec));
+        memcpy(totalArea, &crtc->panningTotalArea, sizeof(BoxRec));
     if (trackingArea)
-	memcpy (trackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
+        memcpy(trackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
     if (border)
-	memcpy (border,        crtc->panningBorder,       4*sizeof(INT16));
+        memcpy(border, crtc->panningBorder, 4 * sizeof(INT16));
 
     return TRUE;
 }
 
 static Bool
-xf86RandR13SetPanning (ScreenPtr           pScreen,
-		       RRCrtcPtr           randr_crtc,
-		       BoxPtr              totalArea,
-		       BoxPtr              trackingArea,
-		       INT16               *border)
+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];
-
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
+    BoxRec oldTotalArea;
+    BoxRec oldTrackingArea;
+    INT16 oldBorder[4];
 
     if (crtc->version < 2)
-	return FALSE;
+        return FALSE;
 
-    memcpy (&oldTotalArea,    &crtc->panningTotalArea,    sizeof(BoxRec));
-    memcpy (&oldTrackingArea, &crtc->panningTrackingArea, sizeof(BoxRec));
-    memcpy (oldBorder,         crtc->panningBorder,       4*sizeof(INT16));
+    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));
+        memcpy(&crtc->panningTotalArea, totalArea, sizeof(BoxRec));
     if (trackingArea)
-	memcpy (&crtc->panningTrackingArea, trackingArea, sizeof(BoxRec));
+        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;
+        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;
     }
 }
 
@@ -1705,11 +1678,12 @@ gamma_to_ramp(float gamma, CARD16 *ramp, int size)
     int i;
 
     for (i = 0; i < size; i++) {
-	if (gamma == 1.0)
-	    ramp[i] = i << 8;
-	else
-	    ramp[i] = (CARD16)(pow((double)i / (double)(size - 1), 1. / gamma)
-			       * (double)(size - 1) * 256);
+        if (gamma == 1.0)
+            ramp[i] = i << 8;
+        else
+            ramp[i] =
+                (CARD16) (pow((double) i / (double) (size - 1), 1. / gamma)
+                          * (double) (size - 1) * 256);
     }
 }
 
@@ -1722,15 +1696,15 @@ xf86RandR12ChangeGamma(int scrnIndex, Gamma gamma)
     int size;
 
     if (!crtc)
-	return Success;
+        return Success;
 
     size = max(0, crtc->gammaSize);
     if (!size)
-	return Success;
+        return Success;
 
     points = calloc(size, 3 * sizeof(CARD16));
     if (!points)
-	return BadAlloc;
+        return BadAlloc;
 
     red = points;
     green = points + size;
@@ -1749,37 +1723,37 @@ xf86RandR12ChangeGamma(int scrnIndex, Gamma gamma)
 }
 
 static Bool
-xf86RandR12EnterVT (int screen_index, int flags)
+xf86RandR12EnterVT(int screen_index, int flags)
 {
-    ScreenPtr        pScreen = screenInfo.screens[screen_index];
-    ScrnInfoPtr	     pScrn = xf86Screens[screen_index];
-    XF86RandRInfoPtr randrp  = XF86RANDRINFO(pScreen);
-    rrScrPrivPtr     rp = rrGetScrPriv(pScreen);
-    Bool	     ret;
-    int              i;
+    ScreenPtr pScreen = screenInfo.screens[screen_index];
+    ScrnInfoPtr pScrn = xf86Screens[screen_index];
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
+    rrScrPrivPtr rp = rrGetScrPriv(pScreen);
+    Bool ret;
+    int i;
 
     if (randrp->orig_EnterVT) {
-	pScrn->EnterVT = randrp->orig_EnterVT;
-	ret = pScrn->EnterVT (screen_index, flags);
-	randrp->orig_EnterVT = pScrn->EnterVT;
-	pScrn->EnterVT = xf86RandR12EnterVT;
-	if (!ret)
-	    return FALSE;
+        pScrn->EnterVT = randrp->orig_EnterVT;
+        ret = pScrn->EnterVT(screen_index, flags);
+        randrp->orig_EnterVT = pScrn->EnterVT;
+        pScrn->EnterVT = xf86RandR12EnterVT;
+        if (!ret)
+            return FALSE;
     }
 
     /* reload gamma */
     for (i = 0; i < rp->numCrtcs; i++)
-	xf86RandR12CrtcSetGamma(pScreen, rp->crtcs[i]);
+        xf86RandR12CrtcSetGamma(pScreen, rp->crtcs[i]);
 
-    return RRGetInfo (pScreen, TRUE); /* force a re-probe of outputs and notify clients about changes */
+    return RRGetInfo(pScreen, TRUE);    /* force a re-probe of outputs and notify clients about changes */
 }
 
 static Bool
-xf86RandR12Init12 (ScreenPtr pScreen)
+xf86RandR12Init12(ScreenPtr pScreen)
 {
-    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
-    rrScrPrivPtr	rp = rrGetScrPriv(pScreen);
-    XF86RandRInfoPtr	randrp  = XF86RANDRINFO(pScreen);
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    rrScrPrivPtr rp = rrGetScrPriv(pScreen);
+    XF86RandRInfoPtr randrp = XF86RANDRINFO(pScreen);
     int i;
 
     rp->rrGetInfo = xf86RandR12GetInfo12;
@@ -1802,16 +1776,16 @@ xf86RandR12Init12 (ScreenPtr pScreen)
     randrp->orig_EnterVT = pScrn->EnterVT;
     pScrn->EnterVT = xf86RandR12EnterVT;
 
-    if (!xf86RandR12CreateObjects12 (pScreen))
-	return FALSE;
+    if (!xf86RandR12CreateObjects12(pScreen))
+        return FALSE;
 
     /*
      * Configure output modes
      */
-    if (!xf86RandR12SetInfo12 (pScreen))
-	return FALSE;
+    if (!xf86RandR12SetInfo12(pScreen))
+        return FALSE;
     for (i = 0; i < rp->numCrtcs; i++) {
-	xf86RandR12CrtcGetGamma(pScreen, rp->crtcs[i]);
+        xf86RandR12CrtcGetGamma(pScreen, rp->crtcs[i]);
     }
     return TRUE;
 }
@@ -1819,7 +1793,7 @@ xf86RandR12Init12 (ScreenPtr pScreen)
 #endif
 
 Bool
-xf86RandR12PreInit (ScrnInfoPtr pScrn)
+xf86RandR12PreInit(ScrnInfoPtr pScrn)
 {
     return TRUE;
 }