← Back to branch summary

~ubuntu-branches/ubuntu/hardy/evince/hardy-security

« back to all changes in this revision

Viewing changes to shell/ev-window.c

  • Committer: Bazaar Package Importer
  • Author(s): Aron Sisak
  • Date: 2007-07-30 22:47:24 UTC
  • mfrom: (1.1.17 upstream)
  • Revision ID: james.westby@ubuntu.com-20070730224724-3jcs7t9t5ymuj6os
Tags: 0.9.3-0ubuntu1
* New upstream release:
  - New Features and UI Improvements:
    - Use new GTK+ tootlips 
    - Printing multiple pages per sheet
    - Added UNIX-like key bindings hjkl
  - Bug fixes:
    - Do not block while enumerating printers in preview mode
    - Show new pages as soon as they are rendered even if other page 
      elements like forms, images or links are not ready yet 
    - Provide different options in the print dialog depending on document 
      type backend capabilities 
  - Translations:
    - es, eu, fi, hu, mk, nl, zh_CN
* debian/patches/02_autoconf.patch:
  - configure update

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell/ev-window.c
211
211
#define GCONF_LOCKDOWN_SAVE         "/desktop/gnome/lockdown/disable_save_to_disk"
212
212
#define GCONF_LOCKDOWN_PRINT        "/desktop/gnome/lockdown/disable_printing"
213
213
 
214
 
#define PRESENTATION_TIMEOUT 5 * 1000
 
214
#define PRESENTATION_TIMEOUT 5
215
215
 
216
216
#define SIDEBAR_DEFAULT_SIZE    132
217
217
#define LINKS_SIDEBAR_ID "links"
273
273
 
274
274
G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
275
275
 
276
 
static gdouble
277
 
ev_window_get_screen_dpi (EvWindow *ev_window)
278
 
{
279
 
        GdkScreen *screen;
280
 
        gdouble    xdpi, ydpi;
281
 
 
282
 
        screen = gtk_window_get_screen (GTK_WINDOW (ev_window));
283
 
 
284
 
        xdpi = 25.4 * gdk_screen_get_width (screen) / gdk_screen_get_width_mm (screen);
285
 
        ydpi = 25.4 * gdk_screen_get_height (screen) / gdk_screen_get_height_mm (screen);
286
 
        
287
 
        return (xdpi + ydpi) / 2.0;
288
 
}
289
 
 
290
276
static void
291
277
ev_window_set_action_sensitive (EvWindow   *ev_window,
292
278
                                const char *name,
457
443
                                                      ZOOM_CONTROL_ACTION);
458
444
 
459
445
                real_zoom = ev_view_get_zoom (EV_VIEW (ev_window->priv->view));
460
 
                real_zoom *= 72.0 / ev_window_get_screen_dpi (ev_window);
 
446
                real_zoom *= 72.0 / get_screen_dpi (GTK_WINDOW (ev_window));
461
447
                zoom = ephy_zoom_get_nearest_zoom_level (real_zoom);
462
448
 
463
449
                ephy_zoom_action_set_zoom_level (EPHY_ZOOM_ACTION (action), zoom);
520
506
        fullscreen_toolbar = ((priv->chrome & EV_CHROME_FULLSCREEN_TOOLBAR) != 0 || 
521
507
                              (priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && fullscreen;
522
508
        findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;
523
 
        sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !fullscreen_mode;
 
509
        sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !presentation;
524
510
        preview_toolbar = (priv->chrome& EV_CHROME_PREVIEW_TOOLBAR);
525
511
 
526
512
        set_widget_visibility (priv->menubar, menubar); 
987
973
                gdouble zoom_value;
988
974
 
989
975
                zoom_value = g_value_get_double (&zoom);
990
 
                zoom_value *= ev_window_get_screen_dpi (window) / 72.0;
 
976
                zoom_value *= get_screen_dpi (GTK_WINDOW (window)) / 72.0;
991
977
                ev_view_set_zoom (view, zoom_value, FALSE);
992
978
                g_value_unset (&zoom);
993
979
        }
2211
2197
                      const gchar *filename)
