← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/poppler/glib/demo/render.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/poppler/glib/demo/render.c
 
1
/*
 
2
 * Copyright (C) 2007 Carlos Garcia Campos  <carlosgc@gnome.org>
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation; either version 2, or (at your option)
 
7
 * any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 
17
 */
 
18
 
 
19
#include "config.h"
 
20
 
 
21
#include <gtk/gtk.h>
 
22
#include <cairo.h>
 
23
 
 
24
#include "render.h"
 
25
 
 
26
typedef enum {
 
27
        PGD_RENDER_CAIRO,
 
28
        PGD_RENDER_PIXBUF
 
29
} PgdRenderMode;
 
30
 
 
31
typedef struct {
 
32
        PopplerDocument *doc;
 
33
 
 
34
        /* Properties */
 
35
        PgdRenderMode    mode;
 
36
        gint             page;
 
37
        gdouble          scale;
 
38
        gint             rotate;
 
39
        GdkRectangle     slice;
 
40
        gboolean         printing;
 
41
        
 
42
        GtkWidget       *swindow;
 
43
        GtkWidget       *darea;
 
44
        GtkWidget       *slice_x;
 
45
        GtkWidget       *slice_y;
 
46
        GtkWidget       *slice_w;
 
47
        GtkWidget       *slice_h;
 
48
        GtkWidget       *timer_label;
 
49
 
 
50
        cairo_surface_t *surface;
 
51
        GdkPixbuf       *pixbuf;
 
52
} PgdRenderDemo;
 
53
 
 
54
static void
 
55
pgd_render_free (PgdRenderDemo *demo)
 
56
{
 
57
        if (!demo)
 
58
                return;
 
59
 
 
60
        if (demo->doc) {
 
61
                g_object_unref (demo->doc);
 
62
                demo->doc = NULL;
 
63
        }
 
64
        
 
65
        if (demo->surface) {
 
66
                cairo_surface_destroy (demo->surface);
 
67
                demo->surface = NULL;
 
68
        }
 
69
 
 
70
        if (demo->pixbuf) {
 
71
                g_object_unref (demo->pixbuf);
 
72
                demo->pixbuf = NULL;
 
73
        }
 
74
 
 
75
        g_free (demo);
 
76
}
 
77
 
 
78
static gboolean
 
79
pgd_render_drawing_area_expose (GtkWidget      *area,
 
80
                                GdkEventExpose *event,
 
81
                                PgdRenderDemo  *demo)
 
82
{
 
83
        if (demo->mode == PGD_RENDER_CAIRO && !demo->surface)
 
84
                return FALSE;
 
85
 
 
86
        if (demo->mode == PGD_RENDER_PIXBUF && !demo->pixbuf)
 
87
                return FALSE;
 
88
 
 
89
        gdk_window_clear (gtk_widget_get_window (area));
 
90
 
 
91
        if (demo->mode == PGD_RENDER_CAIRO) {
 
92
                cairo_t *cr;
 
93
 
 
94
                cr = gdk_cairo_create (gtk_widget_get_window (area));
 
95
                cairo_set_source_surface (cr, demo->surface, 0, 0);
 
96
                cairo_paint (cr);
 
97
                cairo_destroy (cr);
 
98
        } else if (demo->mode == PGD_RENDER_PIXBUF) {
 
99
                gdk_draw_pixbuf (gtk_widget_get_window (area),
 
100
                                 gtk_widget_get_style(area)->fg_gc[GTK_STATE_NORMAL],
 
101
                                 demo->pixbuf,
 
102
                                 0, 0,
 
103
                                 0, 0,
 
104
                                 gdk_pixbuf_get_width (demo->pixbuf),
 
105
                                 gdk_pixbuf_get_height (demo->pixbuf),
 
106
                                 GDK_RGB_DITHER_NORMAL,
 
107
                                 0, 0);
 
108
        } else {
 
109
                g_assert_not_reached ();
 
110
        }
 
111
 
 
112
        return TRUE;
 
113
}
 
114
 
 
115
static void
 
116
pgd_render_start (GtkButton     *button,
 
117
                  PgdRenderDemo *demo)
 
