test/composite-test.c

   1 #include <gtk/gtk.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include "pixman.h"
   5 #include "gtk-utils.h"
   6
   7 #define WIDTH   60
   8 #define HEIGHT  60
   9
  10 typedef struct {
  11     const char *name;
  12     pixman_op_t op;
  13 } operator_t;
  14
  15 static const operator_t operators[] = {
  16     { "CLEAR",          PIXMAN_OP_CLEAR },
  17     { "SRC",            PIXMAN_OP_SRC },
  18     { "DST",            PIXMAN_OP_DST },
  19     { "OVER",           PIXMAN_OP_OVER },
  20     { "OVER_REVERSE",   PIXMAN_OP_OVER_REVERSE },
  21     { "IN",             PIXMAN_OP_IN },
  22     { "IN_REVERSE",     PIXMAN_OP_IN_REVERSE },
  23     { "OUT",            PIXMAN_OP_OUT },
  24     { "OUT_REVERSE",    PIXMAN_OP_OUT_REVERSE },
  25     { "ATOP",           PIXMAN_OP_ATOP },
  26     { "ATOP_REVERSE",   PIXMAN_OP_ATOP_REVERSE },
  27     { "XOR",            PIXMAN_OP_XOR },
  28     { "ADD",            PIXMAN_OP_ADD },
  29     { "SATURATE",       PIXMAN_OP_SATURATE },
  30
  31     { "MULTIPLY",       PIXMAN_OP_MULTIPLY },
  32     { "SCREEN",         PIXMAN_OP_SCREEN },
  33     { "OVERLAY",        PIXMAN_OP_OVERLAY },
  34     { "DARKEN",         PIXMAN_OP_DARKEN },
  35     { "LIGHTEN",        PIXMAN_OP_LIGHTEN },
  36     { "COLOR_DODGE",    PIXMAN_OP_COLOR_DODGE },
  37     { "COLOR_BURN",     PIXMAN_OP_COLOR_BURN },
  38     { "HARD_LIGHT",     PIXMAN_OP_HARD_LIGHT },
  39     { "SOFT_LIGHT",     PIXMAN_OP_SOFT_LIGHT },
  40     { "DIFFERENCE",     PIXMAN_OP_DIFFERENCE },
  41     { "EXCLUSION",      PIXMAN_OP_EXCLUSION },
  42     { "HSL_HUE",        PIXMAN_OP_HSL_HUE },
  43     { "HSL_SATURATION", PIXMAN_OP_HSL_SATURATION },
  44     { "HSL_COLOR",      PIXMAN_OP_HSL_COLOR },
  45     { "HSL_LUMINOSITY", PIXMAN_OP_HSL_LUMINOSITY },
  46 };
  47
  48 static uint32_t
  49 reader (const void *src, int size)
  50 {
  51     switch (size)
  52     {
  53     case 1:
  54         return *(uint8_t *)src;
  55     case 2:
  56         return *(uint16_t *)src;
  57     case 4:
  58         return *(uint32_t *)src;
  59     default:
  60         g_assert_not_reached();
  61     }
  62 }
  63
  64 static void
  65 writer (void *src, uint32_t value, int size)
  66 {
  67     switch (size)
  68     {
  69     case 1:
  70         *(uint8_t *)src = value;
  71         break;
  72
  73     case 2:
  74         *(uint16_t *)src = value;
  75         break;
  76
  77     case 4:
  78         *(uint32_t *)src = value;
  79         break;
  80
  81     default:
  82         break;
  83     }
  84 }
  85
  86 int
  87 main (int argc, char **argv)
  88 {
  89 #define d2f pixman_double_to_fixed
  90
  91     GtkWidget *window, *swindow;
  92     GtkWidget *table;
  93     uint32_t *dest = malloc (WIDTH * HEIGHT * 4);
  94     uint32_t *src = malloc (WIDTH * HEIGHT * 4);
  95     pixman_image_t *src_img;
  96     pixman_image_t *dest_img;
  97     pixman_point_fixed_t p1 = { -10 << 0, 0 };
  98     pixman_point_fixed_t p2 = { WIDTH << 16, (HEIGHT - 10) << 16 };
  99     uint16_t full = 0xcfff;
 100     uint16_t low  = 0x5000;
 101     uint16_t alpha = 0xffff;
 102     pixman_gradient_stop_t stops[6] =
 103     {
 104         { d2f (0.0), { full, low, low, alpha } },
 105         { d2f (0.25), { full, full, low, alpha } },
 106         { d2f (0.4), { low, full, low, alpha } },
 107         { d2f (0.5), { low, full, full, alpha } },
 108         { d2f (0.8), { low, low, full, alpha } },
 109         { d2f (1.0), { full, low, full, alpha } },
 110     };
 111
 112
 113     int i;
 114
 115     gtk_init (&argc, &argv);
 116
 117     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 118
 119     gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
 120
 121     g_signal_connect (window, "delete-event",
 122                       G_CALLBACK (gtk_main_quit),
 123                       NULL);
 124     table = gtk_table_new (G_N_ELEMENTS (operators) / 6, 6, TRUE);
 125
 126     src_img = pixman_image_create_linear_gradient (&p1, &p2, stops,
 127                                                    sizeof (stops) / sizeof (stops[0]));
 128
 129     pixman_image_set_repeat (src_img, PIXMAN_REPEAT_PAD);
 130
 131     dest_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,
 132                                          WIDTH, HEIGHT,
 133                                          dest,
 134                                          WIDTH * 4);
 135     pixman_image_set_accessors (dest_img, reader, writer);
 136
 137     for (i = 0; i < G_N_ELEMENTS (operators); ++i)
 138     {
 139         GtkWidget *image;
 140         GdkPixbuf *pixbuf;
 141         GtkWidget *vbox;
 142         GtkWidget *label;
 143         int j, k;
 144
 145         vbox = gtk_vbox_new (FALSE, 0);
 146
 147         label = gtk_label_new (operators[i].name);
 148         gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 6);
 149         gtk_widget_show (label);
 150
 151         for (j = 0; j < HEIGHT; ++j)
 152         {
 153             for (k = 0; k < WIDTH; ++k)
 154                 dest[j * WIDTH + k] = 0x7f6f6f00;
 155         }
 156         pixman_image_composite (operators[i].op, src_img, NULL, dest_img,
 157                                 0, 0, 0, 0, 0, 0, WIDTH, HEIGHT);
 158         pixbuf = pixbuf_from_argb32 (pixman_image_get_data (dest_img), TRUE,
 159                                      WIDTH, HEIGHT, WIDTH * 4);
 160         image = gtk_image_new_from_pixbuf (pixbuf);
 161         gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
 162         gtk_widget_show (image);
 163
 164         gtk_table_attach_defaults (GTK_TABLE (table), vbox,
 165                                    i % 6, (i % 6) + 1, i / 6, (i / 6) + 1);
 166         gtk_widget_show (vbox);
 167
 168         g_object_unref (pixbuf);
 169     }
 170
 171     pixman_image_unref (src_img);
 172     free (src);
 173     pixman_image_unref (dest_img);
 174     free (dest);
 175
 176     swindow = gtk_scrolled_window_new (NULL, NULL);
 177     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
 178                                     GTK_POLICY_AUTOMATIC,
 179                                     GTK_POLICY_AUTOMATIC);
 180
 181     gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), table);
 182     gtk_widget_show (table);
 183
 184     gtk_container_add (GTK_CONTAINER (window), swindow);
 185     gtk_widget_show (swindow);
 186
 187     gtk_widget_show (window);
 188
 189     gtk_main ();
 190
 191     return 0;
 192 }