2212
2198
{
2213
2199
        GtkPrintSettings *settings;
 
2200
        EvFileExporterCapabilities capabilities;
2214
2201
        
2215
2202
        /* Some printers take into account some print settings,
2216
2203
         * and others don't. However we have exported the document
2219
2206
         * settings set to default values. 
2220
2207
         */
2221
2208
        settings = gtk_print_settings_copy (window->priv->print_settings);
2222
 
        gtk_print_settings_set_n_copies (settings, 1);
 
2209
        capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (window->priv->document));
 
2210
 
2223
2211
        gtk_print_settings_set_page_ranges (settings, NULL, 0);
2224
 
        gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
2225
2212
        gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
2226
 
        gtk_print_settings_set_scale (settings, 1.0);
2227
 
        gtk_print_settings_set_collate (settings, FALSE);
2228
 
        gtk_print_settings_set_reverse (settings, FALSE);
2229
 
 
 
2213
        if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
 
2214
                gtk_print_settings_set_n_copies (settings, 1);
 
2215
        if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
 
2216
                gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
 
2217
        if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
 
2218
                gtk_print_settings_set_scale (settings, 1.0);
 
2219
        if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
 
2220
                gtk_print_settings_set_collate (settings, FALSE);
 
2221
        if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
 
2222
                gtk_print_settings_set_reverse (settings, FALSE);
 
2223
        if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP)
 
2224
                gtk_print_settings_set_number_up (settings, 1);
 
2225
        
2230
2226
        if (window->priv->print_preview) {
2231
2227
                gchar *uri;
2232
2228
                gchar *print_settings_file = NULL;
2300
2296
        EvPrintPageSet page_set;
2301
2297
        gint           n_ranges = 0;
2302
2298
        gint           copies;
 
2299
        gint           pages_per_sheet;
2303
2300
        gboolean       collate;
2304
2301
        gboolean       reverse;
2305
2302
        gdouble        scale;
2391
2388
                height *= scale;
2392
2389
        }
2393
2390
 
 
2391
        pages_per_sheet = gtk_print_settings_get_number_up (window->priv->print_settings);
 
2392
        
2394
2393
        copies = gtk_print_settings_get_n_copies (window->priv->print_settings);
2395
2394
        collate = gtk_print_settings_get_collate (window->priv->print_settings);
2396
2395
        reverse = gtk_print_settings_get_reverse (window->priv->print_settings);
2400
2399
                                                    width, height,
2401
2400
                                                    ranges, n_ranges,
2402
2401
                                                    page_set,
 
2402
                                                    pages_per_sheet,
2403
2403
                                                    copies, collate,
2404
2404
                                                    reverse);
2405
2405
        
2457
2457
        dialog = gtk_print_unix_dialog_new (_("Print"), GTK_WINDOW (ev_window));
2458
2458
        ev_window->priv->print_dialog = dialog;
2459
2459
        
2460
 
        capabilities = GTK_PRINT_CAPABILITY_PAGE_SET |
2461
 
                GTK_PRINT_CAPABILITY_COPIES |
2462
 
                GTK_PRINT_CAPABILITY_COLLATE |
2463
 
                GTK_PRINT_CAPABILITY_REVERSE |
2464
 
                GTK_PRINT_CAPABILITY_SCALE |
2465
 
                GTK_PRINT_CAPABILITY_GENERATE_PS |
2466
 
                GTK_PRINT_CAPABILITY_PREVIEW;
2467
 
        
2468
 
        if (EV_IS_FILE_EXPORTER (ev_window->priv->document) &&
2469
 
            ev_file_exporter_format_supported (EV_FILE_EXPORTER (ev_window->priv->document),
2470
 
                                               EV_FILE_FORMAT_PDF)) {
2471
 
                capabilities |= GTK_PRINT_CAPABILITY_GENERATE_PDF;
2472
 
        }
2473
 
        
 
2460
        capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
 
2461
                ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (ev_window->priv->document));
2474
2462
        gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
2475
2463
                                                       capabilities);
2476
2464
 