118
{
 
119
        PopplerPage *page;
 
120
        gdouble      page_width, page_height;
 
121
        gdouble      width, height;
 
122
        gint         x, y;
 
123
        gchar       *str;
 
124
        GTimer      *timer;
 
125
 
 
126
        page = poppler_document_get_page (demo->doc, demo->page);
 
127
        if (!page)
 
128
                return;
 
129
 
 
130
        if (demo->surface)
 
131
                cairo_surface_destroy (demo->surface);
 
132
        demo->surface = NULL;
 
133
 
 
134
        if (demo->pixbuf)
 
135
                g_object_unref (demo->pixbuf);
 
136
        demo->pixbuf = NULL;
 
137
        
 
138
        poppler_page_get_size (page, &page_width, &page_height);
 
139
 
 
140
        if (demo->rotate == 0 || demo->rotate == 180) {
 
141
                width = demo->slice.width * demo->scale;
 
142
                height = demo->slice.height * demo->scale;
 
143
                x = demo->slice.x * demo->scale;
 
144
                y = demo->slice.y * demo->scale;
 
145
        } else {
 
146
                width = demo->slice.height * demo->scale;
 
147
                height = demo->slice.width * demo->scale;
 
148
                x = demo->slice.y * demo->scale;
 
149
                y = demo->slice.x * demo->scale;
 
150
        }
 
151
 
 
152
        if (demo->mode == PGD_RENDER_CAIRO) {
 
153
                cairo_t *cr;
 
154
 
 
155
                timer = g_timer_new ();
 
156
                demo->surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
 
157
                                                            width, height);
 
158
                cr = cairo_create (demo->surface);
 
159
 
 
160
                cairo_save (cr);
 
161
                switch (demo->rotate) {
 
162
                case 90:
 
163
                        cairo_translate (cr, x + width, -y);
 
164
                        break;
 
165
                case 180:
 
166
                        cairo_translate (cr, x + width, y + height);
 
167
                        break;
 
168
                case 270:
 
169
                        cairo_translate (cr, -x, y + height);
 
170
                        break;
 
171
                default:
 
172
                        cairo_translate (cr, -x, -y);
 
173
                }
 
174
 
 
175
                if (demo->scale != 1.0)
 
176
                        cairo_scale (cr, demo->scale, demo->scale);
 
177
                
 
178
                if (demo->rotate != 0)
 
179
                        cairo_rotate (cr, demo->rotate * G_PI / 180.0);
 
180
 
 
181
                if (demo->printing)
 
182
                        poppler_page_render_for_printing (page, cr);
 
183
                else
 
184
                        poppler_page_render (page, cr);
 
185
                cairo_restore (cr);
 
186
 
 
187
                cairo_set_operator (cr, CAIRO_OPERATOR_DEST_OVER);
 
188
                cairo_set_source_rgb (cr, 1., 1., 1.);
 
189
                cairo_paint (cr);
 
190
 
 
191
                g_timer_stop (timer);
 
192
                
 
193
                cairo_destroy (cr);
 
194
        } else if (demo->mode == PGD_RENDER_PIXBUF) {
 
195
#ifdef POPPLER_WITH_GDK
 
196
                timer = g_timer_new ();
 
197
                demo->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
 
198
                                               FALSE, 8, width, height);
 
199
                gdk_pixbuf_fill (demo->pixbuf, 0xffffff);
 
200
                if (demo->printing) {
 
201
                        poppler_page_render_to_pixbuf_for_printing (page,
 
202
                                                                    x, y,
 
203
                                                                    width,
 
204
                                                                    height,
 
205
                                                                    demo->scale,
 
206
                                                                    demo->rotate,
 
207
                                                                    demo->pixbuf);
 
208
                } else {
 
209
                        poppler_page_render_to_pixbuf (page,
 
210
                                                       x, y,
 
211
                                                       width,
 
212
                                                       height,
 
213
                                                       demo->scale,
 
214
                                                       demo->rotate,
 
215
                                                       demo->pixbuf);
 
216
                }
 
217
                g_timer_stop (timer);
 
218
#endif /* POPPLER_WITH_GDK */
 
219
        } else {
 
220
                g_assert_not_reached ();
 
221
        }
 
222
 
 
223
        g_object_unref (page);
 
224
        
 
225
        str = g_strdup_printf ("<i>Page rendered in %.4f seconds</i>",
 
226
                               g_timer_elapsed (timer, NULL));
 
