#include "../test/utils.h"

#include "gtk-utils.h"

#define NUM_GRADIENTS 9

#define NUM_STOPS 3

#define NUM_REPEAT 4

#define SIZE 128

#define WIDTH (SIZE * NUM_GRADIENTS)

#define HEIGHT (SIZE * NUM_REPEAT)

/*

 * We want to test all the possible relative positions of the start

 * and end circle:

 *

 *  - The start circle can be smaller/equal/bigger than the end

 *    circle. A radial gradient can be classified in one of these

 *    three cases depending on the sign of dr.

 *

 *  - The smaller circle can be completely inside/internally

 *    tangent/outside (at least in part) of the bigger circle. This

 *    classification is the same as the one which can be computed by

 *    examining the sign of a = (dx^2 + dy^2 - dr^2).

 *

 *  - If the two circles have the same size, neither can be inside or

 *    internally tangent

 *

 * This test draws radial gradients whose circles always have the same

 * centers (0, 0) and (1, 0), but with different radiuses. From left

 * to right:

 *

 * - Degenerate start circle completely inside the end circle

 *     0.00 -> 1.75; dr = 1.75 > 0; a = 1 - 1.75^2 < 0

 *

 * - Small start circle completely inside the end circle

 *     0.25 -> 1.75; dr =  1.5 > 0; a = 1 - 1.50^2 < 0

 *

 * - Small start circle internally tangent to the end circle

 *     0.50 -> 1.50; dr =  1.0 > 0; a = 1 - 1.00^2 = 0

 *

 * - Small start circle outside of the end circle

 *     0.50 -> 1.00; dr =  0.5 > 0; a = 1 - 0.50^2 > 0

 *

 * - Start circle with the same size as the end circle

 *     1.00 -> 1.00; dr =  0.0 = 0; a = 1 - 0.00^2 > 0

 *

 * - Small end circle outside of the start circle

 *     1.00 -> 0.50; dr = -0.5 > 0; a = 1 - 0.50^2 > 0

 *

 * - Small end circle internally tangent to the start circle

 *     1.50 -> 0.50; dr = -1.0 > 0; a = 1 - 1.00^2 = 0

 *

 * - Small end circle completely inside the start circle

 *     1.75 -> 0.25; dr = -1.5 > 0; a = 1 - 1.50^2 < 0

 *

 * - Degenerate end circle completely inside the start circle

 *     0.00 -> 1.75; dr = 1.75 > 0; a = 1 - 1.75^2 < 0

 *

 */

const static double radiuses[NUM_GRADIENTS] = {

    0.00,

    0.25,

    0.50,

    0.50,

    1.00,

    1.00,

    1.50,

    1.75,

    1.75

};

#define double_to_color(x)					\

    (((uint32_t) ((x)*65536)) - (((uint32_t) ((x)*65536)) >> 16))

#define PIXMAN_STOP(offset,r,g,b,a)		\

    { pixman_double_to_fixed (offset),		\

	{					\

	double_to_color (r),			\

	double_to_color (g),			\

	double_to_color (b),			\

	double_to_color (a)			\

	}					\

    }

static const pixman_gradient_stop_t stops[NUM_STOPS] = {

    PIXMAN_STOP (0.0,        1, 0, 0, 0.75),

    PIXMAN_STOP (0.70710678, 0, 1, 0, 0),

    PIXMAN_STOP (1.0,        0, 0, 1, 1)

};

static pixman_image_t *

create_radial (int index)

{

    pixman_point_fixed_t p0, p1;

    pixman_fixed_t r0, r1;

    double x0, x1, radius0, radius1, left, right, center;

    x0 = 0;

    x1 = 1;

    radius0 = radiuses[index];

    radius1 = radiuses[NUM_GRADIENTS - index - 1];

    /* center the gradient */

    left = MIN (x0 - radius0, x1 - radius1);

    right = MAX (x0 + radius0, x1 + radius1);

    center = (left + right) * 0.5;

    x0 -= center;

    x1 -= center;

    /* scale to make it fit within a 1x1 rect centered in (0,0) */

    x0 *= 0.25;

    x1 *= 0.25;

    radius0 *= 0.25;

    radius1 *= 0.25;

    p0.x = pixman_double_to_fixed (x0);

    p0.y = pixman_double_to_fixed (0);

    p1.x = pixman_double_to_fixed (x1);

    p1.y = pixman_double_to_fixed (0);

    r0 = pixman_double_to_fixed (radius0);

    r1 = pixman_double_to_fixed (radius1);

    return pixman_image_create_radial_gradient (&p0, &p1,

						r0, r1,

						stops, NUM_STOPS);

}

static const pixman_repeat_t repeat[NUM_REPEAT] = {

    PIXMAN_REPEAT_NONE,

    PIXMAN_REPEAT_NORMAL,

    PIXMAN_REPEAT_REFLECT,

    PIXMAN_REPEAT_PAD

};

int

main (int argc, char **argv)

{

    pixman_transform_t transform;

    pixman_image_t *src_img, *dest_img;

    int i, j;

    enable_divbyzero_exceptions ();

    dest_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,

					 WIDTH, HEIGHT,

					 NULL, 0);

    draw_checkerboard (dest_img, 25, 0xffaaaaaa, 0xffbbbbbb);

    pixman_transform_init_identity (&transform);

    /*

     * The create_radial() function returns gradients centered in the

     * origin and whose interesting part fits a 1x1 square. We want to

     * paint these gradients on a SIZExSIZE square and to make things

     * easier we want the origin in the top-left corner of the square

     * we want to see.

     */

    pixman_transform_translate (NULL, &transform,

				pixman_double_to_fixed (0.5),

				pixman_double_to_fixed (0.5));

    pixman_transform_scale (NULL, &transform,

			    pixman_double_to_fixed (SIZE),

			    pixman_double_to_fixed (SIZE));

    /*

     * Gradients are evaluated at the center of each pixel, so we need

     * to translate by half a pixel to trigger some interesting

     * cornercases. In particular, the original implementation of PDF

     * radial gradients tried to divide by 0 when using this transform

     * on the "tangent circles" cases.

     */

    pixman_transform_translate (NULL, &transform,

				pixman_double_to_fixed (0.5),

				pixman_double_to_fixed (0.5));

    for (i = 0; i < NUM_GRADIENTS; i++)

    {

	src_img = create_radial (i);

	pixman_image_set_transform (src_img, &transform);

	for (j = 0; j < NUM_REPEAT; j++)

	{

	    pixman_image_set_repeat (src_img, repeat[j]);

	    pixman_image_composite32 (PIXMAN_OP_OVER,

				      src_img,

				      NULL,

				      dest_img,

				      0, 0,

				      0, 0,

				      i * SIZE, j * SIZE,

				      SIZE, SIZE);

	}

	pixman_image_unref (src_img);

    }

    show_image (dest_img);

    pixman_image_unref (dest_img);

    return 0;

}