2914
2902
        if (window->priv->presentation_timeout_id > 0) {
2915
2903
                g_source_remove (window->priv->presentation_timeout_id);
2916
2904
        }
2917
 
        
 
2905
 
 
2906
#if GLIB_CHECK_VERSION (2, 13, 0)
 
2907
        window->priv->presentation_timeout_id =
 
2908
                g_timeout_add_seconds (PRESENTATION_TIMEOUT,
 
2909
                                       (GSourceFunc)presentation_timeout_cb, window);
 
2910
#else
2918
2911
        window->priv->presentation_timeout_id = 
2919
 
            g_timeout_add (PRESENTATION_TIMEOUT, (GSourceFunc)presentation_timeout_cb, window);
 
2912
            g_timeout_add (PRESENTATION_TIMEOUT * 1000,
 
2913
                           (GSourceFunc)presentation_timeout_cb, window);
 
2914
#endif  
2920
2915
 
2921
2916
        ev_view_show_cursor (EV_VIEW (window->priv->view));
2922
2917
}
3036
3031
{
3037
3032
        gboolean presentation;
3038
3033
 
3039
 
        g_return_if_fail (EV_IS_WINDOW (window));
 
3034
        g_return_if_fail (EV_IS_WINDOW (window));
3040
3035
        ev_window_stop_fullscreen (window);
3041
3036
 
3042
3037
        presentation = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
3095
3090
        if (screen == old_screen)
3096
3091
                return;
3097
3092
 
3098
 
#ifdef HAVE_GTK_RECENT
3099
 
        if (old_screen) {
3100
 
                g_signal_handlers_disconnect_by_func (
3101
 
                        gtk_recent_manager_get_for_screen (old_screen),
3102
 
                        G_CALLBACK (ev_window_setup_recent), window);
3103
 
        }
3104
 
 
3105
 
        priv->recent_manager = gtk_recent_manager_get_for_screen (screen);
3106
 
        g_signal_connect_swapped (priv->recent_manager,
3107
 
                                  "changed",
3108
 
                                  G_CALLBACK (ev_window_setup_recent),
3109
 
                                  window);
3110
 
#endif
3111
 
        
3112
 
        ev_view_set_screen_dpi (EV_VIEW (window->priv->view),
3113
 
                                ev_window_get_screen_dpi (window));
 
3093
        ev_view_set_screen_dpi (EV_VIEW (priv->view),
 
3094
                                get_screen_dpi (GTK_WINDOW (window)));
3114
3095
        
3115
3096
        if (GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed) {
3116
3097
                GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed (widget, old_screen);
3358
3339
}
3359
3340
 
3360
3341
#ifdef WITH_GTK_PRINT
 
3342
static void ev_window_do_preview_print (EvWindow *window);
 
3343
 
3361
3344
static gboolean
3362
 
lookup_printer_from_name (GtkPrinter *printer,
3363
 
                          EvWindow   *window)
 
3345
ev_window_enumerate_printer_cb (GtkPrinter *printer,
 
3346
                                EvWindow   *window)
3364
3347
{
 
3348
        EvWindowPrivate *priv = window->priv;
3365
3349
        const gchar *printer_name;
3366
3350
 
3367
 
        printer_name = gtk_print_settings_get_printer (window->priv->print_settings);
3368
 
        
 
3351
        printer_name = gtk_print_settings_get_printer (priv->print_settings);
3369
3352
        if ((printer_name
3370
 
             && g_ascii_strcasecmp (printer_name, gtk_printer_get_name (printer)) == 0) ||
 
3353
             && strcmp (printer_name, gtk_printer_get_name (printer)) == 0) ||
3371
3354
            (!printer_name && gtk_printer_is_default (printer))) {
3372
 
                if (window->priv->printer)
3373
 
                        g_object_unref (window->priv->printer);
3374
 
                window->priv->printer = g_object_ref (printer);
3375
 
 
3376
 
                return TRUE;
 
3355
                if (priv->printer)
 
3356
                        g_object_unref (priv->printer);
 
3357
                priv->printer = g_object_ref (printer);
 
3358
 
 
3359
                /* Now that we have the printer, we'll start the print */
 
3360
                ev_window_do_preview_print (window);
 
3361
 
 
3362
                return TRUE; /* we're done */
3377
3363
        }
3378
3364
 
3379
 
        return FALSE;
 
3365
        return FALSE; /* continue the enumeration */
3380
3366
}
3381
3367
 
