 @@ -528,1999 +528,1999 @@ mode_geometry (XRRModeInfo *mode_info, R
     int height = mode_height (mode_info, rotation);
     rect[0].x = 0;
     rect[0].y = 0;
     rect[1].x = width;
     rect[1].y = 0;
     rect[2].x = width;
     rect[2].y = height;
     rect[3].x = 0;
     rect[3].y = height;
     path_bounds (transform, rect, 4, bounds);
+}
 /* v refresh frequency in Hz */
 static double
 mode_refresh (XRRModeInfo *mode_info)
+{
     double rate;
     unsigned int vTotal = mode_info->vTotal;
     if (mode_info->modeFlags & RR_DoubleScan) {
 	/* doublescan doubles the number of lines */
 	vTotal *= 2;
+    }
     if (mode_info->modeFlags & RR_Interlace) {
 	/* interlace splits the frame into two fields */
 	/* the field rate is what is typically reported by monitors */
 	vTotal /= 2;
+    }
     if (mode_info->hTotal && vTotal)
 	rate = ((double) mode_info->dotClock /
 		((double) mode_info->hTotal * (double) vTotal));
     else
     	rate = 0;
     return rate;
+}
 /* h sync frequency in Hz */
 static double
 mode_hsync (XRRModeInfo *mode_info)
+{
     double rate;
     if (mode_info->hTotal)
 	rate = (double) mode_info->dotClock / (double) mode_info->hTotal;
     else
     	rate = 0;
     return rate;
+}
 static void
 init_name (name_t *name)
+{
     name->kind = name_none;
+}
 static void
 set_name_string (name_t *name, char *string)
+{
     name->kind |= name_string;
     name->string = string;
+}
 static void
 set_name_xid (name_t *name, XID xid)
+{
     name->kind |= name_xid;
     name->xid = xid;
+}
 static void
 set_name_index (name_t *name, int idx)
+{
     name->kind |= name_index;
     name->index = idx;
+}
 static void
 set_name_preferred (name_t *name)
+{
     name->kind |= name_preferred;
+}
 static void
 set_name_all (name_t *name, name_t *old)
+{
     if (old->kind & name_xid)
 	name->xid = old->xid;
     if (old->kind & name_string)
 	name->string = old->string;
     if (old->kind & name_index)
 	name->index = old->index;
     name->kind |= old->kind;
+}
 static void
 set_name (name_t *name, char *string, name_kind_t valid)
+{
     unsigned int xid; /* don't make it XID (which is unsigned long):
 			 scanf() takes unsigned int */
     int idx;
     if ((valid & name_xid) && sscanf (string, "0x%x", &xid) == 1)
 	set_name_xid (name, xid);
     else if ((valid & name_index) && sscanf (string, "%d", &idx) == 1)
 	set_name_index (name, idx);
     else if (valid & name_string)
 	set_name_string (name, string);
     else
 	argerr ("invalid name '%s'\n", string);
+}
 static int
 print_name (const name_t *name)
+{
     name_kind_t kind = name->kind;
     if ((kind & name_xid))         return printf("XID 0x%x", (unsigned int)name->xid);
     else if ((kind & name_string)) return printf("name %s", name->string);
     else if ((kind & name_index))  return printf("index %d", name->index);
     else                           return printf("unknown name");
+}
 static void
 init_transform (transform_t *transform)
+{
     int x;
     memset (&transform->transform, '\0', sizeof (transform->transform));
     for (x = 0; x < 3; x++)
 	transform->transform.matrix[x][x] = XDoubleToFixed (1.0);
     transform->filter = "";
     transform->nparams = 0;
     transform->params = NULL;
+}
 static void
 set_transform (transform_t  *dest,
 	       XTransform   *transform,
 	       const char   *filter,
 	       XFixed	    *params,
 	       int	    nparams)
+{
     dest->transform = *transform;
     /* note: this string is leaked */
     dest->filter = strdup (filter);
     dest->nparams = nparams;
     dest->params = malloc (nparams * sizeof (XFixed));
     memcpy (dest->params, params, nparams * sizeof (XFixed));
+}
 static void
 copy_transform (transform_t *dest, transform_t *src)
+{
     set_transform (dest, &src->transform,
 		   src->filter, src->params, src->nparams);
+}
 static Bool
 equal_transform (transform_t *a, transform_t *b)
+{
     if (memcmp (&a->transform, &b->transform, sizeof (XTransform)) != 0)
 	return False;
     if (strcmp (a->filter, b->filter) != 0)
 	return False;
     if (a->nparams != b->nparams)
 	return False;
     if (memcmp (a->params, b->params, a->nparams * sizeof (XFixed)) != 0)
 	return False;
     return True;
+}
 static output_t *
 add_output (void)
+{
     output_t *output = calloc (1, sizeof (output_t));
     if (!output)
 	fatal ("out of memory\n");
     output->next = NULL;
     output->found = False;
     output->brightness = 1.0;
     *all_outputs_tail = output;
     all_outputs_tail = &output->next;
     return output;
+}
 static output_t *
 find_output (name_t *name)
+{
     output_t *output;
     for (output = all_outputs; output; output = output->next)
+    {
 	name_kind_t common = name->kind & output->output.kind;
 	if ((common & name_xid) && name->xid == output->output.xid)
 	    break;
 	if ((common & name_string) && !strcmp (name->string, output->output.string))
 	    break;
 	if ((common & name_index) && name->index == output->output.index)
 	    break;
+    }
     return output;
+}
 static output_t *
 find_output_by_xid (RROutput output)
+{
     name_t  output_name;
     init_name (&output_name);
     set_name_xid (&output_name, output);
     return find_output (&output_name);
+}
 static output_t *
 find_output_by_name (char *name)
+{
     name_t  output_name;
     init_name (&output_name);
     set_name_string (&output_name, name);
     return find_output (&output_name);
+}
 static crtc_t *
 find_crtc (name_t *name)
+{
     int	    c;
     crtc_t  *crtc = NULL;
     for (c = 0; c < num_crtcs; c++)
+    {
 	name_kind_t common;
 	crtc = &crtcs[c];
 	common = name->kind & crtc->crtc.kind;
 	if ((common & name_xid) && name->xid == crtc->crtc.xid)
 	    break;
 	if ((common & name_string) && !strcmp (name->string, crtc->crtc.string))
 	    break;
 	if ((common & name_index) && name->index == crtc->crtc.index)
 	    break;
 	crtc = NULL;
+    }
     return crtc;
+}
 static crtc_t *
 find_crtc_by_xid (RRCrtc crtc)
+{
     name_t  crtc_name;
     init_name (&crtc_name);
     set_name_xid (&crtc_name, crtc);
     return find_crtc (&crtc_name);
+}
 static XRRModeInfo *
 find_mode (name_t *name, double refresh)
+{
     int		m;
     XRRModeInfo	*best = NULL;
     double	bestDist = 0;
     for (m = 0; m < res->nmode; m++)
+    {
 	XRRModeInfo *mode = &res->modes[m];
 	if ((name->kind & name_xid) && name->xid == mode->id)
+	{
 	    best = mode;
 	    break;
+	}
 	if ((name->kind & name_string) && !strcmp (name->string, mode->name))
+	{
 	    double   dist;
 	    if (refresh)
 		dist = fabs (mode_refresh (mode) - refresh);
 	    else
 		dist = 0;
 	    if (!best || dist < bestDist)
+	    {
 		bestDist = dist;
 		best = mode;
+	    }
+	}
+    }
     return best;
+}
 static XRRModeInfo *
 find_mode_by_xid (RRMode mode)
