]> www.fi.muni.cz Git - evince.git/blob - libdocument/ev-document-misc.c
l10n: Added Aragonese translation for evince
[evince.git] / libdocument / ev-document-misc.c
1 /*
2  *  Copyright (C) 2009 Juanjo MarĂ­n <juanj.marin@juntadeandalucia.es>
3  *  Copyright (c) 2007 Carlos Garcia Campos <carlosgc@gnome.org>
4  *  Copyright (C) 2000-2003 Marco Pesenti Gritti
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2, or (at your option)
9  *  any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  */
20
21 #include <config.h>
22
23 #include <string.h>
24 #include <math.h>
25
26 #include <gtk/gtk.h>
27
28 #include "ev-document-misc.h"
29
30 /* Returns a new GdkPixbuf that is suitable for placing in the thumbnail view.
31  * It is four pixels wider and taller than the source.  If source_pixbuf is not
32  * NULL, then it will fill the return pixbuf with the contents of
33  * source_pixbuf.
34  */
35 static GdkPixbuf *
36 create_thumbnail_frame (int        width,
37                         int        height,
38                         GdkPixbuf *source_pixbuf,
39                         gboolean   fill_bg)
40 {
41         GdkPixbuf *retval;
42         guchar *data;
43         gint rowstride;
44         int i;
45         int width_r, height_r;
46
47         if (source_pixbuf)
48                 g_return_val_if_fail (GDK_IS_PIXBUF (source_pixbuf), NULL);
49
50         if (source_pixbuf) {
51                 width_r = gdk_pixbuf_get_width (source_pixbuf);
52                 height_r = gdk_pixbuf_get_height (source_pixbuf);
53         } else {
54                 width_r = width;
55                 height_r = height;
56         }
57
58         /* make sure no one is passing us garbage */
59         g_return_val_if_fail (width_r >= 0 && height_r >= 0, NULL);
60
61         retval = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
62                                  TRUE, 8,
63                                  width_r + 4,
64                                  height_r + 4);
65
66         /* make it black and fill in the middle */
67         data = gdk_pixbuf_get_pixels (retval);
68         rowstride = gdk_pixbuf_get_rowstride (retval);
69
70         gdk_pixbuf_fill (retval, 0x000000ff);
71         if (fill_bg) {
72                 for (i = 1; i < height_r + 1; i++)
73                         memset (data + (rowstride * i) + 4, 0xffffffff, width_r * 4);
74         }
75
76         /* copy the source pixbuf */
77         if (source_pixbuf)
78                 gdk_pixbuf_copy_area (source_pixbuf, 0, 0,
79                                       width_r,
80                                       height_r,
81                                       retval,
82                                       1, 1);
83         /* Add the corner */
84         data [(width_r + 2) * 4 + 3] = 0;
85         data [(width_r + 3) * 4 + 3] = 0;
86         data [(width_r + 2) * 4 + (rowstride * 1) + 3] = 0;
87         data [(width_r + 3) * 4 + (rowstride * 1) + 3] = 0;
88
89         data [(height_r + 2) * rowstride + 3] = 0;
90         data [(height_r + 3) * rowstride + 3] = 0;
91         data [(height_r + 2) * rowstride + 4 + 3] = 0;
92         data [(height_r + 3) * rowstride + 4 + 3] = 0;
93
94         return retval;
95 }
96
97 GdkPixbuf *
98 ev_document_misc_get_thumbnail_frame (int        width,
99                                       int        height,
100                                       GdkPixbuf *source_pixbuf)
101 {
102         return create_thumbnail_frame (width, height, source_pixbuf, TRUE);
103 }
104
105 GdkPixbuf *
106 ev_document_misc_get_loading_thumbnail (int      width,
107                                         int      height,
108                                         gboolean inverted_colors)
109 {
110         return create_thumbnail_frame (width, height, NULL, !inverted_colors);
111 }
112
113 void
114 ev_document_misc_get_page_border_size (gint       page_width,
115                                        gint       page_height,
116                                        GtkBorder *border)
117 {
118         g_assert (border);
119
120         border->left = 1;
121         border->top = 1;
122         if (page_width < 100) {
123                 border->right = 2;
124                 border->bottom = 2;
125         } else if (page_width < 500) {
126                 border->right = 3;
127                 border->bottom = 3;
128         } else {
129                 border->right = 4;
130                 border->bottom = 4;
131         }
132 }
133
134
135 void
136 ev_document_misc_paint_one_page (cairo_t      *cr,
137                                  GtkWidget    *widget,
138                                  GdkRectangle *area,
139                                  GtkBorder    *border,
140                                  gboolean      highlight,
141                                  gboolean      inverted_colors)
142 {
143         GtkStyleContext *context = gtk_widget_get_style_context (widget);
144         GtkStateFlags state = gtk_widget_get_state_flags (widget);
145         GdkRGBA fg, bg, shade_bg;
146         GtkSymbolicColor *c1, *c2;
147
148         gtk_style_context_get_background_color (context, state, &bg);
149         gtk_style_context_get_color (context, state, &fg);
150
151         // FIXME: should we cache the shade_bg?
152         c1 = gtk_symbolic_color_new_literal (&bg);
153         c2 = gtk_symbolic_color_new_shade (c1, 0.7);
154         gtk_symbolic_color_resolve (c2, NULL, &shade_bg);
155         gtk_symbolic_color_unref (c1);
156         gtk_symbolic_color_unref (c2);
157
158         gdk_cairo_set_source_rgba (cr, highlight ? &fg : &shade_bg);
159         gdk_cairo_rectangle (cr, area);
160         cairo_fill (cr);
161
162         if (inverted_colors)
163                 cairo_set_source_rgb (cr, 0, 0, 0);
164         else
165                 cairo_set_source_rgb (cr, 1, 1, 1);
166         cairo_rectangle (cr,
167                          area->x + border->left,
168                          area->y + border->top,
169                          area->width - (border->left + border->right),
170                          area->height - (border->top + border->bottom));
171         cairo_fill (cr);
172
173         gdk_cairo_set_source_rgba (cr, &bg);
174         cairo_rectangle (cr,
175                          area->x,
176                          area->y + area->height - (border->bottom - border->top),
177                          border->bottom - border->top,
178                          border->bottom - border->top);
179         cairo_fill (cr);
180
181         cairo_rectangle (cr,
182                          area->x + area->width - (border->right - border->left),
183                          area->y,
184                          border->right - border->left,
185                          border->right - border->left);
186         cairo_fill (cr);
187 }
188
189 cairo_surface_t *
190 ev_document_misc_surface_from_pixbuf (GdkPixbuf *pixbuf)
191 {
192         cairo_surface_t *surface;
193         cairo_t         *cr;
194
195         g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
196
197         surface = cairo_image_surface_create (gdk_pixbuf_get_has_alpha (pixbuf) ?
198                                               CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24,
199                                               gdk_pixbuf_get_width (pixbuf),
200                                               gdk_pixbuf_get_height (pixbuf));
201         cr = cairo_create (surface);
202         gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
203         cairo_paint (cr);
204         cairo_destroy (cr);
205         
206         return surface;
207 }
208
209 GdkPixbuf *
210 ev_document_misc_pixbuf_from_surface (cairo_surface_t *surface)
211 {
212         g_return_val_if_fail (surface, NULL);   
213
214         return gdk_pixbuf_get_from_surface (surface,
215                                             0, 0,
216                                             cairo_image_surface_get_width (surface),
217                                             cairo_image_surface_get_height (surface));
218 }
219
220 cairo_surface_t *
221 ev_document_misc_surface_rotate_and_scale (cairo_surface_t *surface,
222                                            gint             dest_width,
223                                            gint             dest_height,
224                                            gint             dest_rotation)
225 {
226         cairo_surface_t *new_surface;
227         cairo_t         *cr;
228         gint             width, height;
229         gint             new_width = dest_width;
230         gint             new_height = dest_height;
231
232         width = cairo_image_surface_get_width (surface);
233         height = cairo_image_surface_get_height (surface);
234         
235         if (dest_width == width &&
236             dest_height == height &&
237             dest_rotation == 0) {
238                 return cairo_surface_reference (surface);
239         }
240
241         if (dest_rotation == 90 || dest_rotation == 270) {
242                 new_width = dest_height;
243                 new_height = dest_width;
244         }
245
246         new_surface = cairo_surface_create_similar (surface,
247                                                     cairo_surface_get_content (surface),
248                                                     new_width, new_height);
249
250         cr = cairo_create (new_surface);
251         switch (dest_rotation) {
252                 case 90:
253                         cairo_translate (cr, new_width, 0);
254                         break;
255                 case 180:
256                         cairo_translate (cr, new_width, new_height);
257                         break;
258                 case 270:
259                         cairo_translate (cr, 0, new_height);
260                         break;
261                 default:
262                         cairo_translate (cr, 0, 0);
263         }
264         
265         if (dest_width != width || dest_height != height) {
266                 cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_BILINEAR);
267                 cairo_scale (cr,
268                              (gdouble)dest_width / width,
269                              (gdouble)dest_height / height);
270         }
271         
272         cairo_rotate (cr, dest_rotation * G_PI / 180.0);
273         cairo_set_source_surface (cr, surface, 0, 0);
274         cairo_paint (cr);
275         cairo_destroy (cr);
276
277         return new_surface;
278 }
279
280 void
281 ev_document_misc_invert_surface (cairo_surface_t *surface) {
282         cairo_t *cr;
283
284         cr = cairo_create (surface);
285
286         /* white + DIFFERENCE -> invert */
287         cairo_set_operator (cr, CAIRO_OPERATOR_DIFFERENCE);
288         cairo_set_source_rgb (cr, 1., 1., 1.);
289         cairo_paint(cr);
290         cairo_destroy (cr);
291 }
292
293 void
294 ev_document_misc_invert_pixbuf (GdkPixbuf *pixbuf)
295 {
296         guchar *data, *p;
297         guint   width, height, x, y, rowstride, n_channels;
298
299         n_channels = gdk_pixbuf_get_n_channels (pixbuf);
300         g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
301         g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
302
303         /* First grab a pointer to the raw pixel data. */
304         data = gdk_pixbuf_get_pixels (pixbuf);
305
306         /* Find the number of bytes per row (could be padded). */
307         rowstride = gdk_pixbuf_get_rowstride (pixbuf);
308
309         width = gdk_pixbuf_get_width (pixbuf);
310         height = gdk_pixbuf_get_height (pixbuf);
311         for (x = 0; x < width; x++) {
312                 for (y = 0; y < height; y++) {
313                         /* Calculate pixel's offset into the data array. */
314                         p = data + x * n_channels + y * rowstride;
315                         /* Change the RGB values*/
316                         p[0] = 255 - p[0];
317                         p[1] = 255 - p[1];
318                         p[2] = 255 - p[2];
319                 }
320         }
321 }
322
323 gdouble
324 ev_document_misc_get_screen_dpi (GdkScreen *screen)
325 {
326         gdouble dp, di;
327
328         /*diagonal in pixels*/
329         dp = hypot (gdk_screen_get_width (screen), gdk_screen_get_height (screen));
330
331         /*diagonal in inches*/
332         di = hypot (gdk_screen_get_width_mm(screen), gdk_screen_get_height_mm (screen)) / 25.4;
333
334         return (dp / di);
335 }
336
337 /* Returns a locale specific date and time representation */
338 gchar *
339 ev_document_misc_format_date (GTime utime)
340 {
341         time_t time = (time_t) utime;
342         char s[256];
343         const char fmt_hack[] = "%c";
344         size_t len;
345 #ifdef HAVE_LOCALTIME_R
346         struct tm t;
347         if (time == 0 || !localtime_r (&time, &t)) return NULL;
348         len = strftime (s, sizeof (s), fmt_hack, &t);
349 #else
350         struct tm *t;
351         if (time == 0 || !(t = localtime (&time)) ) return NULL;
352         len = strftime (s, sizeof (s), fmt_hack, t);
353 #endif
354
355         if (len == 0 || s[0] == '\0') return NULL;
356
357         return g_locale_to_utf8 (s, -1, NULL, NULL, NULL);
358 }