3382
3368
static void
3402
3388
        g_object_unref (print_job);
3403
3389
        gtk_widget_destroy (GTK_WIDGET (window));
3404
3390
}
3405
 
#endif /* WITH_GTK_PRINT */
3406
3391
 
3407
3392
static void
3408
 
ev_window_cmd_preview_print (GtkAction *action, EvWindow *window)
 
3393
ev_window_do_preview_print (EvWindow *window)
3409
3394
{
3410
 
#ifdef WITH_GTK_PRINT
3411
 
        GtkPrintSettings *print_settings = NULL;
 
3395
        EvWindowPrivate  *priv = window->priv;
3412
3396
        GtkPageSetup     *page_setup;
3413
3397
        GtkPrintJob      *job;
3414
3398
        gchar            *filename;
3415
3399
        GError           *error = NULL;
 
3400
 
 
3401
        g_assert (priv->print_settings != NULL);
 
3402
        g_assert (priv->printer != NULL);
 
3403
 
 
3404
        page_setup = gtk_page_setup_new ();
 
3405
 
 
3406
        job = gtk_print_job_new ("evince-print",
 
3407
                                 priv->printer,
 
3408
                                 priv->print_settings,
 
3409
                                 page_setup);
 
3410
 
 
3411
        g_object_unref (priv->print_settings);
 
3412
        priv->print_settings = NULL;
 
3413
        g_object_unref (priv->printer);
 
3414
        priv->printer = NULL;
 
3415
        g_object_unref (page_setup);
 
3416
 
 
3417
        filename = g_filename_from_uri (priv->local_uri ?
 
3418
                                        priv->local_uri : priv->uri,
 
3419
                                        NULL, NULL);
 
3420
 
 
3421
        if (gtk_print_job_set_source_file (job, filename, &error)) {
 
3422
                gtk_print_job_send (job,
 
3423
                                    (GtkPrintJobCompleteFunc)ev_window_preview_print_finished,
 
3424
                                    window, NULL);
 
3425
        } else {
 
3426
                g_warning (error->message);
 
3427
                g_error_free (error);
 
3428
        }
 
3429
 
 
3430
        g_free (filename);
 
3431
 
 
3432
        gtk_widget_hide (GTK_WIDGET (window));
 
3433
}
 
3434
 
 
3435
#endif /* WITH_GTK_PRINT */
 
3436
 
 
3437
static void
 
3438
ev_window_cmd_preview_print (GtkAction *action, EvWindow *window)
 