227
        gtk_label_set_markup (GTK_LABEL (demo->timer_label), str);
 
228
        g_free (str);
 
229
        
 
230
        g_timer_destroy (timer);
 
231
        
 
232
        gtk_widget_set_size_request (demo->darea, width, height);
 
233
        gtk_widget_queue_draw (demo->darea);
 
234
}
 
235
        
 
236
static void
 
237
pgd_render_slice_selector_setup (PgdRenderDemo *demo)
 
238
{
 
239
        PopplerPage *page;
 
240
        gdouble      width, height;
 
241
 
 
242
        page = poppler_document_get_page (demo->doc, demo->page);
 
243
        if (!page)
 
244
                return;
 
245
 
 
246
        poppler_page_get_size (page, &width, &height);
 
247
        
 
248
        gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->slice_x), 0, width);
 
249
        gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->slice_y), 0, height);
 
250
        gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->slice_w), 0, width);
 
251
        gtk_spin_button_set_range (GTK_SPIN_BUTTON (demo->slice_h), 0, height);
 
252
 
 
253
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->slice_x), 0);
 
254
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->slice_y), 0);
 
255
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->slice_w), width);
 
256
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (demo->slice_h), height);
 
257
 
 
258
        g_object_unref (page);
 
259
}
 
260
 
 
261
static void
 
262
pgd_render_page_selector_value_changed (GtkSpinButton *spinbutton,
 
263
                                        PgdRenderDemo *demo)
 
264
{
 
265
        demo->page = (gint)gtk_spin_button_get_value (spinbutton) - 1;
 
266
        pgd_render_slice_selector_setup (demo);
 
267
}
 
268
 
 
269
static void
 
270
pgd_render_scale_selector_value_changed (GtkSpinButton *spinbutton,
 
271
                                         PgdRenderDemo *demo)
 
272
{
 
273
        demo->scale = gtk_spin_button_get_value (spinbutton);
 
274
}
 
275
 
 
276
static void
 
277
pgd_render_rotate_selector_changed (GtkComboBox   *combobox,
 
278
                                    PgdRenderDemo *demo)
 
279
{
 
280
        demo->rotate = gtk_combo_box_get_active (combobox) * 90;
 
281
}
 
282
 
 
283
static void
 
284
pgd_render_printing_selector_changed (GtkToggleButton *tooglebutton,
 
285
                                      PgdRenderDemo *demo)
 
286
{
 
287
        demo->printing = gtk_toggle_button_get_active (tooglebutton);
 
288
}
 
289
 
 
290
static void
 
291
pgd_render_mode_selector_changed (GtkComboBox   *combobox,
 
292
                                  PgdRenderDemo *demo)
 
293
{
 
294
        demo->mode = gtk_combo_box_get_active (combobox);
 
295
}
 
296
 
 
297
static void
 
298
pgd_render_slice_selector_value_changed (GtkSpinButton *spinbutton,
 
299
                                         PgdRenderDemo *demo)
 
300
{
 
301
        demo->slice.x = (gint)gtk_spin_button_get_value (GTK_SPIN_BUTTON (demo->slice_x));
 
302
        demo->slice.y = (gint)gtk_spin_button_get_value (GTK_SPIN_BUTTON (demo->slice_y));
 
303
        demo->slice.width = (gint)gtk_spin_button_get_value (GTK_SPIN_BUTTON (demo->slice_w));
 
304
        demo->slice.height = (gint)gtk_spin_button_get_value (GTK_SPIN_BUTTON (demo->slice_h));
 
305
}
 
306
 
 
307
GtkWidget *
 
308
pgd_render_properties_selector_create (PgdRenderDemo *demo)
 