+{
     name_t  mode_name;
     init_name (&mode_name);
     set_name_xid (&mode_name, mode);
     return find_mode (&mode_name, 0);
+}
 #if 0
 static XRRModeInfo *
 find_mode_by_name (char *name)
+{
     name_t  mode_name;
     init_name (&mode_name);
     set_name_string (&mode_name, name);
     return find_mode (&mode_name, 0);
+}
 #endif
 static
 XRRModeInfo *
 find_mode_for_output (output_t *output, name_t *name)
+{
     XRROutputInfo   *output_info = output->output_info;
     int		    m;
     XRRModeInfo	    *best = NULL;
     double	    bestDist = 0;
     for (m = 0; m < output_info->nmode; m++)
+    {
 	XRRModeInfo	    *mode;
 	mode = find_mode_by_xid (output_info->modes[m]);
 	if (!mode) continue;
 	if ((name->kind & name_xid) && name->xid == mode->id)
+	{
 	    best = mode;
 	    break;
+	}
 	if ((name->kind & name_string) && !strcmp (name->string, mode->name))
+	{
 	    double   dist;
 	    /* Stay away from doublescan modes unless refresh rate is specified. */
 	    if (!output->refresh && (mode->modeFlags & RR_DoubleScan))
 		continue;
 	    if (output->refresh)
 		dist = fabs (mode_refresh (mode) - output->refresh);
 	    else
 		dist = 0;
 	    if (!best || dist < bestDist)
+	    {
 		bestDist = dist;
 		best = mode;
+	    }
+	}
+    }
     return best;
+}
 static XRRModeInfo *
 preferred_mode (output_t *output)
+{
     XRROutputInfo   *output_info = output->output_info;
     int		    m;
     XRRModeInfo	    *best;
     int		    bestDist;
     best = NULL;
     bestDist = 0;
     for (m = 0; m < output_info->nmode; m++)
+    {
 	XRRModeInfo *mode_info = find_mode_by_xid (output_info->modes[m]);
 	int	    dist;
 	if (m < output_info->npreferred)
 	    dist = 0;
 	else if (output_info->mm_height)
 	    dist = (1000 * DisplayHeight(dpy, screen) / DisplayHeightMM(dpy, screen) -
 * mode_info->height / output_info->mm_height);
 	else
 	    dist = DisplayHeight(dpy, screen) - mode_info->height;
         if (dist < 0) dist = -dist;
 	if (!best || dist < bestDist)
+	{
 	    best = mode_info;
 	    bestDist = dist;
+	}
+    }
     return best;
+}
 static Bool
 output_can_use_crtc (output_t *output, crtc_t *crtc)
+{
     XRROutputInfo   *output_info = output->output_info;
     int		    c;
     for (c = 0; c < output_info->ncrtc; c++)
 	if (output_info->crtcs[c] == crtc->crtc.xid)
 	    return True;
     return False;
+}
 static Bool
 output_can_use_mode (output_t *output, XRRModeInfo *mode)
+{
     XRROutputInfo   *output_info = output->output_info;
     int		    m;
     for (m = 0; m < output_info->nmode; m++)
 	if (output_info->modes[m] == mode->id)
 	    return True;
     return False;
+}
 static Bool
 crtc_can_use_rotation (crtc_t *crtc, Rotation rotation)
+{
     Rotation	rotations = crtc->crtc_info->rotations;
     Rotation	dir = rotation & (RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270);
     Rotation	reflect = rotation & (RR_Reflect_X|RR_Reflect_Y);
     if (((rotations & dir) != 0) && ((rotations & reflect) == reflect))
 	return True;
     return False;
+}
 #if 0
 static Bool
 crtc_can_use_transform (crtc_t *crtc, XTransform *transform)
+{
     int	major, minor;
     XRRQueryVersion (dpy, &major, &minor);
     if (major > 1 || (major == 1 && minor >= 3))
 	return True;
     return False;
+}
 #endif
 /*
  * Report only rotations that are supported by all crtcs
  */
 static Rotation
 output_rotations (output_t *output)
+{
     Bool	    found = False;
     Rotation	    rotation = RR_Rotate_0;
     XRROutputInfo   *output_info = output->output_info;
     int		    c;
     for (c = 0; c < output_info->ncrtc; c++)
+    {
 	crtc_t	*crtc = find_crtc_by_xid (output_info->crtcs[c]);
 	if (crtc)
+	{
 	    if (!found) {
 		rotation = crtc->crtc_info->rotations;
 		found = True;
 	    } else
 		rotation &= crtc->crtc_info->rotations;
+	}
+    }
     return rotation;
+}
 static Bool
 output_can_use_rotation (output_t *output, Rotation rotation)
+{
     XRROutputInfo   *output_info = output->output_info;
     int		    c;
     /* make sure all of the crtcs can use this rotation.
      * yes, this is not strictly necessary, but it is
      * simpler,and we expect most drivers to either
      * support rotation everywhere or nowhere
      */
     for (c = 0; c < output_info->ncrtc; c++)
+    {
 	crtc_t	*crtc = find_crtc_by_xid (output_info->crtcs[c]);
 	if (crtc && !crtc_can_use_rotation (crtc, rotation))
 	    return False;
+    }
     return True;
+}
 static Bool
 output_is_primary(output_t *output)
+{
     if (has_1_3)
 	    return XRRGetOutputPrimary(dpy, root) == output->output.xid;
     return False;
+}
 /* Returns the index of the last value in an array < 0xffff */
 static int
 find_last_non_clamped(CARD16 array[], int size) {
     int i;
     for (i = size - 1; i > 0; i--) {
         if (array[i] < 0xffff)
 	    return i;
+    }
     return 0;
+}
 static void
 set_gamma_info(output_t *output)
