Reindent and reformat pixman-linear-gradient.c

diff --git a/pixman/pixman-linear-gradient.c b/pixman/pixman-linear-gradient.c
index 54330e7..8c4a8ff 100644 (file)
--- a/pixman/pixman-linear-gradient.c
+++ b/pixman/pixman-linear-gradient.c
@@ -30,23 +30,25 @@
 
 static source_pict_class_t
 linear_gradient_classify (pixman_image_t *image,
-                         int             x,
-                         int             y,
-                         int             width,
-                         int             height)
+                          int             x,
+                          int             y,
+                          int             width,
+                          int             height)
 {
     linear_gradient_t *linear = (linear_gradient_t *)image;
-    pixman_vector_t   v;
+    pixman_vector_t v;
     pixman_fixed_32_32_t l;
     pixman_fixed_48_16_t dx, dy, a, b, off;
     pixman_fixed_48_16_t factors[4];
-    int             i;
-    
+    int i;
+
     image->source.class = SOURCE_IMAGE_CLASS_UNKNOWN;
-    
+
     dx = linear->p2.x - linear->p1.x;
     dy = linear->p2.y - linear->p1.y;
+
     l = dx * dx + dy * dy;
+
     if (l)
     {
        a = (dx << 32) / l;
@@ -56,40 +58,45 @@ linear_gradient_classify (pixman_image_t *image,
     {
        a = b = 0;
     }
-    
+
     off = (-a * linear->p1.x
-          -b * linear->p1.y) >> 16;
-    
+           -b * linear->p1.y) >> 16;
+
     for (i = 0; i < 3; i++)
     {
        v.vector[0] = pixman_int_to_fixed ((i % 2) * (width  - 1) + x);
        v.vector[1] = pixman_int_to_fixed ((i / 2) * (height - 1) + y);
        v.vector[2] = pixman_fixed_1;
-       
+
        if (image->common.transform)
        {
            if (!pixman_transform_point_3d (image->common.transform, &v))
            {
                image->source.class = SOURCE_IMAGE_CLASS_UNKNOWN;
-               
+
                return image->source.class;
            }
        }
-       
+
        factors[i] = ((a * v.vector[0] + b * v.vector[1]) >> 16) + off;
     }
-    
+
     if (factors[2] == factors[0])
        image->source.class = SOURCE_IMAGE_CLASS_HORIZONTAL;
     else if (factors[1] == factors[0])
        image->source.class = SOURCE_IMAGE_CLASS_VERTICAL;
-    
+
     return image->source.class;
 }
 
 static void
-linear_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width, uint32_t *buffer,
-                                const uint32_t *mask, uint32_t mask_bits)
+linear_gradient_get_scanline_32 (pixman_image_t *image,
+                                 int             x,
+                                 int             y,
+                                 int             width,
+                                 uint32_t *      buffer,
+                                 const uint32_t *mask,
+                                 uint32_t        mask_bits)
 {
     pixman_vector_t v, unit;
     pixman_fixed_32_32_t l;
@@ -97,83 +104,102 @@ linear_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
     gradient_t *gradient = (gradient_t *)image;
     source_image_t *source = (source_image_t *)image;
     linear_gradient_t *linear = (linear_gradient_t *)image;
-    uint32_t       *end = buffer + width;
-    pixman_gradient_walker_t  walker;
-    
+    uint32_t *end = buffer + width;
+    pixman_gradient_walker_t walker;
+
     _pixman_gradient_walker_init (&walker, gradient, source->common.repeat);
-    
+
     /* reference point is the center of the pixel */
-    v.vector[0] = pixman_int_to_fixed(x) + pixman_fixed_1/2;
-    v.vector[1] = pixman_int_to_fixed(y) + pixman_fixed_1/2;
+    v.vector[0] = pixman_int_to_fixed (x) + pixman_fixed_1 / 2;
+    v.vector[1] = pixman_int_to_fixed (y) + pixman_fixed_1 / 2;
     v.vector[2] = pixman_fixed_1;
-    if (source->common.transform) {
+
+    if (source->common.transform)
+    {
        if (!pixman_transform_point_3d (source->common.transform, &v))
            return;
+       
        unit.vector[0] = source->common.transform->matrix[0][0];
        unit.vector[1] = source->common.transform->matrix[1][0];
        unit.vector[2] = source->common.transform->matrix[2][0];
-    } else {
+    }
+    else
+    {
        unit.vector[0] = pixman_fixed_1;
        unit.vector[1] = 0;
        unit.vector[2] = 0;
     }
-    
+
     dx = linear->p2.x - linear->p1.x;
     dy = linear->p2.y - linear->p1.y;
-    l = dx*dx + dy*dy;
-    if (l != 0) {
+
+    l = dx * dx + dy * dy;
+
+    if (l != 0)
+    {
        a = (dx << 32) / l;
        b = (dy << 32) / l;
-       off = (-a*linear->p1.x - b*linear->p1.y)>>16;
+       off = (-a * linear->p1.x
+              -b * linear->p1.y) >> 16;
     }
-    if (l == 0  || (unit.vector[2] == 0 && v.vector[2] == pixman_fixed_1)) {
+
+    if (l == 0 || (unit.vector[2] == 0 && v.vector[2] == pixman_fixed_1))
+    {
        pixman_fixed_48_16_t inc, t;
+
        /* affine transformation only */
-       if (l == 0) {
+       if (l == 0)
+       {
            t = 0;
            inc = 0;
-       } else {
-           t = ((a*v.vector[0] + b*v.vector[1]) >> 16) + off;
+       }
+       else
+       {
+           t = ((a * v.vector[0] + b * v.vector[1]) >> 16) + off;
            inc = (a * unit.vector[0] + b * unit.vector[1]) >> 16;
        }
-       
+
        if (source->class == SOURCE_IMAGE_CLASS_VERTICAL)
        {
            register uint32_t color;
-           
-           color = _pixman_gradient_walker_pixel( &walker, t );
+
+           color = _pixman_gradient_walker_pixel (&walker, t);
            while (buffer < end)
-               *(buffer++) = color;
+               *buffer++ = color;
        }
        else
        {
-           if (!mask) {
+           if (!mask)
+           {
                while (buffer < end)
                {
-                   *(buffer) = _pixman_gradient_walker_pixel (&walker, t);
-                   buffer += 1;
-                   t      += inc;
+                   *buffer++ = _pixman_gradient_walker_pixel (&walker, t);
+                   
+                   t += inc;
                }
-           } else {
-               while (buffer < end) {
+           }
+           else
+           {
+               while (buffer < end)
+               {
                    if (*mask++ & mask_bits)
-                   {
-                       *(buffer) = _pixman_gradient_walker_pixel (&walker, t);
-                   }
-                   buffer += 1;
-                   t      += inc;
+                       *buffer = _pixman_gradient_walker_pixel (&walker, t);
+
+                   buffer++;
+                   t += inc;
                }
            }
        }
     }
-    else /* projective transformation */
+    else
     {
+       /* projective transformation */
        pixman_fixed_48_16_t t;
-       
+
        if (source->class == SOURCE_IMAGE_CLASS_VERTICAL)
        {
            register uint32_t color;
-           
+
            if (v.vector[2] == 0)
            {
                t = 0;
@@ -181,15 +207,15 @@ linear_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
            else
            {
                pixman_fixed_48_16_t x, y;
-               
+
                x = ((pixman_fixed_48_16_t) v.vector[0] << 16) / v.vector[2];
                y = ((pixman_fixed_48_16_t) v.vector[1] << 16) / v.vector[2];
                t = ((a * x + b * y) >> 16) + off;
            }
-           
-           color = _pixman_gradient_walker_pixel( &walker, t );
+
+           color = _pixman_gradient_walker_pixel (&walker, t);
            while (buffer < end)
-               *(buffer++) = color;
+               *buffer++ = color;
        }
        else
        {
@@ -197,17 +223,23 @@ linear_gradient_get_scanline_32 (pixman_image_t *image, int x, int y, int width,
            {
                if (!mask || *mask++ & mask_bits)
                {
-                   if (v.vector[2] == 0) {
+                   if (v.vector[2] == 0)
+                   {
                        t = 0;
-                   } else {
+                   }
+                   else
+                   {
                        pixman_fixed_48_16_t x, y;
                        x = ((pixman_fixed_48_16_t)v.vector[0] << 16) / v.vector[2];
                        y = ((pixman_fixed_48_16_t)v.vector[1] << 16) / v.vector[2];
-                       t = ((a*x + b*y) >> 16) + off;
+                       t = ((a * x + b * y) >> 16) + off;
                    }
-                   *(buffer) = _pixman_gradient_walker_pixel (&walker, t);
+                   
+                   *buffer = _pixman_gradient_walker_pixel (&walker, t);
                }
+               
                ++buffer;
+               
                v.vector[0] += unit.vector[0];
                v.vector[1] += unit.vector[1];
                v.vector[2] += unit.vector[2];
@@ -224,38 +256,39 @@ linear_gradient_property_changed (pixman_image_t *image)
 }
 
 PIXMAN_EXPORT pixman_image_t *
-pixman_image_create_linear_gradient (pixman_point_fixed_t         *p1,
-                                    pixman_point_fixed_t         *p2,
-                                    const pixman_gradient_stop_t *stops,
-                                    int                           n_stops)
+pixman_image_create_linear_gradient (pixman_point_fixed_t *        p1,
+                                     pixman_point_fixed_t *        p2,
+                                     const pixman_gradient_stop_t *stops,
+                                     int                           n_stops)
 {
     pixman_image_t *image;
     linear_gradient_t *linear;
-    
+
     return_val_if_fail (n_stops >= 2, NULL);
-    
-    image = _pixman_image_allocate();
-    
+
+    image = _pixman_image_allocate ();
+
     if (!image)
        return NULL;
-    
+
     linear = &image->linear;
-    
+
     if (!_pixman_init_gradient (&linear->common, stops, n_stops))
     {
        free (image);
        return NULL;
     }
-    
+
     linear->p1 = *p1;
     linear->p2 = *p2;
-    
+
     image->type = LINEAR;
     image->source.class = SOURCE_IMAGE_CLASS_UNKNOWN;
     image->common.classify = linear_gradient_classify;
     image->common.property_changed = linear_gradient_property_changed;
-    
+
     linear_gradient_property_changed (image);
-    
+
     return image;
 }
+