309
{
 
310
        GtkWidget *hbox, *vbox;
 
311
        GtkWidget *label;
 
312
        GtkWidget *page_hbox, *page_selector;
 
313
        GtkWidget *scale_hbox, *scale_selector;
 
314
        GtkWidget *rotate_hbox, *rotate_selector;
 
315
        GtkWidget *mode_hbox, *mode_selector;
 
316
        GtkWidget *printing_selector;
 
317
        GtkWidget *slice_hbox, *slice_selector;
 
318
        GtkWidget *button;
 
319
        gint       n_pages;
 
320
        gchar     *str;
 
321
 
 
322
        n_pages = poppler_document_get_n_pages (demo->doc);
 
323
 
 
324
        vbox = gtk_vbox_new (FALSE, 6);
 
325
        
 
326
        hbox = gtk_hbox_new (FALSE, 12);
 
327
        gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 
328
        gtk_widget_show (hbox);
 
329
 
 
330
        page_hbox = gtk_hbox_new (FALSE, 6);
 
331
 
 
332
        label = gtk_label_new ("Page:");
 
333
        gtk_box_pack_start (GTK_BOX (page_hbox), label, TRUE, TRUE, 0);
 
334
        gtk_widget_show (label);
 
335
        
 
336
        page_selector = gtk_spin_button_new_with_range (1, n_pages, 1);
 
337
        g_signal_connect (G_OBJECT (page_selector), "value-changed",
 
338
                          G_CALLBACK (pgd_render_page_selector_value_changed),
 
339
                          (gpointer)demo);
 
340
        gtk_box_pack_start (GTK_BOX (page_hbox), page_selector, TRUE, TRUE, 0);
 
341
        gtk_widget_show (page_selector);
 
342
 
 
343
        str = g_strdup_printf ("of %d", n_pages);
 
344
        label = gtk_label_new (str);
 
345
        gtk_box_pack_start (GTK_BOX (page_hbox), label, TRUE, TRUE, 0);
 
346
        gtk_widget_show (label);
 
347
        g_free (str);
 
348
 
 
349
        gtk_box_pack_start (GTK_BOX (hbox), page_hbox, FALSE, TRUE, 0);
 
350
        gtk_widget_show (page_hbox);
 
351
 
 
352
        scale_hbox = gtk_hbox_new (FALSE, 6);
 
353
        
 
354
        label = gtk_label_new ("Scale:");
 
355
        gtk_box_pack_start (GTK_BOX (scale_hbox), label, TRUE, TRUE, 0);
 
356
        gtk_widget_show (label);
 
357
        
 
358
        scale_selector = gtk_spin_button_new_with_range (0, 10.0, 0.1);
 
359
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (scale_selector), 1.0);
 
360
        g_signal_connect (G_OBJECT (scale_selector), "value-changed",
 
361
                          G_CALLBACK (pgd_render_scale_selector_value_changed),
 
362
                          (gpointer)demo);
 
363
        gtk_box_pack_start (GTK_BOX (scale_hbox), scale_selector, TRUE, TRUE, 0);
 
364
        gtk_widget_show (scale_selector);
 
365
 
 
366
        gtk_box_pack_start (GTK_BOX (hbox), scale_hbox, FALSE, TRUE, 0);
 
367
        gtk_widget_show (scale_hbox);
 
368
 
 
369
        rotate_hbox = gtk_hbox_new (FALSE, 6);
 
370
 
 
371
        label = gtk_label_new ("Rotate:");
 
372
        gtk_box_pack_start (GTK_BOX (rotate_hbox), label, TRUE, TRUE, 0);
 
373
        gtk_widget_show (label);
 
374
 
 
375
        rotate_selector = gtk_combo_box_new_text ();
 
376
        gtk_combo_box_append_text (GTK_COMBO_BOX (rotate_selector), "0");
 
377
        gtk_combo_box_append_text (GTK_COMBO_BOX (rotate_selector), "90");
 
378
        gtk_combo_box_append_text (GTK_COMBO_BOX (rotate_selector), "180");
 
379
        gtk_combo_box_append_text (GTK_COMBO_BOX (rotate_selector), "270");
 
380
        gtk_combo_box_set_active (GTK_COMBO_BOX (rotate_selector), 0);
 
381
        g_signal_connect (G_OBJECT (rotate_selector), "changed",
 
382
                          G_CALLBACK (pgd_render_rotate_selector_changed),
 
383
                          (gpointer)demo);
 
384
        gtk_box_pack_start (GTK_BOX (rotate_hbox), rotate_selector, TRUE, TRUE, 0);
 
385
        gtk_widget_show (rotate_selector);
 
386
 
 
387
        gtk_box_pack_start (GTK_BOX (hbox), rotate_hbox, FALSE, TRUE, 0);
 
388
        gtk_widget_show (rotate_hbox);
 