+{
     XRRCrtcGamma *crtc_gamma;
     double i1, v1, i2, v2;
     int size, middle, last_best, last_red, last_green, last_blue;
     CARD16 *best_array;
     if (!output->crtc_info)
 	return;
     size = XRRGetCrtcGammaSize(dpy, output->crtc_info->crtc.xid);
     if (!size) {
 	warning("Failed to get size of gamma for output %s\n", output->output.string);
 	return;
+    }
     crtc_gamma = XRRGetCrtcGamma(dpy, output->crtc_info->crtc.xid);
     if (!crtc_gamma) {
 	warning("Failed to get gamma for output %s\n", output->output.string);
 	return;
+    }
     /*
      * Here is a bit tricky because gamma is a whole curve for each
      * color.  So, typically, we need to represent 3 * 256 values as 3 + 1
      * values.  Therefore, we approximate the gamma curve (v) by supposing
      * it always follows the way we set it: a power function (i^g)
      * multiplied by a brightness (b).
      * v = i^g * b
      * so g = (ln(v) - ln(b))/ln(i)
      * and b can be found using two points (v1,i1) and (v2, i2):
      * b = e^((ln(v2)*ln(i1) - ln(v1)*ln(i2))/ln(i1/i2))
      * For the best resolution, we select i2 at the highest place not
      * clamped and i1 at i2/2. Note that if i2 = 1 (as in most normal
      * cases), then b = v2.
      */
     last_red = find_last_non_clamped(crtc_gamma->red, size);
     last_green = find_last_non_clamped(crtc_gamma->green, size);
     last_blue = find_last_non_clamped(crtc_gamma->blue, size);
     best_array = crtc_gamma->red;
     last_best = last_red;
     if (last_green > last_best) {
 	last_best = last_green;
 	best_array = crtc_gamma->green;
+    }
     if (last_blue > last_best) {
 	last_best = last_blue;
 	best_array = crtc_gamma->blue;
+    }
     if (last_best == 0)
 	last_best = 1;
     middle = last_best / 2;
     i1 = (double)(middle + 1) / size;
     v1 = (double)(best_array[middle]) / 65535;
     i2 = (double)(last_best + 1) / size;
     v2 = (double)(best_array[last_best]) / 65535;
     if (v2 < 0.0001) { /* The screen is black */
 	output->brightness = 0;
 	output->gamma.red = 1;
 	output->gamma.green = 1;
 	output->gamma.blue = 1;
     } else {
 	if ((last_best + 1) == size)
 	    output->brightness = v2;
 	else
 	    output->brightness = exp((log(v2)*log(i1) - log(v1)*log(i2))/log(i1/i2));
 	output->gamma.red = log((double)(crtc_gamma->red[last_red / 2]) / output->brightness
 				/ 65535) / log((double)((last_red / 2) + 1) / size);
 	output->gamma.green = log((double)(crtc_gamma->green[last_green / 2]) / output->brightness
 				  / 65535) / log((double)((last_green / 2) + 1) / size);
 	output->gamma.blue = log((double)(crtc_gamma->blue[last_blue / 2]) / output->brightness
 				 / 65535) / log((double)((last_blue / 2) + 1) / size);
+    }
     XRRFreeGamma(crtc_gamma);
+}
 static void
 set_output_info (output_t *output, RROutput xid, XRROutputInfo *output_info)
+{
     /* sanity check output info */
     if (output_info->connection != RR_Disconnected && !output_info->nmode)
 	warning ("Output %s is not disconnected but has no modes\n",
 		 output_info->name);
     /* set output name and info */
     if (!(output->output.kind & name_xid))
 	set_name_xid (&output->output, xid);
     if (!(output->output.kind & name_string))
 	set_name_string (&output->output, output_info->name);
     output->output_info = output_info;
     /* set crtc name and info */
     if (!(output->changes & changes_crtc))
 	set_name_xid (&output->crtc, output_info->crtc);
     if (output->crtc.kind == name_xid && output->crtc.xid == None)
 	output->crtc_info = NULL;
     else
+    {
 	output->crtc_info = find_crtc (&output->crtc);
 	if (!output->crtc_info)
+	{
 	    if (output->crtc.kind & name_xid)
 		fatal ("cannot find crtc 0x%lx\n", output->crtc.xid);
 	    if (output->crtc.kind & name_index)
 		fatal ("cannot find crtc %d\n", output->crtc.index);
+	}
 	if (!output_can_use_crtc (output, output->crtc_info))
 	    fatal ("output %s cannot use crtc 0x%lx\n", output->output.string,
 		   output->crtc_info->crtc.xid);
+    }
     /* set mode name and info */
     if (!(output->changes & changes_mode))
+    {
 	crtc_t	*crtc = NULL;
 	if (output_info->crtc)
 	    crtc = find_crtc_by_xid(output_info->crtc);
 	if (crtc && crtc->crtc_info)
 	    set_name_xid (&output->mode, crtc->crtc_info->mode);
 	else if (output->crtc_info)
 	    set_name_xid (&output->mode, output->crtc_info->crtc_info->mode);
 	else
 	    set_name_xid (&output->mode, None);
 	if (output->mode.xid)
+	{
 	    output->mode_info = find_mode_by_xid (output->mode.xid);
 	    if (!output->mode_info)
 		fatal ("server did not report mode 0x%lx for output %s\n",
 		       output->mode.xid, output->output.string);
+	}
 	else
 	    output->mode_info = NULL;
+    }
     else if (output->mode.kind == name_xid && output->mode.xid == None)
 	output->mode_info = NULL;
     else
+    {
 	if (output->mode.kind == name_preferred)
 	    output->mode_info = preferred_mode (output);
 	else
 	    output->mode_info = find_mode_for_output (output, &output->mode);
 	if (!output->mode_info)
+	{
 	    if (output->mode.kind & name_preferred)
 		fatal ("cannot find preferred mode\n");
 	    if (output->mode.kind & name_string)
 		fatal ("cannot find mode %s\n", output->mode.string);
 	    if (output->mode.kind & name_xid)
 		fatal ("cannot find mode 0x%lx\n", output->mode.xid);
+	}
 	if (!output_can_use_mode (output, output->mode_info))
 	    fatal ("output %s cannot use mode %s\n", output->output.string,
 		   output->mode_info->name);
+    }
     /* set position */
     if (!(output->changes & changes_position))
+    {
 	if (output->crtc_info)
+	{
 	    output->x = output->crtc_info->crtc_info->x;
 	    output->y = output->crtc_info->crtc_info->y;
+	}
 	else
+	{
 	    output->x = 0;
 	    output->y = 0;
+	}
+    }
     /* set rotation */
     if (!(output->changes & changes_rotation))
+    {
 	output->rotation &= ~0xf;
 	if (output->crtc_info)
 	    output->rotation |= (output->crtc_info->crtc_info->rotation & 0xf);
 	else
 	    output->rotation = RR_Rotate_0;
+    }
     if (!(output->changes & changes_reflection))
+    {
 	output->rotation &= ~(RR_Reflect_X|RR_Reflect_Y);
 	if (output->crtc_info)
 	    output->rotation |= (output->crtc_info->crtc_info->rotation &
 				 (RR_Reflect_X|RR_Reflect_Y));
+    }
     if (!output_can_use_rotation (output, output->rotation))
 	fatal ("output %s cannot use rotation \"%s\" reflection \"%s\"\n",
 	       output->output.string,
 	       rotation_name (output->rotation),
 	       reflection_name (output->rotation));
     /* set gamma */
     if (!(output->changes & changes_gamma))
 	    set_gamma_info(output);
     /* set transformation */
     if (!(output->changes & changes_transform))
+    {
 	if (output->crtc_info)
 	    copy_transform (&output->transform, &output->crtc_info->current_transform);
 	else
 	    init_transform (&output->transform);
     } else {
 	/* transform was already set for --scale or --transform */
 	/* for --scale-from, figure out the mode size and compute the transform
 	 * for the target framebuffer area */
 	if (output->scale_from_w > 0 && output->mode_info) {
 	    double sx = (double)output->scale_from_w /
 				output->mode_info->width;
 	    double sy = (double)output->scale_from_h /
 				output->mode_info->height;
 	    if (verbose)
 		printf("scaling %s by %lfx%lf\n", output->output.string, sx,
 		       sy);
 	    init_transform (&output->transform);
 	    output->transform.transform.matrix[0][0] = XDoubleToFixed (sx);
 	    output->transform.transform.matrix[1][1] = XDoubleToFixed (sy);
 	    output->transform.transform.matrix[2][2] = XDoubleToFixed (1.0);
 	    if (sx != 1 || sy != 1)
 		output->transform.filter = "bilinear";
 	    else
 		output->transform.filter = "nearest";
 	    output->transform.nparams = 0;
 	    output->transform.params = NULL;
+	}
+    }
     /* set primary */
     if (!(output->changes & changes_primary))
 	output->primary = output_is_primary(output);
+}
 static void
 get_screen (Bool current)
