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, 191 insertions, 177 deletions

diff --git a/xorg-server/randr/rrtransform.c b/xorg-server/randr/rrtransform.c
index e1620498b..f93181d2e 100644
--- a/xorg-server/randr/rrtransform.c
+++ b/xorg-server/randr/rrtransform.c
@@ -24,63 +24,59 @@
 #include "rrtransform.h"
 
 void
-RRTransformInit (RRTransformPtr transform)
+RRTransformInit(RRTransformPtr transform)
 {
-    pixman_transform_init_identity (&transform->transform);
-    pixman_f_transform_init_identity (&transform->f_transform);
-    pixman_f_transform_init_identity (&transform->f_inverse);
+    pixman_transform_init_identity(&transform->transform);
+    pixman_f_transform_init_identity(&transform->f_transform);
+    pixman_f_transform_init_identity(&transform->f_inverse);
     transform->filter = NULL;
     transform->params = NULL;
     transform->nparams = 0;
 }
 
 void
-RRTransformFini (RRTransformPtr transform)
+RRTransformFini(RRTransformPtr transform)
 {
     free(transform->params);
 }
 
 Bool
-RRTransformEqual (RRTransformPtr a, RRTransformPtr b)
+RRTransformEqual(RRTransformPtr a, RRTransformPtr b)
 {
-    if (a && pixman_transform_is_identity (&a->transform))
-	a = NULL;
-    if (b && pixman_transform_is_identity (&b->transform))
-	b = NULL;
+    if (a && pixman_transform_is_identity(&a->transform))
+        a = NULL;
+    if (b && pixman_transform_is_identity(&b->transform))
+        b = NULL;
     if (a == NULL && b == NULL)
-	return TRUE;
+        return TRUE;
     if (a == NULL || b == NULL)
-	return FALSE;
-    if (memcmp (&a->transform, &b->transform, sizeof (a->transform)) != 0)
-	return FALSE;
+        return FALSE;
+    if (memcmp(&a->transform, &b->transform, sizeof(a->transform)) != 0)
+        return FALSE;
     if (a->filter != b->filter)
-	return FALSE;
+        return FALSE;
     if (a->nparams != b->nparams)
-	return FALSE;
-    if (memcmp (a->params, b->params, a->nparams * sizeof (xFixed)) != 0)
-	return FALSE;
+        return FALSE;
+    if (memcmp(a->params, b->params, a->nparams * sizeof(xFixed)) != 0)
+        return FALSE;
     return TRUE;
 }
 
 Bool