389
 
 
390
        mode_hbox = gtk_hbox_new (FALSE, 6);
 
391
 
 
392
        label = gtk_label_new ("Mode:");
 
393
        gtk_box_pack_start (GTK_BOX (mode_hbox), label, TRUE, TRUE, 0);
 
394
        gtk_widget_show (label);
 
395
 
 
396
        mode_selector = gtk_combo_box_new_text ();
 
397
        gtk_combo_box_append_text (GTK_COMBO_BOX (mode_selector), "cairo");
 
398
#ifdef POPPLER_WITH_GDK
 
399
        gtk_combo_box_append_text (GTK_COMBO_BOX (mode_selector), "pixbuf");
 
400
#endif
 
401
        gtk_combo_box_set_active (GTK_COMBO_BOX (mode_selector), 0);
 
402
        g_signal_connect (G_OBJECT (mode_selector), "changed",
 
403
                          G_CALLBACK (pgd_render_mode_selector_changed),
 
404
                          (gpointer)demo);
 
405
        gtk_box_pack_start (GTK_BOX (mode_hbox), mode_selector, TRUE, TRUE, 0);
 
406
        gtk_widget_show (mode_selector);
 
407
 
 
408
        gtk_box_pack_start (GTK_BOX (hbox), mode_hbox, FALSE, TRUE, 0);
 
409
        gtk_widget_show (mode_hbox);
 
410
 
 
411
        printing_selector = gtk_check_button_new_with_label ("Printing");
 
412
        g_signal_connect (printing_selector, "toggled",
 
413
                          G_CALLBACK (pgd_render_printing_selector_changed),
 
414
                          (gpointer)demo);
 
415
        gtk_box_pack_start (GTK_BOX (hbox), printing_selector, FALSE, TRUE, 0);
 
416
        gtk_widget_show (printing_selector);
 
417
 
 
418
        hbox = gtk_hbox_new (FALSE, 12);
 
419
        gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 
420
        gtk_widget_show (hbox);
 
421
 
 
422
        slice_hbox = gtk_hbox_new (FALSE, 6);
 
423
 
 
424
        label = gtk_label_new ("x:");
 
425
        gtk_box_pack_start (GTK_BOX (slice_hbox), label, TRUE, TRUE, 0);
 
426
        gtk_widget_show (label);
 
427
 
 
428
        demo->slice_x = gtk_spin_button_new_with_range (0, 0, 1.0);
 
429
        g_signal_connect (G_OBJECT (demo->slice_x), "value-changed",
 
430
                          G_CALLBACK (pgd_render_slice_selector_value_changed),
 
431
                          (gpointer)demo);
 
432
        gtk_box_pack_start (GTK_BOX (slice_hbox), demo->slice_x, TRUE, TRUE, 0);
 
433
        gtk_widget_show (demo->slice_x);
 
434
 
 
435
        gtk_box_pack_start (GTK_BOX (hbox), slice_hbox, FALSE, TRUE, 0);
 
436
        gtk_widget_show (slice_hbox);
 
437
 
 
438
        slice_hbox = gtk_hbox_new (FALSE, 6);
 
439
        
 
440
        label = gtk_label_new ("y:");
 
441
        gtk_box_pack_start (GTK_BOX (slice_hbox), label, TRUE, TRUE, 0);
 
442
        gtk_widget_show (label);
 
443
 
 
444
        demo->slice_y = gtk_spin_button_new_with_range (0, 0, 1.0);
 
445
        g_signal_connect (G_OBJECT (demo->slice_y), "value-changed",
 
446
                          G_CALLBACK (pgd_render_slice_selector_value_changed),
 
447
                          (gpointer)demo);
 
448
        gtk_box_pack_start (GTK_BOX (slice_hbox), demo->slice_y, TRUE, TRUE, 0);
 
449
        gtk_widget_show (demo->slice_y);
 
450
 
 
451
        gtk_box_pack_start (GTK_BOX (hbox), slice_hbox, FALSE, TRUE, 0);
 
452
        gtk_widget_show (slice_hbox);
 
453
        
 
454
        slice_hbox = gtk_hbox_new (FALSE, 6);
 
455
        
 
456
        label = gtk_label_new ("width:");
 