+{
     if (!has_1_2)
         fatal ("Server RandR version before 1.2\n");
     if (res)
 	return;
     XRRGetScreenSizeRange (dpy, root, &minWidth, &minHeight,
 			   &maxWidth, &maxHeight);
     if (current)
 	res = XRRGetScreenResourcesCurrent (dpy, root);
     else
 	res = XRRGetScreenResources (dpy, root);
     if (!res) fatal ("could not get screen resources");
+}
 static void
 get_crtcs (void)
+{
     int		c;
     num_crtcs = res->ncrtc;
     crtcs = calloc (num_crtcs, sizeof (crtc_t));
     if (!crtcs) fatal ("out of memory\n");
     for (c = 0; c < res->ncrtc; c++)
+    {
 	XRRCrtcInfo *crtc_info = XRRGetCrtcInfo (dpy, res, res->crtcs[c]);
 	XRRCrtcTransformAttributes  *attr;
 	XRRPanning  *panning_info = NULL;
 	if (has_1_3) {
 	    XRRPanning zero;
 	    memset(&zero, 0, sizeof(zero));
 	    panning_info = XRRGetPanning  (dpy, res, res->crtcs[c]);
 	    zero.timestamp = panning_info->timestamp;
 	    if (!memcmp(panning_info, &zero, sizeof(zero))) {
 		Xfree(panning_info);
 		panning_info = NULL;
+	    }
+	}
 	set_name_xid (&crtcs[c].crtc, res->crtcs[c]);
 	set_name_index (&crtcs[c].crtc, c);
 	if (!crtc_info) fatal ("could not get crtc 0x%lx information\n", res->crtcs[c]);
 	crtcs[c].crtc_info = crtc_info;
 	crtcs[c].panning_info = panning_info;
 	if (crtc_info->mode == None)
+	{
 	    crtcs[c].mode_info = NULL;
 	    crtcs[c].x = 0;
 	    crtcs[c].y = 0;
 	    crtcs[c].rotation = RR_Rotate_0;
+	}
 	if (XRRGetCrtcTransform (dpy, res->crtcs[c], &attr) && attr) {
 	    set_transform (&crtcs[c].current_transform,
 			   &attr->currentTransform,
 			   attr->currentFilter,
 			   attr->currentParams,
 			   attr->currentNparams);
 	    XFree (attr);
+	}
 	else
+	{
 	    init_transform (&crtcs[c].current_transform);
+	}
 	copy_transform (&crtcs[c].pending_transform, &crtcs[c].current_transform);
+   }
+}
 static void
 crtc_add_output (crtc_t *crtc, output_t *output)
+{
     if (crtc->outputs)
 	crtc->outputs = realloc (crtc->outputs, (crtc->noutput + 1) * sizeof (output_t *));
     else
+    {
 	crtc->outputs = malloc (sizeof (output_t *));
 	crtc->x = output->x;
 	crtc->y = output->y;
 	crtc->rotation = output->rotation;
 	crtc->mode_info = output->mode_info;
 	copy_transform (&crtc->pending_transform, &output->transform);
+   }
     if (!crtc->outputs) fatal ("out of memory\n");
     crtc->outputs[crtc->noutput++] = output;
+}
 static void
 set_crtcs (void)
+{
     output_t	*output;
     for (output = all_outputs; output; output = output->next)
+    {
 	if (!output->mode_info) continue;
 	crtc_add_output (output->crtc_info, output);
+    }
+}
 static void
 set_panning (void)
+{
     output_t	*output;
     for (output = all_outputs; output; output = output->next)
+    {
 	if (! output->crtc_info)
 	    continue;
 	if (! (output->changes & changes_panning))
 	    continue;
 	if (! output->crtc_info->panning_info)
 	    output->crtc_info->panning_info = malloc (sizeof(XRRPanning));
 	memcpy (output->crtc_info->panning_info, &output->panning, sizeof(XRRPanning));
 	output->crtc_info->changing = 1;
+    }
+}
 static void
 set_gamma(void)
+{
     output_t	*output;
     for (output = all_outputs; output; output = output->next) {
 	int i, size, shift;
 	crtc_t *crtc;
 	XRRCrtcGamma *crtc_gamma;
 	float gammaRed;
 	float gammaGreen;
 	float gammaBlue;
 	if (!(output->changes & changes_gamma))
 	    continue;
 	if (!output->crtc_info) {
 	    fatal("Need crtc to set gamma on.\n");
 	    continue;
+	}
 	crtc = output->crtc_info;
 	size = XRRGetCrtcGammaSize(dpy, crtc->crtc.xid);
 	if (!size) {
 	    fatal("Gamma size is 0.\n");
 	    continue;
+	}
 	/*
 	 * The gamma-correction lookup table managed through XRR[GS]etCrtcGamma
 	 * is 2^n in size, where 'n' is the number of significant bits in
 	 * the X Color.  Because an X Color is 16 bits, size cannot be larger
 	 * than 2^16.
 	 */
 	if (size > 65536) {
 	    fatal("Gamma correction table is impossibly large.\n");
 	    continue;
+	}
 	/*
 	 * The hardware color lookup table has a number of significant
 	 * bits equal to ffs(size) - 1; compute all values so that
 	 * they are in the range [0,size) then shift the values so
 	 * that they occupy the MSBs of the 16-bit X Color.
 	 */
 	shift = 16 - (ffs(size) - 1);
 	crtc_gamma = XRRAllocGamma(size);
 	if (!crtc_gamma) {
 	    fatal("Gamma allocation failed.\n");
 	    continue;
+	}
 	if (output->gamma.red == 0.0)
 	    output->gamma.red = 1.0;
 	if (output->gamma.green == 0.0)
 	    output->gamma.green = 1.0;
 	if (output->gamma.blue == 0.0)
 	    output->gamma.blue = 1.0;
 	gammaRed = 1.0 / output->gamma.red;
 	gammaGreen = 1.0 / output->gamma.green;
 	gammaBlue = 1.0 / output->gamma.blue;
 	for (i = 0; i < size; i++) {
 	    if (gammaRed == 1.0 && output->brightness == 1.0)
 		crtc_gamma->red[i] = i;
 	    else
 		crtc_gamma->red[i] = dmin(pow((double)i/(double)(size - 1),
 					      gammaRed) * output->brightness,
 .0) * (double)(size - 1);
 	    crtc_gamma->red[i] <<= shift;
 	    if (gammaGreen == 1.0 && output->brightness == 1.0)
 		crtc_gamma->green[i] = i;
 	    else
 		crtc_gamma->green[i] = dmin(pow((double)i/(double)(size - 1),
 						gammaGreen) * output->brightness,
 .0) * (double)(size - 1);
 	    crtc_gamma->green[i] <<= shift;
 	    if (gammaBlue == 1.0 && output->brightness == 1.0)
 		crtc_gamma->blue[i] = i;
 	    else
 		crtc_gamma->blue[i] = dmin(pow((double)i/(double)(size - 1),
 					       gammaBlue) * output->brightness,
 .0) * (double)(size - 1);
 	    crtc_gamma->blue[i] <<= shift;
+	}
 	XRRSetCrtcGamma(dpy, crtc->crtc.xid, crtc_gamma);
 	free(crtc_gamma);
+    }
+}
 static void
 set_primary(void)