3439
{
 
3440
#ifdef WITH_GTK_PRINT
 
3441
        EvWindowPrivate *priv = window->priv;
 
3442
        GtkPrintSettings *print_settings = NULL;
3416
3443
#if GTK_CHECK_VERSION (2, 11, 0)
3417
 
        const gchar      *print_settings_file = window->priv->print_settings_file;
 
3444
        const gchar      *print_settings_file = priv->print_settings_file;
3418
3445
 
3419
3446
        if (print_settings_file) {
3420
3447
                if (g_file_test (print_settings_file, G_FILE_TEST_IS_REGULAR)) {
3435
3462
        if (!print_settings)
3436
3463
                print_settings = gtk_print_settings_new ();
3437
3464
 
3438
 
        if (window->priv->print_settings)
3439
 
                g_object_unref (window->priv->print_settings);
3440
 
        window->priv->print_settings = print_settings;
3441
 
 
3442
 
        gtk_enumerate_printers ((GtkPrinterFunc) lookup_printer_from_name,
3443
 
                                window, NULL, TRUE);
3444
 
        g_assert (GTK_IS_PRINTER (window->priv->printer));
3445
 
        
3446
 
        page_setup = gtk_page_setup_new ();
3447
 
 
3448
 
        job = gtk_print_job_new ("evince-print",
3449
 
                                 window->priv->printer,
3450
 
                                 window->priv->print_settings,
3451
 
                                 page_setup);
3452
 
 
3453
 
        g_object_unref (window->priv->print_settings);
3454
 
        window->priv->print_settings = NULL;
3455
 
        g_object_unref (window->priv->printer);
3456
 
        window->priv->printer = NULL;
3457
 
        g_object_unref (page_setup);
3458
 
 
3459
 
        filename = g_filename_from_uri (window->priv->local_uri ?
3460
 
                                        window->priv->local_uri : window->priv->uri,
3461
 
                                        NULL, NULL);
3462
 
 
3463
 
        if (gtk_print_job_set_source_file (job, filename, &error)) {
3464
 
                gtk_print_job_send (job,
3465
 
                                    (GtkPrintJobCompleteFunc)ev_window_preview_print_finished,
3466
 
                                    window, NULL);
3467
 
        } else {
3468
 
                g_warning (error->message);
3469
 
                g_error_free (error);
3470
 
        }
3471
 
 
3472
 
        g_free (filename);
3473
 
 
3474
 
        gtk_widget_hide (GTK_WIDGET (window));
 
3465
        if (priv->print_settings)
 
3466
                g_object_unref (priv->print_settings);
 
3467
        priv->print_settings = print_settings;
 
3468
 
 
3469
        gtk_enumerate_printers ((GtkPrinterFunc) ev_window_enumerate_printer_cb,
 
3470
                                window, NULL, FALSE);
3475
3471
#endif /* WITH_GTK_PRINT */
3476
3472
}
3477
3473
 
3508
3504
}
3509
3505
 
3510
3506
static void
3511
 
update_view_size (EvView *view, EvWindow *window)
3512
 
{
3513
 
        int width, height;
3514
 
        GtkRequisition vsb_requisition;
3515
 
        GtkRequisition hsb_requisition;
3516
 
        int scrollbar_spacing;
3517
 
 
3518
 
        /* Calculate the width available for the */
3519
 
        width = window->priv->scrolled_window->allocation.width;
3520
 
        height = window->priv->scrolled_window->allocation.height;
3521
 
 
3522
 
        if (gtk_scrolled_window_get_shadow_type (GTK_SCROLLED_WINDOW (window->priv->scrolled_window)) == GTK_SHADOW_IN) {
3523
 
                width -= 2 * window->priv->view->style->xthickness;
3524
 
                height -= 2 * window->priv->view->style->ythickness;
3525
 
        }
3526
 
 
3527
 
        gtk_widget_size_request (GTK_SCROLLED_WINDOW (window->priv->scrolled_window)->vscrollbar,
3528
 
                                 &vsb_requisition);
3529
 
        gtk_widget_size_request (GTK_SCROLLED_WINDOW (window->priv->scrolled_window)->hscrollbar,
3530
 
                                 &hsb_requisition);
3531
 
        gtk_widget_style_get (window->priv->scrolled_window,
3532
 
                              "scrollbar_spacing", &scrollbar_spacing,
3533
 
                              NULL);
3534
 
 
3535
 
        ev_view_set_zoom_for_size (EV_VIEW (window->priv->view),
3536
 
                                   MAX (1, width),
3537
 
                                   MAX (1, height),
3538
 
                                   vsb_requisition.width + scrollbar_spacing,
3539
 
                                   hsb_requisition.height + scrollbar_spacing);
3540
 
}
3541
 
 
3542
 
static void
3543
3507
save_sizing_mode (EvWindow *window)
3544
3508
{
3545
3509
        EvSizingMode mode;
3566
3530
 
3567
3531
        scrolled_window = ev_window->priv->scrolled_window;
3568
3532
 
3569
 
        g_signal_handlers_disconnect_by_func (ev_window->priv->view, update_view_size, ev_window);
 
3533
        g_signal_handlers_disconnect_by_func (ev_window->priv->view, ev_view_update_view_size, scrolled_window);
3570
3534
 
3571
3535
        if (sizing_mode != EV_SIZING_FREE)
3572
 
                update_view_size (NULL, ev_window);
 
3536
                ev_view_update_view_size (EV_VIEW (ev_window->priv->view),
 
3537
                                          GTK_SCROLLED_WINDOW (scrolled_window));
3573
3538
 
3574
3539
        switch (sizing_mode) {
3575
3540
                case EV_SIZING_BEST_FIT:
3578
3543
                                      "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
3579
3544
                                      NULL);
3580
3545
                        g_signal_connect (ev_window->priv->view, "zoom_invalid",
3581
 
                                          G_CALLBACK (update_view_size),
3582
 
                                          ev_window);
 
3546
                                          G_CALLBACK (ev_view_update_view_size),
 
3547
                                          scrolled_window);
3583
3548
                        break;
3584
3549
                case EV_SIZING_FIT_WIDTH:
3585
3550
                        g_object_set (G_OBJECT (scrolled_window),
3587
3552
                                      "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
3588
3553
                                      NULL);
3589
3554
                        g_signal_connect (ev_window->priv->view, "zoom_invalid",
3590
 
                                          G_CALLBACK (update_view_size),
3591
 
                                          ev_window);
 
3555
                                          G_CALLBACK (ev_view_update_view_size),
 
3556
                                          scrolled_window);
