Pileus Git - ~andy/gtk/blob - docs/tools/shadow.c

   1 #include "shadow.h"
   2 #include <math.h>
   3
   4 #define BLUR_RADIUS 5
   5 #define SHADOW_OFFSET (BLUR_RADIUS * 4 / 5)
   6 #define SHADOW_OPACITY 0.75
   7
   8 typedef struct {
   9   int size;
  10   double *data;
  11 } ConvFilter;
  12
  13 static double
  14 gaussian (double x, double y, double r)
  15 {
  16     return ((1 / (2 * M_PI * r)) *
  17             exp ((- (x * x + y * y)) / (2 * r * r)));
  18 }
  19
  20 static ConvFilter *
  21 create_blur_filter (int radius)
  22 {
  23   ConvFilter *filter;
  24   int x, y;
  25   double sum;
  26
  27   filter = g_new0 (ConvFilter, 1);
  28   filter->size = radius * 2 + 1;
  29   filter->data = g_new (double, filter->size * filter->size);
  30
  31   sum = 0.0;
  32
  33   for (y = 0 ; y < filter->size; y++)
  34     {
  35       for (x = 0 ; x < filter->size; x++)
  36         {
  37           sum += filter->data[y * filter->size + x] = gaussian (x - (filter->size >> 1),
  38                                                                 y - (filter->size >> 1),
  39                                                                 radius);
  40         }
  41     }
  42
  43   for (y = 0; y < filter->size; y++)
  44     {
  45       for (x = 0; x < filter->size; x++)
  46         {
  47           filter->data[y * filter->size + x] /= sum;
  48         }
  49     }
  50
  51   return filter;
  52
  53 }
  54
  55 static GdkPixbuf *
  56 create_shadow (GdkPixbuf *src)
  57 {
  58   int x, y, i, j;
  59   int width, height;
  60   GdkPixbuf *dest;
  61   static ConvFilter *filter = NULL;
  62   int src_rowstride, dest_rowstride;
  63   int src_bpp, dest_bpp;
  64
  65   guchar *src_pixels, *dest_pixels;
  66
  67   if (!filter)
  68     filter = create_blur_filter (BLUR_RADIUS);
  69
  70   width = gdk_pixbuf_get_width (src) + BLUR_RADIUS * 2 + SHADOW_OFFSET;
  71   height = gdk_pixbuf_get_height (src) + BLUR_RADIUS * 2 + SHADOW_OFFSET;
  72
  73   dest = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (src),
  74                          gdk_pixbuf_get_has_alpha (src),
  75                          gdk_pixbuf_get_bits_per_sample (src),
  76                          width, height);
  77   gdk_pixbuf_fill (dest, 0);
  78   src_pixels = gdk_pixbuf_get_pixels (src);
  79   src_rowstride = gdk_pixbuf_get_rowstride (src);
  80   src_bpp = gdk_pixbuf_get_has_alpha (src) ? 4 : 3;
  81
  82   dest_pixels = gdk_pixbuf_get_pixels (dest);
  83   dest_rowstride = gdk_pixbuf_get_rowstride (dest);
  84   dest_bpp = gdk_pixbuf_get_has_alpha (dest) ? 4 : 3;
  85
  86   for (y = 0; y < height; y++)
  87     {
  88       for (x = 0; x < width; x++)
  89         {
  90           int sumr = 0, sumg = 0, sumb = 0, suma = 0;
  91
  92           for (i = 0; i < filter->size; i++)
  93             {
  94               for (j = 0; j < filter->size; j++)
  95                 {
  96                   int src_x, src_y;
  97
  98                   src_y = -(BLUR_RADIUS + SHADOW_OFFSET) + y - (filter->size >> 1) + i;
  99                   src_x = -(BLUR_RADIUS + SHADOW_OFFSET) + x - (filter->size >> 1) + j;
 100
 101                   if (src_y < 0 || src_y > gdk_pixbuf_get_height (src) ||
 102                       src_x < 0 || src_x > gdk_pixbuf_get_width (src))
 103                     continue;
 104
 105                   sumr += src_pixels [src_y * src_rowstride +
 106                                       src_x * src_bpp + 0] *
 107                     filter->data [i * filter->size + j];
 108                   sumg += src_pixels [src_y * src_rowstride +
 109                                       src_x * src_bpp + 1] *
 110                     filter->data [i * filter->size + j];
 111
 112                   sumb += src_pixels [src_y * src_rowstride +
 113                                       src_x * src_bpp + 2] *
 114                     filter->data [i * filter->size + j];
 115
 116                   if (src_bpp == 4)
 117                     suma += src_pixels [src_y * src_rowstride +
 118                                         src_x * src_bpp + 3] *
 119                     filter->data [i * filter->size + j];
 120
 121
 122                 }
 123             }
 124
 125           if (dest_bpp == 4)
 126             dest_pixels [y * dest_rowstride +
 127                          x * dest_bpp + 3] = suma * SHADOW_OPACITY;
 128
 129         }
 130     }
 131
 132   return dest;
 133 }
 134
 135 GdkPixbuf *
 136 create_shadowed_pixbuf (GdkPixbuf *src)
 137 {
 138   GdkPixbuf *dest;
 139
 140   dest = create_shadow (src);
 141
 142   gdk_pixbuf_composite (src, dest,
 143                         BLUR_RADIUS, BLUR_RADIUS,
 144                         gdk_pixbuf_get_width (src),
 145                         gdk_pixbuf_get_height (src),
 146                         BLUR_RADIUS, BLUR_RADIUS, 1.0, 1.0,
 147                         GDK_INTERP_NEAREST, 255);
 148   return dest;
 149 }