+{
     output_t *output;
     if (no_primary) {
 	XRRSetOutputPrimary(dpy, root, None);
     } else {
 	for (output = all_outputs; output; output = output->next) {
 	    if (!(output->changes & changes_primary))
 		continue;
 	    if (output->primary)
 		XRRSetOutputPrimary(dpy, root, output->output.xid);
+	}
+    }
+}
 static Status
 crtc_disable (crtc_t *crtc)
+{
     if (verbose)
     	printf ("crtc %d: disable\n", crtc->crtc.index);
     if (dryrun)
 	return RRSetConfigSuccess;
     return XRRSetCrtcConfig (dpy, res, crtc->crtc.xid, CurrentTime,
 , 0, None, RR_Rotate_0, NULL, 0);
+}
 static void
 crtc_set_transform (crtc_t *crtc, transform_t *transform)
+{
     int	major, minor;
     XRRQueryVersion (dpy, &major, &minor);
     if (major > 1 || (major == 1 && minor >= 3))
 	XRRSetCrtcTransform (dpy, crtc->crtc.xid,
 			     &transform->transform,
-			     __UNCONST(transform->filter),
+			     transform->filter,
 			     transform->params,
 			     transform->nparams);
+}
 static Status
 crtc_revert (crtc_t *crtc)
+{
     XRRCrtcInfo	*crtc_info = crtc->crtc_info;
     if (verbose)
     	printf ("crtc %d: revert\n", crtc->crtc.index);
     if (dryrun)
 	return RRSetConfigSuccess;
     if (!equal_transform (&crtc->current_transform, &crtc->pending_transform))
 	crtc_set_transform (crtc, &crtc->current_transform);
     return XRRSetCrtcConfig (dpy, res, crtc->crtc.xid, CurrentTime,
 			    crtc_info->x, crtc_info->y,
 			    crtc_info->mode, crtc_info->rotation,
 			    crtc_info->outputs, crtc_info->noutput);
+}
 static Status
 crtc_apply (crtc_t *crtc)
+{
     RROutput	*rr_outputs;
     int		o;
     Status	s;
     RRMode	mode = None;
     if (!crtc->changing || !crtc->mode_info)
 	return RRSetConfigSuccess;
     rr_outputs = calloc (crtc->noutput, sizeof (RROutput));
     if (!rr_outputs)
 	return BadAlloc;
     for (o = 0; o < crtc->noutput; o++)
 	rr_outputs[o] = crtc->outputs[o]->output.xid;
     mode = crtc->mode_info->id;
     if (verbose) {
 	printf ("crtc %d: %12s %6.1f +%d+%d", crtc->crtc.index,
 		crtc->mode_info->name, mode_refresh (crtc->mode_info),
 		crtc->x, crtc->y);
 	for (o = 0; o < crtc->noutput; o++)
 	    printf (" \"%s\"", crtc->outputs[o]->output.string);
 	printf ("\n");
+    }
     if (dryrun)
 	s = RRSetConfigSuccess;
     else
+    {
 	if (!equal_transform (&crtc->current_transform, &crtc->pending_transform))
 	    crtc_set_transform (crtc, &crtc->pending_transform);
 	s = XRRSetCrtcConfig (dpy, res, crtc->crtc.xid, CurrentTime,
 			      crtc->x, crtc->y, mode, crtc->rotation,
 			      rr_outputs, crtc->noutput);
 	if (s == RRSetConfigSuccess && crtc->panning_info) {
 	    if (has_1_3)
 		s = XRRSetPanning (dpy, res, crtc->crtc.xid, crtc->panning_info);
 	    else
 		fatal ("panning needs RandR 1.3\n");
+	}
+    }
     free (rr_outputs);
     return s;
+}
 static void
 screen_revert (void)
+{
     if (verbose)
 	printf ("screen %d: revert\n", screen);
     if (dryrun)
 	return;
     XRRSetScreenSize (dpy, root,
 		      DisplayWidth (dpy, screen),
 		      DisplayHeight (dpy, screen),
 		      DisplayWidthMM (dpy, screen),
 		      DisplayHeightMM (dpy, screen));
+}
 static void
 screen_apply (void)
+{
     if (fb_width == DisplayWidth (dpy, screen) &&
 	fb_height == DisplayHeight (dpy, screen) &&
 	fb_width_mm == DisplayWidthMM (dpy, screen) &&
 	fb_height_mm == DisplayHeightMM (dpy, screen))
+    {
 	return;
+    }
     if (verbose)
 	printf ("screen %d: %dx%d %dx%d mm %6.2fdpi\n", screen,
 		fb_width, fb_height, fb_width_mm, fb_height_mm, dpi);
     if (dryrun)
 	return;
     XRRSetScreenSize (dpy, root, fb_width, fb_height,
 		      fb_width_mm, fb_height_mm);
+}
 static void
 revert (void)
+{
     int	c;
     /* first disable all crtcs */
     for (c = 0; c < res->ncrtc; c++)
 	crtc_disable (&crtcs[c]);
     /* next reset screen size */
     screen_revert ();
     /* now restore all crtcs */
     for (c = 0; c < res->ncrtc; c++)
 	crtc_revert (&crtcs[c]);
+}
 /*
  * uh-oh, something bad happened in the middle of changing
  * the configuration. Revert to the previous configuration
  * and bail
  */
 static void _X_NORETURN
 panic (Status s, crtc_t *crtc)
+{
     int	    c = crtc->crtc.index;
     const char *message;
     switch (s) {
     case RRSetConfigSuccess:		message = "succeeded";		    break;
     case BadAlloc:			message = "out of memory";	    break;
     case RRSetConfigFailed:		message = "failed";		    break;
     case RRSetConfigInvalidConfigTime:	message = "invalid config time";    break;
     case RRSetConfigInvalidTime:	message = "invalid time";	    break;
     default:				message = "unknown failure";	    break;
+    }
     fprintf (stderr, "%s: Configure crtc %d %s\n", program_name, c, message);
     revert ();
     exit (1);
+}
 static void
 apply (void)
+{
     Status  s;
     int	    c;
     /*
      * Hold the server grabbed while messing with
      * the screen so that apps which notice the resize
      * event and ask for xinerama information from the server
      * receive up-to-date information
      */
     if (grab_server)
 	XGrabServer (dpy);
     /*
      * Turn off any crtcs which are to be disabled or which are
      * larger than the target size
      */
     for (c = 0; c < res->ncrtc; c++)
+    {
 	crtc_t	    *crtc = &crtcs[c];
 	XRRCrtcInfo *crtc_info = crtc->crtc_info;
 	/* if this crtc is already disabled, skip it */
 	if (crtc_info->mode == None)
 	    continue;
 	/*
 	 * If this crtc is to be left enabled, make
 	 * sure the old size fits then new screen
 	 */
 	if (crtc->mode_info)
+	{
 	    XRRModeInfo	*old_mode = find_mode_by_xid (crtc_info->mode);
 	    int x, y, w, h;
 	    box_t bounds;
 	    if (!old_mode)
 		panic (RRSetConfigFailed, crtc);
 	    /* old position and size information */
 	    mode_geometry (old_mode, crtc_info->rotation,
 			   &crtc->current_transform.transform,
 			   &bounds);
 	    x = crtc_info->x + bounds.x1;
 	    y = crtc_info->y + bounds.y1;
 	    w = bounds.x2 - bounds.x1;
 	    h = bounds.y2 - bounds.y1;
 	    /* if it fits, skip it */
 	    if (x + w <= fb_width && y + h <= fb_height)
 		continue;
 	    crtc->changing = True;
+	}
 	s = crtc_disable (crtc);
 	if (s != RRSetConfigSuccess)
 	    panic (s, crtc);
+    }
     /*
      * Set the screen size
      */
     screen_apply ();
     /*
      * Set crtcs
      */
     for (c = 0; c < res->ncrtc; c++)
+    {
 	crtc_t	*crtc = &crtcs[c];
 	s = crtc_apply (crtc);
 	if (s != RRSetConfigSuccess)
 	    panic (s, crtc);
+    }
     set_primary ();
     /*
      * Release the server grab and let all clients
      * respond to the updated state
      */
     if (grab_server)
 	XUngrabServer (dpy);
+}
 /*
  * Use current output state to complete the output list
  */
 static void
 get_outputs (void)
