shell/ev-utils.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
   2 /*
   3  *  Copyright (C) 2004 Anders Carlsson <andersca@gnome.org>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  *
  19  */
  20
  21 #include "ev-utils.h"
  22 #include <math.h>
  23
  24 typedef struct
  25 {
  26   int size;
  27   double *data;
  28 } ConvFilter;
  29
  30 static double
  31 gaussian (double x, double y, double r)
  32 {
  33     return ((1 / (2 * M_PI * r)) *
  34             exp ((- (x * x + y * y)) / (2 * r * r)));
  35 }
  36
  37 static ConvFilter *
  38 create_blur_filter (int radius)
  39 {
  40   ConvFilter *filter;
  41   int x, y;
  42   double sum;
  43
  44   filter = g_new0 (ConvFilter, 1);
  45   filter->size = radius * 2 + 1;
  46   filter->data = g_new (double, filter->size * filter->size);
  47
  48   sum = 0.0;
  49
  50   for (y = 0 ; y < filter->size; y++)
  51     {
  52       for (x = 0 ; x < filter->size; x++)
  53         {
  54           sum += filter->data[y * filter->size + x] = gaussian (x - (filter->size >> 1),
  55                                                                 y - (filter->size >> 1),
  56                                                                 radius);
  57         }
  58     }
  59
  60   for (y = 0; y < filter->size; y++)
  61     {
  62       for (x = 0; x < filter->size; x++)
  63         {
  64           filter->data[y * filter->size + x] /= sum;
  65         }
  66     }
  67
  68   return filter;
  69
  70 }
  71
  72 static GdkPixbuf *
  73 create_shadow (GdkPixbuf *src, int blur_radius,
  74                int x_offset, int y_offset, double opacity)
  75 {
  76   int x, y, i, j;
  77   int width, height;
  78   GdkPixbuf *dest;
  79   static ConvFilter *filter = NULL;
  80   int src_rowstride, dest_rowstride;
  81   int src_bpp, dest_bpp;
  82
  83   guchar *src_pixels, *dest_pixels;
  84
  85   if (!filter)
  86     filter = create_blur_filter (blur_radius);
  87
  88   if (x_offset < 0)
  89           x_offset = (blur_radius * 4) / 5;
  90
  91   if (y_offset < 0)
  92           y_offset = (blur_radius * 4) / 5;
  93
  94
  95   width = gdk_pixbuf_get_width (src) + blur_radius * 2 + x_offset;
  96   height = gdk_pixbuf_get_height (src) + blur_radius * 2 + y_offset;
  97
  98   dest = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (src), TRUE,
  99                          gdk_pixbuf_get_bits_per_sample (src),
 100                          width, height);
 101   gdk_pixbuf_fill (dest, 0);
 102   src_pixels = gdk_pixbuf_get_pixels (src);
 103   src_rowstride = gdk_pixbuf_get_rowstride (src);
 104   src_bpp = gdk_pixbuf_get_has_alpha (src) ? 4 : 3;
 105
 106   dest_pixels = gdk_pixbuf_get_pixels (dest);
 107   dest_rowstride = gdk_pixbuf_get_rowstride (dest);
 108   dest_bpp = gdk_pixbuf_get_has_alpha (dest) ? 4 : 3;
 109
 110   for (y = 0; y < height; y++)
 111     {
 112       for (x = 0; x < width; x++)
 113         {
 114           int sumr = 0, sumg = 0, sumb = 0, suma = 0;
 115
 116           for (i = 0; i < filter->size; i++)
 117             {
 118               for (j = 0; j < filter->size; j++)
 119                 {
 120                   int src_x, src_y;
 121
 122                   src_y = -(blur_radius + x_offset) + y - (filter->size >> 1) + i;
 123                   src_x = -(blur_radius + y_offset) + x - (filter->size >> 1) + j;
 124
 125                   if (src_y < 0 || src_y > gdk_pixbuf_get_height (src) ||
 126                       src_x < 0 || src_x > gdk_pixbuf_get_width (src))
 127                     continue;
 128
 129                   sumr += src_pixels [src_y * src_rowstride +
 130                                       src_x * src_bpp + 0] *
 131                     filter->data [i * filter->size + j];
 132                   sumg += src_pixels [src_y * src_rowstride +
 133                                       src_x * src_bpp + 1] *
 134                     filter->data [i * filter->size + j];
 135
 136                   sumb += src_pixels [src_y * src_rowstride +
 137                                       src_x * src_bpp + 2] *
 138                     filter->data [i * filter->size + j];
 139
 140                   if (src_bpp == 4)
 141                     suma += src_pixels [src_y * src_rowstride +
 142                                         src_x * src_bpp + 3] *
 143                     filter->data [i * filter->size + j];
 144                   else
 145                           suma += 0xff;
 146
 147                 }
 148             }
 149
 150           if (dest_bpp == 4)
 151             dest_pixels [y * dest_rowstride +
 152                          x * dest_bpp + 3] = (suma * opacity) / (filter->size * filter->size);
 153
 154         }
 155     }
 156
 157   return dest;
 158 }
 159
 160 GdkPixbuf *
 161 ev_pixbuf_add_shadow (GdkPixbuf *src, int size,
 162                       int x_offset, int y_offset, double opacity)
 163 {
 164   GdkPixbuf *dest;
 165
 166   dest = create_shadow (src, size, x_offset, y_offset, opacity);
 167
 168   gdk_pixbuf_composite (src, dest,
 169                         size, size,
 170                         gdk_pixbuf_get_width (src),
 171                         gdk_pixbuf_get_height (src),
 172                         size, size,
 173                         1.0, 1.0,
 174                         GDK_INTERP_NEAREST, 255);
 175
 176   return dest;
 177 }
 178
 179
 180 /* Simple function to output the contents of a region.  Used solely for testing
 181  * the region code.
 182  */
 183 void
 184 ev_print_region_contents (GdkRegion *region)
 185 {
 186         GdkRectangle *rectangles = NULL;
 187         gint n_rectangles, i;
 188
 189         if (region == NULL) {
 190                 g_print ("<empty region>\n");
 191                 return;
 192         }
 193
 194         g_print ("<region %p>\n", region);
 195         gdk_region_get_rectangles (region, &rectangles, &n_rectangles);
 196         for (i = 0; i < n_rectangles; i++) {
 197                 g_print ("\t(%d %d, %d %d) [%dx%d]\n",
 198                          rectangles[i].x,
 199                          rectangles[i].y,
 200                          rectangles[i].x + rectangles[i].width,
 201                          rectangles[i].y + rectangles[i].height,
 202                          rectangles[i].width,
 203                          rectangles[i].height);
 204         }
 205         g_free (rectangles);
 206 }
 207
 208
 209 #ifndef HAVE_G_FILE_SET_CONTENTS
 210
 211 #include <errno.h>
 212 #include <unistd.h>
 213 #include <sys/types.h>
 214 #include <sys/wait.h>
 215 #include <string.h>
 216
 217 static gboolean
 218 rename_file (const char *old_name,
 219              const char *new_name,
 220              GError **err)
 221 {
 222   errno = 0;
 223   if (g_rename (old_name, new_name) == -1)
 224     {
 225       return FALSE;
 226     }
 227
 228   return TRUE;
 229 }
 230
 231 static gboolean
 232 set_umask_permissions (int           fd,
 233                        GError      **err)
 234 {
 235   /* All of this function is just to work around the fact that
 236    * there is no way to get the umask without changing it.
 237    *
 238    * We can't just change-and-reset the umask because that would
 239    * lead to a race condition if another thread tried to change
 240    * the umask in between the getting and the setting of the umask.
 241    * So we have to do the whole thing in a child process.
 242    */
 243
 244   int save_errno;
 245   pid_t pid;
 246
 247   pid = fork ();
 248
 249   if (pid == -1)
 250     {
 251       return FALSE;
 252     }
 253   else if (pid == 0)
 254     {
 255       /* child */
 256       mode_t mask = umask (0666);
 257
 258       errno = 0;
 259       if (fchmod (fd, 0666 & ~mask) == -1)
 260         _exit (errno);
 261       else
 262         _exit (0);
 263
 264       return TRUE; /* To quiet gcc */
 265     }
 266   else
 267     {
 268       /* parent */
 269       int status;
 270
 271       errno = 0;
 272       if (waitpid (pid, &status, 0) == -1)
 273         {
 274           return FALSE;
 275         }
 276
 277       if (WIFEXITED (status))
 278         {
 279           save_errno = WEXITSTATUS (status);
 280
 281           if (save_errno == 0)
 282             {
 283               return TRUE;
 284             }
 285           else
 286             {
 287               return FALSE;
 288             }
 289         }
 290       else if (WIFSIGNALED (status))
 291         {
 292           return FALSE;
 293         }
 294       else
 295         {
 296           return FALSE;
 297         }
 298     }
 299 }
 300
 301 static gchar *
 302 write_to_temp_file (const gchar *contents,
 303                     gssize length,
 304                     const gchar *template,
 305                     GError **err)
 306 {
 307   gchar *tmp_name;
 308   gchar *display_name;
 309   gchar *retval;
 310   FILE *file;
 311   gint fd;
 312   int save_errno;
 313
 314   retval = NULL;
 315
 316   tmp_name = g_strdup_printf ("%s.XXXXXX", template);
 317
 318   errno = 0;
 319   fd = g_mkstemp (tmp_name);
 320   display_name = g_filename_display_name (tmp_name);
 321
 322   if (fd == -1)
 323     {
 324       goto out;
 325     }
 326
 327   if (!set_umask_permissions (fd, err))
 328     {
 329       close (fd);
 330       g_unlink (tmp_name);
 331
 332       goto out;
 333     }
 334
 335   errno = 0;
 336   file = fdopen (fd, "wb");
 337   if (!file)
 338     {
 339       close (fd);
 340       g_unlink (tmp_name);
 341
 342       goto out;
 343     }
 344
 345   if (length > 0)
 346     {
 347       size_t n_written;
 348
 349       errno = 0;
 350
 351       n_written = fwrite (contents, 1, length, file);
 352
 353       if (n_written < length)
 354         {
 355           fclose (file);
 356           g_unlink (tmp_name);
 357
 358           goto out;
 359         }
 360     }
 361
 362   errno = 0;
 363   if (fclose (file) == EOF)
 364     {
 365       g_unlink (tmp_name);
 366
 367       goto out;
 368     }
 369
 370   retval = g_strdup (tmp_name);
 371
 372  out:
 373   g_free (tmp_name);
 374   g_free (display_name);
 375
 376   return retval;
 377 }
 378
 379 gboolean
 380 ev_file_set_contents (const gchar *filename,
 381                       const gchar *contents,
 382                       gssize         length,
 383                       GError       **error)
 384 {
 385   gchar *tmp_filename;
 386   gboolean retval;
 387   GError *rename_error = NULL;
 388
 389   g_return_val_if_fail (filename != NULL, FALSE);
 390   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 391   g_return_val_if_fail (contents != NULL || length == 0, FALSE);
 392   g_return_val_if_fail (length >= -1, FALSE);
 393
 394   if (length == -1)
 395     length = strlen (contents);
 396
 397   tmp_filename = write_to_temp_file (contents, length, filename, error);
 398
 399   if (!tmp_filename)
 400     {
 401       retval = FALSE;
 402       goto out;
 403     }
 404
 405   if (!rename_file (tmp_filename, filename, &rename_error))
 406     {
 407       g_unlink (tmp_filename);
 408       g_propagate_error (error, rename_error);
 409       retval = FALSE;
 410       goto out;
 411     }
 412
 413   retval = TRUE;
 414
 415  out:
 416   g_free (tmp_filename);
 417   return retval;
 418 }
 419
 420 #endif /* HAVE_G_FILE_SET_CONTENTS */
 421