]> www.fi.muni.cz Git - evince.git/blob - shell/ev-utils.c
Clean up selection to be much smoother!
[evince.git] / 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