+{
     int		o;
     output_t    *q;
     for (o = 0; o < res->noutput; o++)
+    {
 	XRROutputInfo	*output_info = XRRGetOutputInfo (dpy, res, res->outputs[o]);
 	output_t	*output;
 	name_t		output_name;
 	if (!output_info) fatal ("could not get output 0x%lx information\n", res->outputs[o]);
 	set_name_xid (&output_name, res->outputs[o]);
 	set_name_index (&output_name, o);
 	set_name_string (&output_name, output_info->name);
 	output = find_output (&output_name);
 	if (!output)
+	{
 	    output = add_output ();
 	    set_name_all (&output->output, &output_name);
 	    /*
 	     * When global --automatic mode is set, turn on connected but off
 	     * outputs, turn off disconnected but on outputs
 	     */
 	    if (automatic)
+	    {
 		switch (output_info->connection) {
 		case RR_Connected:
 		    if (!output_info->crtc) {
 			output->changes |= changes_automatic;
 			output->automatic = True;
+		    }
 		    break;
 		case RR_Disconnected:
 		    if (output_info->crtc)
+		    {
 			output->changes |= changes_automatic;
 			output->automatic = True;
+		    }
 		    break;
+		}
+	    }
+	}
 	output->found = True;
 	/*
 	 * Automatic mode -- track connection state and enable/disable outputs
 	 * as necessary
 	 */
 	if (output->automatic)
+	{
 	    switch (output_info->connection) {
 	    case RR_Connected:
 	    case RR_UnknownConnection:
 		if ((!(output->changes & changes_mode)))
+		{
 		    set_name_preferred (&output->mode);
 		    output->changes |= changes_mode;
+		}
 		break;
 	    case RR_Disconnected:
 		if ((!(output->changes & changes_mode)))
+		{
 		    set_name_xid (&output->mode, None);
 		    set_name_xid (&output->crtc, None);
 		    output->changes |= changes_mode;
 		    output->changes |= changes_crtc;
+		}
 		break;
+	    }
+	}
 	set_output_info (output, res->outputs[o], output_info);
+    }
     for (q = all_outputs; q; q = q->next)
+    {
 	if (!q->found)
+	{
 	    fprintf(stderr, "warning: output %s not found; ignoring\n",
 		    q->output.string);
+	}
+    }
+}
 static void
 mark_changing_crtcs (void)
+{
     int	c;
     for (c = 0; c < num_crtcs; c++)
+    {
 	crtc_t	    *crtc = &crtcs[c];
 	int	    o;
 	output_t    *output;
 	/* walk old output list (to catch disables) */
 	for (o = 0; o < crtc->crtc_info->noutput; o++)
+	{
 	    output = find_output_by_xid (crtc->crtc_info->outputs[o]);
 	    if (!output) fatal ("cannot find output 0x%lx\n",
 				crtc->crtc_info->outputs[o]);
 	    if (output->changes)
 		crtc->changing = True;
+	}
 	/* walk new output list */
 	for (o = 0; o < crtc->noutput; o++)
+	{
 	    output = crtc->outputs[o];
 	    if (output->changes)
 		crtc->changing = True;
+	}
+    }
+}
 /*
  * Test whether 'crtc' can be used for 'output'
  */
 static Bool
 check_crtc_for_output (crtc_t *crtc, output_t *output)
+{
     int		c;
     int		l;
     output_t    *other;
     for (c = 0; c < output->output_info->ncrtc; c++)
 	if (output->output_info->crtcs[c] == crtc->crtc.xid)
 	    break;
     if (c == output->output_info->ncrtc)
 	return False;
     for (other = all_outputs; other; other = other->next)
+    {
 	if (other == output)
 	    continue;
 	if (other->mode_info == NULL)
 	    continue;
 	if (other->crtc_info != crtc)
 	    continue;
 	/* see if the output connected to the crtc can clone to this output */
 	for (l = 0; l < output->output_info->nclone; l++)
 	    if (output->output_info->clones[l] == other->output.xid)
 		break;
 	/* not on the list, can't clone */
 	if (l == output->output_info->nclone)
 	    return False;
+    }
     if (crtc->noutput)
+    {
 	/* make sure the state matches */
 	if (crtc->mode_info != output->mode_info)
 	    return False;
 	if (crtc->x != output->x)
 	    return False;
 	if (crtc->y != output->y)
 	    return False;
 	if (crtc->rotation != output->rotation)
 	    return False;
 	if (!equal_transform (&crtc->current_transform, &output->transform))
 	    return False;
+    }
     else if (crtc->crtc_info->noutput)
+    {
 	/* make sure the state matches the already used state */
 	XRRModeInfo *mode = find_mode_by_xid (crtc->crtc_info->mode);
 	if (mode != output->mode_info)
 	    return False;
 	if (crtc->crtc_info->x != output->x)
 	    return False;
 	if (crtc->crtc_info->y != output->y)
 	    return False;
 	if (crtc->crtc_info->rotation != output->rotation)
 	    return False;
+    }
     return True;
+}
 static crtc_t *
 find_crtc_for_output (output_t *output)
+{
     int	    c;
     for (c = 0; c < output->output_info->ncrtc; c++)
+    {
 	crtc_t	    *crtc;
 	crtc = find_crtc_by_xid (output->output_info->crtcs[c]);
 	if (!crtc) fatal ("cannot find crtc 0x%lx\n", output->output_info->crtcs[c]);
 	if (check_crtc_for_output (crtc, output))
 	    return crtc;
+    }
     return NULL;
+}
 static void
 set_positions (void)