-RRTransformSetFilter (RRTransformPtr	dst,
-		      PictFilterPtr	filter,
-		      xFixed		*params,
-		      int		nparams,
-		      int		width,
-		      int		height)
+RRTransformSetFilter(RRTransformPtr dst,
+                     PictFilterPtr filter,
+                     xFixed * params, int nparams, int width, int height)
 {
-    xFixed  *new_params;
+    xFixed *new_params;
 
-    if (nparams)
-    {
-	new_params = malloc(nparams * sizeof (xFixed));
-	if (!new_params)
-	    return FALSE;
-	memcpy (new_params, params, nparams * sizeof (xFixed));
+    if (nparams) {
+        new_params = malloc(nparams * sizeof(xFixed));
+        if (!new_params)
+            return FALSE;
+        memcpy(new_params, params, nparams * sizeof(xFixed));
     }
     else
-	new_params = NULL;
+        new_params = NULL;
     free(dst->params);
     dst->filter = filter;
     dst->params = new_params;
@@ -91,27 +87,26 @@ RRTransformSetFilter (RRTransformPtr	dst,
 }
 
 Bool
-RRTransformCopy (RRTransformPtr dst, RRTransformPtr src)
+RRTransformCopy(RRTransformPtr dst, RRTransformPtr src)
 {
-    if (src && pixman_transform_is_identity (&src->transform))
-	src = NULL;
+    if (src && pixman_transform_is_identity(&src->transform))
+        src = NULL;
 
-    if (src)
-    {
-	if (!RRTransformSetFilter (dst, src->filter,
-				   src->params, src->nparams, src->width, src->height))
-	    return FALSE;
-	dst->transform = src->transform;
-	dst->f_transform = src->f_transform;
-	dst->f_inverse = src->f_inverse;
+    if (src) {
+        if (!RRTransformSetFilter(dst, src->filter,
+                                  src->params, src->nparams, src->width,
+                                  src->height))
+            return FALSE;
+        dst->transform = src->transform;
+        dst->f_transform = src->f_transform;
+        dst->f_inverse = src->f_inverse;
     }
-    else
-    {
-	if (!RRTransformSetFilter (dst, NULL, NULL, 0, 0, 0))
-	    return FALSE;
-	pixman_transform_init_identity (&dst->transform);
-	pixman_f_transform_init_identity (&dst->f_transform);
-	pixman_f_transform_init_identity (&dst->f_inverse);
+    else {
+        if (!RRTransformSetFilter(dst, NULL, NULL, 0, 0, 0))
+            return FALSE;
+        pixman_transform_init_identity(&dst->transform);
+        pixman_f_transform_init_identity(&dst->f_transform);
+        pixman_f_transform_init_identity(&dst->f_inverse);
     }
     return TRUE;
 }
@@ -125,13 +120,13 @@ RRTransformRescale(struct pixman_f_transform *f_transform, double limit)
     int i, j;
 
     for (j = 0; j < 3; j++)
-	for (i = 0; i < 3; i++)
-	    if ((v = abs (f_transform->m[j][i])) > max)
-		max = v;
+        for (i = 0; i < 3; i++)
+            if ((v = abs(f_transform->m[j][i])) > max)
+                max = v;
     scale = limit / max;
     for (j = 0; j < 3; j++)
-	for (i = 0; i < 3; i++)
-	    f_transform->m[j][i] *= scale;
+        for (i = 0; i < 3; i++)
+            f_transform->m[j][i] *= scale;
 }
 
 /*
@@ -142,142 +137,161 @@ RRTransformRescale(struct pixman_f_transform *f_transform, double limit)
  * Return TRUE if the resulting transform is not a simple translation.
  */
 Bool
-RRTransformCompute (int			    x,
-		    int			    y,
-		    int			    width,
-		    int			    height,
-		    Rotation		    rotation,
-		    RRTransformPtr	    rr_transform,
-
-		    PictTransformPtr	    transform,
-		    struct pixman_f_transform *f_transform,
-		    struct pixman_f_transform *f_inverse)
+RRTransformCompute(int x,
+                   int y,
+                   int width,
+                   int height,
+                   Rotation rotation,
+                   RRTransformPtr rr_transform,
+                   PictTransformPtr transform,
+                   struct pixman_f_transform *f_transform,
+                   struct pixman_f_transform *f_inverse)
 {
-    PictTransform	    t_transform, inverse;
+    PictTransform t_transform, inverse;
     struct pixman_f_transform tf_transform, tf_inverse;
-    Bool		    overflow = FALSE;
+    Bool overflow = FALSE;
+
+    if (!transform)
+        transform = &t_transform;
+    if (!f_transform)
+        f_transform = &tf_transform;
+    if (!f_inverse)
+        f_inverse = &tf_inverse;
+
+    pixman_transform_init_identity(transform);
+    pixman_transform_init_identity(&inverse);
+    pixman_f_transform_init_identity(f_transform);
+    pixman_f_transform_init_identity(f_inverse);
+    if (rotation != RR_Rotate_0) {
+        double f_rot_cos, f_rot_sin, f_rot_dx, f_rot_dy;
+        double f_scale_x, f_scale_y, f_scale_dx, f_scale_dy;
+        xFixed rot_cos, rot_sin, rot_dx, rot_dy;
+        xFixed scale_x, scale_y, scale_dx, scale_dy;
 
-    if (!transform) transform = &t_transform;
-    if (!f_transform) f_transform = &tf_transform;
-    if (!f_inverse) f_inverse = &tf_inverse;
+        /* rotation */
+        switch (rotation & 0xf) {
+        default:
+        case RR_Rotate_0:
+            f_rot_cos = 1;
+            f_rot_sin = 0;
+            f_rot_dx = 0;
+            f_rot_dy = 0;
+            rot_cos = F(1);
+            rot_sin = F(0);
+            rot_dx = F(0);
+            rot_dy = F(0);
+            break;
+        case RR_Rotate_90:
+            f_rot_cos = 0;
+            f_rot_sin = 1;
+            f_rot_dx = height;
+            f_rot_dy = 0;
+            rot_cos = F(0);
+            rot_sin = F(1);
+            rot_dx = F(height);
+            rot_dy = F(0);
+            break;
+        case RR_Rotate_180:
+            f_rot_cos = -1;
+            f_rot_sin = 0;
+            f_rot_dx = width;
+            f_rot_dy = height;
+            rot_cos = F(-1);
+            rot_sin = F(0);
+            rot_dx = F(width);
+            rot_dy = F(height);
+            break;
+        case RR_Rotate_270:
+            f_rot_cos = 0;
+            f_rot_sin = -1;
+            f_rot_dx = 0;
+            f_rot_dy = width;
+            rot_cos = F(0);
+            rot_sin = F(-1);
+            rot_dx = F(0);
+            rot_dy = F(width);
+            break;
+        }
 
-    pixman_transform_init_identity (transform);
-    pixman_transform_init_identity (&inverse);
-    pixman_f_transform_init_identity (f_transform);
-    pixman_f_transform_init_identity (f_inverse);
-    if (rotation != RR_Rotate_0)
-    {
-	double	f_rot_cos, f_rot_sin, f_rot_dx, f_rot_dy;
-	double	f_scale_x, f_scale_y, f_scale_dx, f_scale_dy;
-	xFixed	rot_cos, rot_sin, rot_dx, rot_dy;
-	xFixed	scale_x, scale_y, scale_dx, scale_dy;
+        pixman_transform_rotate(transform, &inverse, rot_cos, rot_sin);
+        pixman_transform_translate(transform, &inverse, rot_dx, rot_dy);
+        pixman_f_transform_rotate(f_transform, f_inverse, f_rot_cos, f_rot_sin);
+        pixman_f_transform_translate(f_transform, f_inverse, f_rot_dx,
+                                     f_rot_dy);
 
-	/* rotation */
-	switch (rotation & 0xf) {
-	default:
-	case RR_Rotate_0:
-	    f_rot_cos = 1;	    f_rot_sin = 0;
-	    f_rot_dx  = 0;	    f_rot_dy  = 0;
-	    rot_cos = F ( 1);	    rot_sin = F ( 0);
-	    rot_dx  = F ( 0);	    rot_dy  = F ( 0);
-	    break;
-	case RR_Rotate_90:
-	    f_rot_cos = 0;	    f_rot_sin = 1;
-	    f_rot_dx  = height;	    f_rot_dy  = 0;
-	    rot_cos = F ( 0);	    rot_sin = F ( 1);
-	    rot_dx =  F ( height);  rot_dy  = F (0);
-	    break;
-	case RR_Rotate_180:
-	    f_rot_cos = -1;	    f_rot_sin = 0;
-	    f_rot_dx  = width;	    f_rot_dy  = height;
-	    rot_cos = F (-1);	    rot_sin = F ( 0);
-	    rot_dx  = F (width);   rot_dy  = F ( height);
-	    break;
-	case RR_Rotate_270:
-	    f_rot_cos = 0;	    f_rot_sin = -1;
-	    f_rot_dx  = 0;	    f_rot_dy  = width;
-	    rot_cos = F ( 0);	    rot_sin = F (-1);
-	    rot_dx  = F ( 0);	    rot_dy  = F ( width);
-	    break;
-	}
-	
-	pixman_transform_rotate (transform, &inverse, rot_cos, rot_sin);
-	pixman_transform_translate (transform, &inverse, rot_dx, rot_dy);
-	pixman_f_transform_rotate (f_transform, f_inverse, f_rot_cos, f_rot_sin);
-	pixman_f_transform_translate (f_transform, f_inverse, f_rot_dx, f_rot_dy);
+        /* reflection */
+        f_scale_x = 1;
+        f_scale_dx = 0;
+        f_scale_y = 1;
+        f_scale_dy = 0;
+        scale_x = F(1);
+        scale_dx = 0;
+        scale_y = F(1);
+        scale_dy = 0;
+        if (rotation & RR_Reflect_X) {
+            f_scale_x = -1;
+            scale_x = F(-1);
+            if (rotation & (RR_Rotate_0 | RR_Rotate_180)) {
+                f_scale_dx = width;
+                scale_dx = F(width);
+            }
+            else {
+                f_scale_dx = height;
+                scale_dx = F(height);
+            }
+        }
+        if (rotation & RR_Reflect_Y) {
+            f_scale_y = -1;
+            scale_y = F(-1);
+            if (rotation & (RR_Rotate_0 | RR_Rotate_180)) {
+                f_scale_dy = height;
+                scale_dy = F(height);
+            }
+            else {
+                f_scale_dy = width;
+                scale_dy = F(width);
+            }
+        }
 
-	/* reflection */
-	f_scale_x = 1;
-	f_scale_dx = 0;
-	f_scale_y = 1;
-	f_scale_dy = 0;
-	scale_x = F (1);
-	scale_dx = 0;
-	scale_y = F (1);
-	scale_dy = 0;
-	if (rotation & RR_Reflect_X)
-	{
-	    f_scale_x = -1;
-	    scale_x = F(-1);
-	    if (rotation & (RR_Rotate_0|RR_Rotate_180)) {
-		f_scale_dx = width;
-		scale_dx = F(width);
-	    } else {
-		f_scale_dx = height;
-		scale_dx = F(height);
-	    }
-	}
-	if (rotation & RR_Reflect_Y)
-	{
-	    f_scale_y = -1;
-	    scale_y = F(-1);
-	    if (rotation & (RR_Rotate_0|RR_Rotate_180)) {
-		f_scale_dy = height;
-		scale_dy = F(height);
-	    } else {
-		f_scale_dy = width;
-		scale_dy = F(width);
-	    }
-	}
-	
-	pixman_transform_scale (transform, &inverse, scale_x, scale_y);
-	pixman_f_transform_scale (f_transform, f_inverse, f_scale_x, f_scale_y);
-	pixman_transform_translate (transform, &inverse, scale_dx, scale_dy);
-	pixman_f_transform_translate (f_transform, f_inverse, f_scale_dx, f_scale_dy);
+        pixman_transform_scale(transform, &inverse, scale_x, scale_y);
+        pixman_f_transform_scale(f_transform, f_inverse, f_scale_x, f_scale_y);
+        pixman_transform_translate(transform, &inverse, scale_dx, scale_dy);
+        pixman_f_transform_translate(f_transform, f_inverse, f_scale_dx,
+                                     f_scale_dy);
     }
-    
+
 #ifdef RANDR_12_INTERFACE
-    if (rr_transform)
-    {
-        if (!pixman_transform_multiply (transform, &rr_transform->transform, transform))
-	    overflow = TRUE;
-	pixman_f_transform_multiply (f_transform, &rr_transform->f_transform, f_transform);
-	pixman_f_transform_multiply (f_inverse, f_inverse, &rr_transform->f_inverse);
+    if (rr_transform) {
+        if (!pixman_transform_multiply
+            (transform, &rr_transform->transform, transform))
+            overflow = TRUE;
+        pixman_f_transform_multiply(f_transform, &rr_transform->f_transform,
+                                    f_transform);
+        pixman_f_transform_multiply(f_inverse, f_inverse,
+                                    &rr_transform->f_inverse);
     }
 #endif
     /*
      * Compute the class of the resulting transform
      */
-    if (!overflow && pixman_transform_is_identity (transform))
-    {
-	pixman_transform_init_translate (transform, F ( x), F ( y));
+    if (!overflow && pixman_transform_is_identity(transform)) {
+        pixman_transform_init_translate(transform, F(x), F(y));
 
-	pixman_f_transform_init_translate (f_transform,  x,  y);
-	pixman_f_transform_init_translate (f_inverse,   -x, -y);
-	return FALSE;
+        pixman_f_transform_init_translate(f_transform, x, y);
+        pixman_f_transform_init_translate(f_inverse, -x, -y);
+        return FALSE;
     }
-    else
-    {
-	pixman_f_transform_translate (f_transform, f_inverse, x, y);
-	if (!pixman_transform_translate (transform, &inverse, F(x), F(y)))
-	    overflow = TRUE;
-	if (overflow)
-	{
-	    struct pixman_f_transform f_scaled;
-	    f_scaled = *f_transform;
-	    RRTransformRescale(&f_scaled, 16384.0);
-	    pixman_transform_from_pixman_f_transform(transform, &f_scaled);
-	}
-	return TRUE;
+    else {
+        pixman_f_transform_translate(f_transform, f_inverse, x, y);
+        if (!pixman_transform_translate(transform, &inverse, F(x), F(y)))
+            overflow = TRUE;
+        if (overflow) {
+            struct pixman_f_transform f_scaled;
+
+            f_scaled = *f_transform;
+            RRTransformRescale(&f_scaled, 16384.0);
+            pixman_transform_from_pixman_f_transform(transform, &f_scaled);
+        }
+        return TRUE;
     }
 }