457
        gtk_box_pack_start (GTK_BOX (slice_hbox), label, TRUE, TRUE, 0);
 
458
        gtk_widget_show (label);
 
459
 
 
460
        demo->slice_w = gtk_spin_button_new_with_range (0, 0, 1.0);
 
461
        g_signal_connect (G_OBJECT (demo->slice_w), "value-changed",
 
462
                          G_CALLBACK (pgd_render_slice_selector_value_changed),
 
463
                          (gpointer)demo);
 
464
        gtk_box_pack_start (GTK_BOX (slice_hbox), demo->slice_w, TRUE, TRUE, 0);
 
465
        gtk_widget_show (demo->slice_w);
 
466
 
 
467
        gtk_box_pack_start (GTK_BOX (hbox), slice_hbox, FALSE, TRUE, 0);
 
468
        gtk_widget_show (slice_hbox);
 
469
        
 
470
        slice_hbox = gtk_hbox_new (FALSE, 6);
 
471
        
 
472
        label = gtk_label_new ("height:");
 
473
        gtk_box_pack_start (GTK_BOX (slice_hbox), label, TRUE, TRUE, 0);
 
474
        gtk_widget_show (label);
 
475
 
 
476
        demo->slice_h = gtk_spin_button_new_with_range (0, 0, 1.0);
 
477
        g_signal_connect (G_OBJECT (demo->slice_h), "value-changed",
 
478
                          G_CALLBACK (pgd_render_slice_selector_value_changed),
 
479
                          (gpointer)demo);
 
480
        gtk_box_pack_start (GTK_BOX (slice_hbox), demo->slice_h, TRUE, TRUE, 0);
 
481
        gtk_widget_show (demo->slice_h);
 
482
 
 
483
        gtk_box_pack_start (GTK_BOX (hbox), slice_hbox, FALSE, TRUE, 0);
 
484
        gtk_widget_show (slice_hbox);
 
485
 
 
486
        pgd_render_slice_selector_setup (demo);
 
487
 
 
488
        button = gtk_button_new_with_label ("Render");
 
489
        g_signal_connect (G_OBJECT (button), "clicked",
 
490
                          G_CALLBACK (pgd_render_start),
 
491
                          (gpointer)demo);
 
492
        gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0);
 
493
        gtk_widget_show (button);
 
494
 
 
495
        demo->timer_label = gtk_label_new (NULL);
 
496
        gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No page rendered</i>");
 
497
        g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL);
 
498
        gtk_box_pack_end (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0);
 
499
        gtk_widget_show (demo->timer_label);
 
500
 
 
501
        return vbox;
 
502
}
 
503
 
 
504
GtkWidget *
 
505
pgd_render_create_widget (PopplerDocument *document)
 
506
{
 
507
        PgdRenderDemo *demo;
 
508
        GtkWidget     *vbox, *hbox;
 
509
 
 
510
        demo = g_new0 (PgdRenderDemo, 1);
 
511
 
 
512
        demo->doc = g_object_ref (document);
 
513
        demo->scale = 1.0;
 
514
 
 
515
        vbox = gtk_vbox_new (FALSE, 6);
 
516
 
 
517
        hbox = pgd_render_properties_selector_create (demo);
 
518
        gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6);
 
519
        gtk_widget_show (hbox);
 
520
 
 
521
        demo->darea = gtk_drawing_area_new ();
 
522
        g_signal_connect (G_OBJECT (demo->darea), "expose_event",
 
523
                          G_CALLBACK (pgd_render_drawing_area_expose),
 
524
                          (gpointer)demo);
 
525
        
 
526
        demo->swindow = gtk_scrolled_window_new (NULL, NULL);
 
527
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (demo->swindow),
 
528
                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 
529
        gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (demo->swindow),
 
530
                                               demo->darea);
 
531
        gtk_widget_show (demo->darea);
 
532
 
 
533
        gtk_box_pack_start (GTK_BOX (vbox), demo->swindow, TRUE, TRUE, 0);
 
534
        gtk_widget_show (demo->swindow);
 
535
 
 
536
        g_object_weak_ref (G_OBJECT (demo->swindow),
 
537
                           (GWeakNotify)pgd_render_free,
 
538
                           (gpointer)demo);
 
539
 
 
540
        return vbox;
 
541
}