+{
     output_t	*output;
     Bool	keep_going;
     Bool	any_set;
     int		min_x, min_y;
     for (;;)
+    {
 	any_set = False;
 	keep_going = False;
 	for (output = all_outputs; output; output = output->next)
+	{
 	    output_t    *relation;
 	    name_t	relation_name;
 	    if (!(output->changes & changes_relation)) continue;
 	    if (output->mode_info == NULL) continue;
 	    init_name (&relation_name);
 	    set_name_string (&relation_name, output->relative_to);
 	    relation = find_output (&relation_name);
 	    if (!relation) fatal ("cannot find output \"%s\"\n", output->relative_to);
 	    if (relation->mode_info == NULL)
+	    {
 		output->x = 0;
 		output->y = 0;
 		output->changes |= changes_position;
 		any_set = True;
 		continue;
+	    }
 	    /*
 	     * Make sure the dependent object has been set in place
 	     */
 	    if ((relation->changes & changes_relation) &&
 		!(relation->changes & changes_position))
+	    {
 		keep_going = True;
 		continue;
+	    }
 	    switch (output->relation) {
 	    case relation_left_of:
 		output->y = relation->y;
 		output->x = relation->x - mode_width (output->mode_info, output->rotation);
 		break;
 	    case relation_right_of:
 		output->y = relation->y;
 		output->x = relation->x + mode_width (relation->mode_info, relation->rotation);
 		break;
 	    case relation_above:
 		output->x = relation->x;
 		output->y = relation->y - mode_height (output->mode_info, output->rotation);
 		break;
 	    case relation_below:
 		output->x = relation->x;
 		output->y = relation->y + mode_height (relation->mode_info, relation->rotation);
 		break;
 	    case relation_same_as:
 		output->x = relation->x;
 		output->y = relation->y;
+	    }
 	    output->changes |= changes_position;
 	    any_set = True;
+	}
 	if (!keep_going)
 	    break;
 	if (!any_set)
 	    fatal ("loop in relative position specifications\n");
+    }
     /*
      * Now normalize positions so the upper left corner of all outputs is at 0,0
      */
     min_x = 32768;
     min_y = 32768;
     for (output = all_outputs; output; output = output->next)
+    {
 	if (output->mode_info == NULL) continue;
 	if (output->x < min_x) min_x = output->x;
 	if (output->y < min_y) min_y = output->y;
+    }
     if (min_x || min_y)
+    {
 	/* move all outputs */
 	for (output = all_outputs; output; output = output->next)
+	{
 	    if (output->mode_info == NULL) continue;
 	    output->x -= min_x;
 	    output->y -= min_y;
 	    output->changes |= changes_position;
+	}
+    }
+}
 static void
 set_screen_size (void)
+{
     output_t	*output;
     Bool	fb_specified = fb_width != 0 && fb_height != 0;
     for (output = all_outputs; output; output = output->next)
+    {
 	XRRModeInfo *mode_info = output->mode_info;
 	int	    x, y, w, h;
 	box_t	    bounds;
 	if (!mode_info) continue;
 	mode_geometry (mode_info, output->rotation,
 		       &output->transform.transform,
 		       &bounds);
 	x = output->x + bounds.x1;
 	y = output->y + bounds.y1;
 	w = bounds.x2 - bounds.x1;
 	h = bounds.y2 - bounds.y1;
 	/* make sure output fits in specified size */
 	if (fb_specified)
+	{
 	    if (x + w > fb_width || y + h > fb_height)
 		warning ("specified screen %dx%d not large enough for output %s (%dx%d+%d+%d)\n",
 			 fb_width, fb_height, output->output.string, w, h, x, y);
+	}
 	/* fit fb to output */
 	else
+	{
 	    XRRPanning *pan;
 	    if (x + w > fb_width)
 		fb_width = x + w;
 	    if (y + h > fb_height)
 		fb_height = y + h;
 	    if (output->changes & changes_panning)
 		pan = &output->panning;
 	    else
 		pan = output->crtc_info ? output->crtc_info->panning_info : NULL;
 	    if (pan && pan->left + pan->width > fb_width)
 		fb_width = pan->left + pan->width;
 	    if (pan && pan->top + pan->height > fb_height)
 		fb_height = pan->top + pan->height;
+	}
+    }
     if (fb_width > maxWidth || fb_height > maxHeight)
         fatal ("screen cannot be larger than %dx%d (desired size %dx%d)\n",
 	       maxWidth, maxHeight, fb_width, fb_height);
     if (fb_specified)
+    {
 	if (fb_width < minWidth || fb_height < minHeight)
 	    fatal ("screen must be at least %dx%d\n", minWidth, minHeight);
+    }
     else
+    {
 	if (fb_width < minWidth) fb_width = minWidth;
 	if (fb_height < minHeight) fb_height = minHeight;
+    }
+}
 static void
 disable_outputs (output_t *outputs)
+{
     while (outputs)
+    {
 	outputs->crtc_info = NULL;
 	outputs = outputs->next;
+    }
+}
 /*
  * find the best mapping from output to crtc available
  */
 static int
 pick_crtcs_score (output_t *outputs)
+{
     output_t	*output;
     int		best_score;
     int		my_score;
     int		score;
     crtc_t	*best_crtc;
     int		c;
     if (!outputs)
 	return 0;
     output = outputs;
     outputs = outputs->next;
     /*
      * Score with this output disabled
      */
     output->crtc_info = NULL;
     best_score = pick_crtcs_score (outputs);
     if (output->mode_info == NULL)
 	return best_score;
     best_crtc = NULL;
     /*
      * Now score with this output any valid crtc
      */
     for (c = 0; c < output->output_info->ncrtc; c++)
+    {
 	crtc_t	    *crtc;
 	crtc = find_crtc_by_xid (output->output_info->crtcs[c]);
 	if (!crtc)
 	    fatal ("cannot find crtc 0x%lx\n", output->output_info->crtcs[c]);
 	/* reset crtc allocation for following outputs */
 	disable_outputs (outputs);
 	if (!check_crtc_for_output (crtc, output))
 	    continue;
 	my_score = 1000;
 	/* slight preference for existing connections */
 	if (crtc == output->current_crtc_info)
 	    my_score++;
 	output->crtc_info = crtc;
 	score = my_score + pick_crtcs_score (outputs);
 	if (score > best_score)
+	{
 	    best_crtc = crtc;
 	    best_score = score;
+	}
+    }
     if (output->crtc_info != best_crtc)
 	output->crtc_info = best_crtc;
     /*
      * Reset other outputs based on this one using the best crtc
      */
     (void) pick_crtcs_score (outputs);
     return best_score;
+}
 /*
  * Pick crtcs for any changing outputs that don't have one
  */
 static void
 pick_crtcs (void)
+{
     output_t	*output;
     /*
      * First try to match up newly enabled outputs with spare crtcs
      */
     for (output = all_outputs; output; output = output->next)
+    {
 	if (output->changes && output->mode_info)
+	{
 	    if (output->crtc_info) {
 		if (output->crtc_info->crtc_info->noutput > 0 &&
 		    (output->crtc_info->crtc_info->noutput > 1 ||
 		     output != find_output_by_xid (output->crtc_info->crtc_info->outputs[0])))
 		    break;
 	    } else {
 		output->crtc_info = find_crtc_for_output (output);
 		if (!output->crtc_info)
 		    break;
+	    }
+	}
+    }
     /*
      * Everyone is happy
      */
     if (!output)
 	return;
     /*
      * When the simple way fails, see if there is a way
      * to swap crtcs around and make things work
      */
     for (output = all_outputs; output; output = output->next)
 	output->current_crtc_info = output->crtc_info;
     pick_crtcs_score (all_outputs);
     for (output = all_outputs; output; output = output->next)
+    {
 	if (output->mode_info && !output->crtc_info)
 	    fatal ("cannot find crtc for output %s\n", output->output.string);
 	if (!output->changes && output->crtc_info != output->current_crtc_info)
 	    output->changes |= changes_crtc;
+    }
+}
 static int
 check_strtol(char *s)
+{
     char *endptr;
     int result = strtol(s, &endptr, 10);
     if (s == endptr)
 	argerr ("failed to parse '%s' as a number\n", s);
     return result;
+}
 static double
 check_strtod(char *s)