3592
3557
                        break;
3593
3558
                case EV_SIZING_FREE:
3594
3559
                        g_object_set (G_OBJECT (scrolled_window),
3611
3576
                gdouble zoom;
3612
3577
 
3613
3578
                zoom = ev_view_get_zoom (view);
3614
 
                zoom *= 72.0 / ev_window_get_screen_dpi (ev_window);
 
3579
                zoom *= 72.0 / get_screen_dpi (GTK_WINDOW(ev_window));
3615
3580
                ev_metadata_manager_set_double (ev_window->priv->uri, "zoom", zoom);
3616
3581
        }
3617
3582
}
3841
3806
 
3842
3807
        action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
3843
3808
 
3844
 
        if (!ev_view_get_presentation (view) && 
3845
 
            !ev_view_get_fullscreen (view)) {
3846
 
 
 
3809
        if (!ev_view_get_presentation (view)) {
3847
3810
                gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
3848
3811
                                              GTK_WIDGET_VISIBLE (ev_sidebar));
3849
3812
 
4079
4042
        
4080
4043
        if (mode == EV_SIZING_FREE) {
4081
4044
                ev_view_set_zoom (EV_VIEW (ev_window->priv->view),
4082
 
                                  zoom * ev_window_get_screen_dpi (ev_window) / 72.0,
 
4045
                                  zoom * get_screen_dpi (GTK_WINDOW (ev_window)) / 72.0,
4083
4046
                                  FALSE);
4084
4047
        }
4085
4048
}
5211
5174
        }
5212
5175
        
5213
5176
#ifdef HAVE_GTK_RECENT
 
5177
#if GTK_CHECK_VERSION(2,11,4)
 
5178
        ev_window->priv->recent_manager = gtk_recent_manager_get_default ();
 
5179
#else
 
5180
        /* It's fine to just use the one of the default screen here */
5214
5181
        ev_window->priv->recent_manager = gtk_recent_manager_get_for_screen (
5215
 
                gtk_widget_get_screen (GTK_WIDGET (ev_window)));
 
5182
                gdk_screen_get_default ());
 
5183
#endif
5216
5184
        ev_window->priv->recent_action_group = NULL;
5217
5185
        ev_window->priv->recent_ui_id = 0;
5218
5186
        g_signal_connect_swapped (ev_window->priv->recent_manager,
5309
5277
 
5310
5278
        ev_window->priv->view = ev_view_new ();
5311
5279
        ev_view_set_screen_dpi (EV_VIEW (ev_window->priv->view),
5312
 
                                ev_window_get_screen_dpi (ev_window));
 
5280
                                get_screen_dpi (GTK_WINDOW (ev_window)));
5313
5281
        ev_window->priv->password_view = ev_password_view_new ();
5314
5282
        g_signal_connect_swapped (ev_window->priv->password_view,
5315
5283
                                  "unlock",