+{
     char *endptr;
     double result = strtod(s, &endptr);
     if (s == endptr)
 	argerr ("failed to parse '%s' as a number\n", s);
     return result;
+}
 static void *
 property_values_from_string(const char *str, const Atom type, const int format,
                             int *returned_nitems)
+{
     char *token, *tmp;
     void *returned_bytes = NULL;
     int nitems = 0, bytes_per_item = format / 8;
     if ((type != XA_INTEGER && type != XA_CARDINAL) ||
 	(format != 8 && format != 16 && format != 32))
+    {
 	return NULL;
+    }
     tmp = strdup (str);
     for (token = strtok (tmp, ","); token; token = strtok (NULL, ","))
+    {
 	char *endptr;
 	long int val = strtol (token, &endptr, 0);
 	if (token == endptr || *endptr != '\0')
+	{
 	    argerr ("failed to parse '%s' as a number\n", token);
+	}
 	returned_bytes = realloc (returned_bytes, (nitems + 1) * bytes_per_item);
 	if (type == XA_INTEGER && format == 8)
+	{
 	    int8_t *ptr = returned_bytes;
 	    ptr[nitems] = (int8_t) val;
+	}
 	else if (type == XA_INTEGER && format == 16)
+	{
 	    int16_t *ptr = returned_bytes;
 	    ptr[nitems] = (int16_t) val;
+	}
 	else if (type == XA_INTEGER && format == 32)
+	{
 	    int32_t *ptr = returned_bytes;
 	    ptr[nitems] = (int32_t) val;
+	}
 	else if (type == XA_CARDINAL && format == 8)
+	{
 	    uint8_t *ptr = returned_bytes;
 	    ptr[nitems] = (uint8_t) val;
+	}
 	else if (type == XA_CARDINAL && format == 16)
+	{
 	    uint16_t *ptr = returned_bytes;
 	    ptr[nitems] = (uint16_t) val;
+	}
 	else if (type == XA_CARDINAL && format == 32)
+	{
 	    uint32_t *ptr = returned_bytes;
 	    ptr[nitems] = (uint32_t) val;
+	}
 	else
+	{
 	    free (tmp);
 	    free (returned_bytes);
 	    return NULL;
+	}
 	nitems++;
+    }
     free (tmp);
     *returned_nitems = nitems;
     return returned_bytes;
+}
 static void
 print_output_property_value(Bool is_edid,
                             int value_format, /* 8, 16, 32 */
                             Atom value_type,  /* XA_{ATOM,INTEGER,CARDINAL} */
                             const void *value_bytes)
+{
     /* special-case the EDID */
     if (is_edid && value_format == 8)
+    {
 	const uint8_t *val = value_bytes;
 	printf ("%02" PRIx8, *val);
 	return;
+    }
     if (value_type == XA_ATOM && value_format == 32)
+    {
 	const Atom *val = value_bytes;
 	char *str = XGetAtomName (dpy, *val);
 	if (str != NULL)
+	{
 	    printf ("%s", str);
 	    XFree (str);
 	    return;
+	}
+    }
     if (value_type == XA_INTEGER)
+    {
 	if (value_format == 8)
+	{
 	    const int8_t *val = value_bytes;
 	    printf ("%" PRId8, *val);
 	    return;
+	}
 	if (value_format == 16)
+	{
 	    const int16_t *val = value_bytes;
 	    printf ("%" PRId16, *val);
 	    return;
+	}
 	if (value_format == 32)
+	{
 	    const int32_t *val = value_bytes;
 	    printf ("%" PRId32, *val);
 	    return;
+	}
+    }
     if (value_type == XA_CARDINAL)
+    {
 	if (value_format == 8)
+	{
 	    const uint8_t *val = value_bytes;
 	    printf ("%" PRIu8, *val);
 	    return;
+	}
 	if (value_format == 16)
+	{
 	    const uint16_t *val = value_bytes;
 	    printf ("%" PRIu16, *val);
 	    return;
+	}
 	if (value_format == 32)
+	{
 	    const uint32_t *val = value_bytes;
 	    printf ("%" PRIu32, *val);
 	    return;
+	}
+    }
     printf ("?");
+}
 static void
 get_providers (void)
+{
     XRRProviderResources *pr;
     int i;
     if (!has_1_4 || providers)
 	return;
     pr = XRRGetProviderResources(dpy, root);
     num_providers = pr->nproviders;
     providers = calloc (num_providers, sizeof (provider_t));
     if (!providers)
 	fatal ("out of memory\n");
     for (i = 0; i < num_providers; i++) {
 	provider_t *provider = &providers[i];
 	name_t *name = &provider->provider;
 	XRRProviderInfo *info = XRRGetProviderInfo(dpy, res, pr->providers[i]);
 	provider->info = info;
 	set_name_xid (name, pr->providers[i]);
 	set_name_index (name, i);
 	set_name_string (name, info->name);
+   }
    XRRFreeProviderResources(pr);
+}
 static provider_t *
 find_provider (name_t *name)
+{
     int i;
     for (i = 0; i < num_providers; i++) {
 	provider_t *p = &providers[i];
 	name_kind_t common = name->kind & p->provider.kind;
 	if ((common & name_xid) && name->xid == p->provider.xid)
 	    return p;
 	if ((common & name_string) && !strcmp (name->string, p->provider.string))
 	    return p;
 	if ((common & name_index) && name->index == p->provider.index)
 	    return p;
+    }
     printf ("Could not find provider with ");
     print_name (name);
     printf ("\n");
     exit (1);
+}
 int
 main (int argc, char **argv)
+{
     XRRScreenSize *sizes;
     XRRScreenConfiguration *sc;
     int		nsize;
     int		nrate;
     short		*rates;
     Status	status = RRSetConfigFailed;
     int		rot = -1;
     int		query = False;
     int		action_requested = False;
     Rotation	current_rotation;
     XEvent	event;
     XRRScreenChangeNotifyEvent *sce;
     char          *display_name = NULL;
     int 		i;
     SizeID	current_size;
     short	current_rate;
     double    	rate = -1;
     int		size = -1;
     int		dirind = 0;
     Bool	setit = False;
     Bool    	version = False;
     int		event_base, error_base;
     int		reflection = 0;
     int		width = 0, height = 0;
     Bool    	have_pixel_size = False;
     int		ret = 0;
     output_t	*config_output = NULL;
     Bool    	setit_1_2 = False;
     Bool    	query_1_2 = False;
     Bool	modeit = False;
     Bool	propit = False;
     Bool	query_1 = False;
     Bool	list_providers = False;
     Bool        provsetoutsource = False;
     Bool        provsetoffsink = False;
     int		major, minor;
     Bool	current = False;
     program_name = argv[0];
     for (i = 1; i < argc; i++) {
 	if (!strcmp ("-display", argv[i]) || !strcmp ("-d", argv[i])) {
 	    if (++i >= argc) argerr ("%s requires an argument\n", argv[i-1]);
 	    display_name = argv[i];
 	    continue;
+	}
 	if (!strcmp("-help", argv[i]) || !strcmp("--help", argv[i])) {
 	    usage();
 	    exit(0);
+	}
 	if (!strcmp ("--verbose", argv[i])) {
 	    verbose = True;
 	    continue;
+	}
 	if (!strcmp ("--dryrun", argv[i])) {