previewer/ev-previewer-window.c

   1 /* ev-previewer-window.c:
   2  *  this file is part of evince, a gnome document viewer
   3  *
   4  * Copyright (C) 2009 Carlos Garcia Campos <carlosgc@gnome.org>
   5  *
   6  * Evince is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Evince is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22
  23 #if GTKUNIXPRINT_ENABLED
  24 #include <gtk/gtkunixprint.h>
  25 #endif
  26 #include <glib/gi18n.h>
  27 #include <evince-view.h>
  28 #include "ev-page-action.h"
  29
  30 #include "ev-previewer-window.h"
  31
  32 struct _EvPreviewerWindow {
  33         GtkWindow         base_instance;
  34
  35         EvDocumentModel  *model;
  36         EvDocument       *document;
  37
  38         GtkActionGroup   *action_group;
  39         GtkActionGroup   *accels_group;
  40         GtkUIManager     *ui_manager;
  41
  42         GtkWidget        *swindow;
  43         EvView           *view;
  44         gdouble           dpi;
  45
  46         /* Printing */
  47         GtkPrintSettings *print_settings;
  48         GtkPageSetup     *print_page_setup;
  49 #if GTKUNIXPRINT_ENABLED
  50         GtkPrinter       *printer;
  51 #endif
  52         gchar            *print_job_title;
  53         gchar            *source_file;
  54 };
  55
  56 struct _EvPreviewerWindowClass {
  57         GtkWindowClass base_class;
  58 };
  59
  60 enum {
  61         PROP_0,
  62         PROP_MODEL
  63 };
  64
  65 #define MIN_SCALE 0.05409
  66 #define MAX_SCALE 4.0
  67
  68 G_DEFINE_TYPE (EvPreviewerWindow, ev_previewer_window, GTK_TYPE_WINDOW)
  69
  70 static gdouble
  71 get_screen_dpi (EvPreviewerWindow *window)
  72 {
  73         GdkScreen *screen;
  74
  75         screen = gtk_window_get_screen (GTK_WINDOW (window));
  76         return ev_document_misc_get_screen_dpi (screen);
  77 }
  78
  79 #if GTKUNIXPRINT_ENABLED
  80 static void
  81 ev_previewer_window_error_dialog_run (EvPreviewerWindow *window,
  82                                       GError            *error)
  83 {
  84         GtkWidget *dialog;
  85
  86         dialog = gtk_message_dialog_new (GTK_WINDOW (window),
  87                                          GTK_DIALOG_MODAL |
  88                                          GTK_DIALOG_DESTROY_WITH_PARENT,
  89                                          GTK_MESSAGE_ERROR,
  90                                          GTK_BUTTONS_CLOSE,
  91                                          "%s", _("Failed to print document"));
  92         gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
  93                                                   "%s", error->message);
  94         gtk_dialog_run (GTK_DIALOG (dialog));
  95         gtk_widget_destroy (dialog);
  96 }
  97 #endif
  98
  99 static void
 100 ev_previewer_window_previous_page (GtkAction         *action,
 101                                    EvPreviewerWindow *window)
 102 {
 103         ev_view_previous_page (window->view);
 104 }
 105
 106 static void
 107 ev_previewer_window_next_page (GtkAction         *action,
 108                                EvPreviewerWindow *window)
 109 {
 110         ev_view_next_page (window->view);
 111 }
 112
 113 static void
 114 ev_previewer_window_zoom_in (GtkAction         *action,
 115                              EvPreviewerWindow *window)
 116 {
 117         ev_document_model_set_sizing_mode (window->model, EV_SIZING_FREE);
 118         ev_view_zoom_in (window->view);
 119 }
 120
 121 static void
 122 ev_previewer_window_zoom_out (GtkAction         *action,
 123                               EvPreviewerWindow *window)
 124 {
 125         ev_document_model_set_sizing_mode (window->model, EV_SIZING_FREE);
 126         ev_view_zoom_out (window->view);
 127 }
 128
 129 static void
 130 ev_previewer_window_zoom_best_fit (GtkToggleAction   *action,
 131                                    EvPreviewerWindow *window)
 132 {
 133         ev_document_model_set_sizing_mode (window->model,
 134                                            gtk_toggle_action_get_active (action) ?
 135                                            EV_SIZING_BEST_FIT : EV_SIZING_FREE);
 136 }
 137
 138 static void
 139 ev_previewer_window_zoom_page_width (GtkToggleAction   *action,
 140                                      EvPreviewerWindow *window)
 141 {
 142         ev_document_model_set_sizing_mode (window->model,
 143                                            gtk_toggle_action_get_active (action) ?
 144                                            EV_SIZING_FIT_WIDTH : EV_SIZING_FREE);
 145 }
 146
 147 static void
 148 ev_previewer_window_action_page_activated (GtkAction         *action,
 149                                            EvLink            *link,
 150                                            EvPreviewerWindow *window)
 151 {
 152         ev_view_handle_link (window->view, link);
 153         gtk_widget_grab_focus (GTK_WIDGET (window->view));
 154 }
 155
 156 static void
 157 ev_previewer_window_focus_page_selector (GtkAction         *action,
 158                                          EvPreviewerWindow *window)
 159 {
 160         GtkAction *page_action;
 161
 162         page_action = gtk_action_group_get_action (window->action_group,
 163                                                    "PageSelector");
 164         ev_page_action_grab_focus (EV_PAGE_ACTION (page_action));
 165 }
 166
 167 static void
 168 ev_previewer_window_scroll_forward (GtkAction         *action,
 169                                     EvPreviewerWindow *window)
 170 {
 171         ev_view_scroll (window->view, GTK_SCROLL_PAGE_FORWARD, FALSE);
 172 }
 173
 174 static void
 175 ev_previewer_window_scroll_backward (GtkAction         *action,
 176                                      EvPreviewerWindow *window)
 177 {
 178         ev_view_scroll (window->view, GTK_SCROLL_PAGE_BACKWARD, FALSE);
 179 }
 180
 181 #if GTKUNIXPRINT_ENABLED
 182 static void
 183 ev_previewer_window_print_finished (GtkPrintJob       *print_job,
 184                                     EvPreviewerWindow *window,
 185                                     GError            *error)
 186 {
 187         if (error) {
 188                 ev_previewer_window_error_dialog_run (window, error);
 189         }
 190
 191         g_object_unref (print_job);
 192         gtk_widget_destroy (GTK_WIDGET (window));
 193 }
 194
 195 static void
 196 ev_previewer_window_do_print (EvPreviewerWindow *window)
 197 {
 198         GtkPrintJob *job;
 199         GError      *error = NULL;
 200
 201         job = gtk_print_job_new (window->print_job_title ?
 202                                  window->print_job_title :
 203                                  window->source_file,
 204                                  window->printer,
 205                                  window->print_settings,
 206                                  window->print_page_setup);
 207         if (gtk_print_job_set_source_file (job, window->source_file, &error)) {
 208                 gtk_print_job_send (job,
 209                                     (GtkPrintJobCompleteFunc)ev_previewer_window_print_finished,
 210                                     window, NULL);
 211         } else {
 212                 ev_previewer_window_error_dialog_run (window, error);
 213                 g_error_free (error);
 214         }
 215
 216         gtk_widget_hide (GTK_WIDGET (window));
 217 }
 218
 219 static void
 220 ev_previewer_window_enumerate_finished (EvPreviewerWindow *window)
 221 {
 222         if (window->printer) {
 223                 ev_previewer_window_do_print (window);
 224         } else {
 225                 GError *error = NULL;
 226
 227                 g_set_error (&error,
 228                              GTK_PRINT_ERROR,
 229                              GTK_PRINT_ERROR_GENERAL,
 230                              _("The selected printer '%s' could not be found"),
 231                              gtk_print_settings_get_printer (window->print_settings));
 232
 233                 ev_previewer_window_error_dialog_run (window, error);
 234                 g_error_free (error);
 235         }
 236 }
 237
 238 static gboolean
 239 ev_previewer_window_enumerate_printers (GtkPrinter        *printer,
 240                                         EvPreviewerWindow *window)
 241 {
 242         const gchar *printer_name;
 243
 244         printer_name = gtk_print_settings_get_printer (window->print_settings);
 245         if ((printer_name
 246              && strcmp (printer_name, gtk_printer_get_name (printer)) == 0) ||
 247             (!printer_name && gtk_printer_is_default (printer))) {
 248                 if (window->printer)
 249                         g_object_unref (window->printer);
 250                 window->printer = g_object_ref (printer);
 251
 252                 return TRUE; /* we're done */
 253         }
 254
 255         return FALSE; /* continue the enumeration */
 256 }
 257
 258 static void
 259 ev_previewer_window_print (GtkAction         *action,
 260                            EvPreviewerWindow *window)
 261 {
 262         if (!window->print_settings)
 263                 window->print_settings = gtk_print_settings_new ();
 264         if (!window->print_page_setup)
 265                 window->print_page_setup = gtk_page_setup_new ();
 266         gtk_enumerate_printers ((GtkPrinterFunc)ev_previewer_window_enumerate_printers,
 267                                 window,
 268                                 (GDestroyNotify)ev_previewer_window_enumerate_finished,
 269                                 FALSE);
 270 }
 271 #endif
 272
 273 static const GtkActionEntry action_entries[] = {
 274         { "GoPreviousPage", GTK_STOCK_GO_UP, N_("_Previous Page"), "<control>Page_Up",
 275           N_("Go to the previous page"),
 276           G_CALLBACK (ev_previewer_window_previous_page) },
 277         { "GoNextPage", GTK_STOCK_GO_DOWN, N_("_Next Page"), "<control>Page_Down",
 278           N_("Go to the next page"),
 279           G_CALLBACK (ev_previewer_window_next_page) },
 280         { "ViewZoomIn", GTK_STOCK_ZOOM_IN, NULL, "<control>plus",
 281           N_("Enlarge the document"),
 282           G_CALLBACK (ev_previewer_window_zoom_in) },
 283         { "ViewZoomOut", GTK_STOCK_ZOOM_OUT, NULL, "<control>minus",
 284           N_("Shrink the document"),
 285           G_CALLBACK (ev_previewer_window_zoom_out) },
 286 #if GTKUNIXPRINT_ENABLED
 287         { "PreviewPrint", GTK_STOCK_PRINT, N_("Print"), NULL,
 288           N_("Print this document"),
 289           G_CALLBACK (ev_previewer_window_print) }
 290 #endif
 291 };
 292
 293 static const GtkActionEntry accel_entries[] = {
 294         { "Space", NULL, "", "space", NULL,
 295           G_CALLBACK (ev_previewer_window_scroll_forward) },
 296         { "ShiftSpace", NULL, "", "<shift>space", NULL,
 297           G_CALLBACK (ev_previewer_window_scroll_backward) },
 298         { "BackSpace", NULL, "", "BackSpace", NULL,
 299           G_CALLBACK (ev_previewer_window_scroll_backward) },
 300         { "ShiftBackSpace", NULL, "", "<shift>BackSpace", NULL,
 301           G_CALLBACK (ev_previewer_window_scroll_forward) },
 302         { "Return", NULL, "", "Return", NULL,
 303           G_CALLBACK (ev_previewer_window_scroll_forward) },
 304         { "ShiftReturn", NULL, "", "<shift>Return", NULL,
 305           G_CALLBACK (ev_previewer_window_scroll_backward) },
 306         { "p", GTK_STOCK_GO_UP, "", "p", NULL,
 307           G_CALLBACK (ev_previewer_window_previous_page) },
 308         { "n", GTK_STOCK_GO_DOWN, "", "n", NULL,
 309           G_CALLBACK (ev_previewer_window_next_page) },
 310         { "Plus", GTK_STOCK_ZOOM_IN, NULL, "plus", NULL,
 311           G_CALLBACK (ev_previewer_window_zoom_in) },
 312         { "CtrlEqual", GTK_STOCK_ZOOM_IN, NULL, "<control>equal", NULL,
 313           G_CALLBACK (ev_previewer_window_zoom_in) },
 314         { "Equal", GTK_STOCK_ZOOM_IN, NULL, "equal", NULL,
 315           G_CALLBACK (ev_previewer_window_zoom_in) },
 316         { "Minus", GTK_STOCK_ZOOM_OUT, NULL, "minus", NULL,
 317           G_CALLBACK (ev_previewer_window_zoom_out) },
 318         { "KpPlus", GTK_STOCK_ZOOM_IN, NULL, "KP_Add", NULL,
 319           G_CALLBACK (ev_previewer_window_zoom_in) },
 320         { "KpMinus", GTK_STOCK_ZOOM_OUT, NULL, "KP_Subtract", NULL,
 321           G_CALLBACK (ev_previewer_window_zoom_out) },
 322         { "CtrlKpPlus", GTK_STOCK_ZOOM_IN, NULL, "<control>KP_Add", NULL,
 323           G_CALLBACK (ev_previewer_window_zoom_in) },
 324         { "CtrlKpMinus", GTK_STOCK_ZOOM_OUT, NULL, "<control>KP_Subtract", NULL,
 325           G_CALLBACK (ev_previewer_window_zoom_out) },
 326         { "FocusPageSelector", NULL, "", "<control>l", NULL,
 327           G_CALLBACK (ev_previewer_window_focus_page_selector) }
 328
 329 };
 330
 331 static const GtkToggleActionEntry toggle_action_entries[] = {
 332         { "ViewBestFit", EV_STOCK_ZOOM_PAGE, N_("_Best Fit"), NULL,
 333           N_("Make the current document fill the window"),
 334           G_CALLBACK (ev_previewer_window_zoom_best_fit) },
 335         { "ViewPageWidth", EV_STOCK_ZOOM_WIDTH, N_("Fit Page _Width"), NULL,
 336           N_("Make the current document fill the window width"),
 337           G_CALLBACK (ev_previewer_window_zoom_page_width) }
 338 };
 339
 340 static gboolean
 341 view_focus_changed (GtkWidget         *widget,
 342                     GdkEventFocus     *event,
 343                     EvPreviewerWindow *window)
 344 {
 345         if (window->accels_group)
 346                 gtk_action_group_set_sensitive (window->accels_group, event->in);
 347
 348         return FALSE;
 349 }
 350
 351 static void
 352 view_sizing_mode_changed (EvDocumentModel   *model,
 353                           GParamSpec        *pspec,
 354                           EvPreviewerWindow *window)
 355 {
 356         EvSizingMode sizing_mode = ev_document_model_get_sizing_mode (model);
 357         GtkAction   *action;
 358
 359         action = gtk_action_group_get_action (window->action_group, "ViewBestFit");
 360         g_signal_handlers_block_by_func (action,
 361                                          G_CALLBACK (ev_previewer_window_zoom_best_fit),
 362                                          window);
 363         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 364                                       sizing_mode == EV_SIZING_BEST_FIT);
 365         g_signal_handlers_unblock_by_func (action,
 366                                            G_CALLBACK (ev_previewer_window_zoom_best_fit),
 367                                            window);
 368
 369         action = gtk_action_group_get_action (window->action_group, "ViewPageWidth");
 370         g_signal_handlers_block_by_func (action,
 371                                          G_CALLBACK (ev_previewer_window_zoom_page_width),
 372                                          window);
 373         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 374                                       sizing_mode == EV_SIZING_FIT_WIDTH);
 375         g_signal_handlers_unblock_by_func (action,
 376                                            G_CALLBACK (ev_previewer_window_zoom_page_width),
 377                                            window);
 378 }
 379
 380 static void
 381 ev_previewer_window_set_document (EvPreviewerWindow *window,
 382                                   GParamSpec        *pspec,
 383                                   EvDocumentModel   *model)
 384 {
 385         EvDocument *document = ev_document_model_get_document (model);
 386
 387         window->document = g_object_ref (document);
 388
 389         g_signal_connect (model, "notify::sizing-mode",
 390                           G_CALLBACK (view_sizing_mode_changed),
 391                           window);
 392         ev_view_set_loading (window->view, FALSE);
 393         gtk_action_group_set_sensitive (window->action_group, TRUE);
 394         gtk_action_group_set_sensitive (window->accels_group, TRUE);
 395 }
 396
 397 static void
 398 ev_previewer_window_connect_action_accelerators (EvPreviewerWindow *window)
 399 {
 400         GList *actions;
 401
 402         gtk_ui_manager_ensure_update (window->ui_manager);
 403
 404         actions = gtk_action_group_list_actions (window->action_group);
 405         g_list_foreach (actions, (GFunc)gtk_action_connect_accelerator, NULL);
 406         g_list_free (actions);
 407 }
 408
 409 static void
 410 ev_previewer_window_dispose (GObject *object)
 411 {
 412         EvPreviewerWindow *window = EV_PREVIEWER_WINDOW (object);
 413
 414         if (window->model) {
 415                 g_object_unref (window->model);
 416                 window->model = NULL;
 417         }
 418
 419         if (window->document) {
 420                 g_object_unref (window->document);
 421                 window->document = NULL;
 422         }
 423
 424         if (window->action_group) {
 425                 g_object_unref (window->action_group);
 426                 window->action_group = NULL;
 427         }
 428
 429         if (window->accels_group) {
 430                 g_object_unref (window->accels_group);
 431                 window->accels_group = NULL;
 432         }
 433
 434         if (window->ui_manager) {
 435                 g_object_unref (window->ui_manager);
 436                 window->ui_manager = NULL;
 437         }
 438
 439         if (window->print_settings) {
 440                 g_object_unref (window->print_settings);
 441                 window->print_settings = NULL;
 442         }
 443
 444         if (window->print_page_setup) {
 445                 g_object_unref (window->print_page_setup);
 446                 window->print_page_setup = NULL;
 447         }
 448
 449 #if GTKUNIXPRINT_ENABLED
 450         if (window->printer) {
 451                 g_object_unref (window->printer);
 452                 window->printer = NULL;
 453         }
 454 #endif
 455
 456         if (window->print_job_title) {
 457                 g_free (window->print_job_title);
 458                 window->print_job_title = NULL;
 459         }
 460
 461         if (window->source_file) {
 462                 g_free (window->source_file);
 463                 window->source_file = NULL;
 464         }
 465
 466         G_OBJECT_CLASS (ev_previewer_window_parent_class)->dispose (object);
 467 }
 468
 469 static gchar*
 470 data_dir (void)
 471 {
 472         gchar *datadir;
 473 #ifdef G_OS_WIN32
 474         gchar *dir;
 475
 476         dir = g_win32_get_package_installation_directory_of_module (NULL);
 477         datadir = g_build_filename (dir, "share", "evince", NULL);
 478         g_free (dir);
 479 #else
 480         datadir = g_strdup (DATADIR);
 481 #endif
 482
 483        return datadir;
 484 }
 485
 486 static void
 487 ev_previewer_window_init (EvPreviewerWindow *window)
 488 {
 489         gtk_window_set_default_size (GTK_WINDOW (window), 600, 600);
 490 }
 491
 492 static void
 493 ev_previewer_window_set_property (GObject      *object,
 494                                   guint         prop_id,
 495                                   const GValue *value,
 496                                   GParamSpec   *pspec)
 497 {
 498         EvPreviewerWindow *window = EV_PREVIEWER_WINDOW (object);
 499
 500         switch (prop_id) {
 501         case PROP_MODEL:
 502                 window->model = g_value_dup_object (value);
 503                 break;
 504         default:
 505                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 506         }
 507 }
 508
 509 static GObject *
 510 ev_previewer_window_constructor (GType                  type,
 511                                  guint                  n_construct_properties,
 512                                  GObjectConstructParam *construct_params)
 513 {
 514         GObject           *object;
 515         EvPreviewerWindow *window;
 516         GtkWidget         *vbox;
 517         GtkWidget         *toolbar;
 518         GtkAction         *action;
 519         GError            *error = NULL;
 520         gchar             *datadir, *ui_path;
 521         gdouble            dpi;
 522
 523         object = G_OBJECT_CLASS (ev_previewer_window_parent_class)->constructor (type,
 524                                                                                  n_construct_properties,
 525                                                                                  construct_params);
 526         window = EV_PREVIEWER_WINDOW (object);
 527
 528         dpi = get_screen_dpi (window);
 529         ev_document_model_set_min_scale (window->model, MIN_SCALE * dpi / 72.0);
 530         ev_document_model_set_max_scale (window->model, MAX_SCALE * dpi / 72.0);
 531         ev_document_model_set_sizing_mode (window->model, EV_SIZING_FIT_WIDTH);
 532         g_signal_connect_swapped (window->model, "notify::document",
 533                                   G_CALLBACK (ev_previewer_window_set_document),
 534                                   window);
 535
 536         window->action_group = gtk_action_group_new ("PreviewerActions");
 537         gtk_action_group_set_translation_domain (window->action_group, NULL);
 538         gtk_action_group_add_actions (window->action_group, action_entries,
 539                                       G_N_ELEMENTS (action_entries),
 540                                       window);
 541         gtk_action_group_add_toggle_actions (window->action_group, toggle_action_entries,
 542                                              G_N_ELEMENTS (toggle_action_entries),
 543                                              window);
 544         gtk_action_group_set_sensitive (window->action_group, FALSE);
 545
 546         action = g_object_new (EV_TYPE_PAGE_ACTION,
 547                                "name", "PageSelector",
 548                                "label", _("Page"),
 549                                "tooltip", _("Select Page"),
 550                                "icon_name", "text-x-generic",
 551                                "visible_overflown", FALSE,
 552                                NULL);
 553         ev_page_action_set_model (EV_PAGE_ACTION (action), window->model);
 554         g_signal_connect (action, "activate_link",
 555                           G_CALLBACK (ev_previewer_window_action_page_activated),
 556                           window);
 557         gtk_action_group_add_action (window->action_group, action);
 558         g_object_unref (action);
 559
 560         window->accels_group = gtk_action_group_new ("PreviewerAccelerators");
 561         gtk_action_group_add_actions (window->accels_group, accel_entries,
 562                                       G_N_ELEMENTS (accel_entries),
 563                                       window);
 564         gtk_action_group_set_sensitive (window->accels_group, FALSE);
 565
 566         window->ui_manager = gtk_ui_manager_new ();
 567         gtk_ui_manager_insert_action_group (window->ui_manager,
 568                                             window->action_group, 0);
 569         gtk_ui_manager_insert_action_group (window->ui_manager,
 570                                             window->accels_group, 1);
 571         gtk_window_add_accel_group (GTK_WINDOW (window),
 572                                     gtk_ui_manager_get_accel_group (window->ui_manager));
 573         datadir = data_dir ();
 574         ui_path = g_build_filename (datadir, "evince-previewer-ui.xml", NULL);
 575         if (!gtk_ui_manager_add_ui_from_file (window->ui_manager, ui_path, &error)) {
 576                 g_warning ("Failed to load ui from evince-previewer-ui.xml: %s", error->message);
 577                 g_error_free (error);
 578         }
 579         g_free (ui_path);
 580         g_free (datadir);
 581
 582         /* GTKUIManager connects actions accels only for menu items,
 583          * but not for tool items. See bug #612972.
 584          */
 585         ev_previewer_window_connect_action_accelerators (window);
 586
 587         view_sizing_mode_changed (window->model, NULL, window);
 588
 589         vbox = gtk_vbox_new (FALSE, 0);
 590
 591         toolbar = gtk_ui_manager_get_widget (window->ui_manager, "/PreviewToolbar");
 592         gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
 593         gtk_widget_show (toolbar);
 594
 595         window->swindow = gtk_scrolled_window_new (NULL, NULL);
 596         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (window->swindow),
 597                                         GTK_POLICY_AUTOMATIC,
 598                                         GTK_POLICY_AUTOMATIC);
 599
 600         window->view = EV_VIEW (ev_view_new ());
 601         g_signal_connect_object (window->view, "focus_in_event",
 602                                  G_CALLBACK (view_focus_changed),
 603                                  window, 0);
 604         g_signal_connect_object (window->view, "focus_out_event",
 605                                  G_CALLBACK (view_focus_changed),
 606                                  window, 0);
 607         ev_view_set_model (window->view, window->model);
 608         ev_document_model_set_continuous (window->model, FALSE);
 609         ev_view_set_loading (window->view, TRUE);
 610
 611         gtk_container_add (GTK_CONTAINER (window->swindow), GTK_WIDGET (window->view));
 612         gtk_widget_show (GTK_WIDGET (window->view));
 613
 614         gtk_box_pack_start (GTK_BOX (vbox), window->swindow, TRUE, TRUE, 0);
 615         gtk_widget_show (window->swindow);
 616
 617         gtk_container_add (GTK_CONTAINER (window), vbox);
 618         gtk_widget_show (vbox);
 619
 620         return object;
 621 }
 622
 623
 624 static void
 625 ev_previewer_window_class_init (EvPreviewerWindowClass *klass)
 626 {
 627         GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 628
 629         gobject_class->constructor = ev_previewer_window_constructor;
 630         gobject_class->set_property = ev_previewer_window_set_property;
 631         gobject_class->dispose = ev_previewer_window_dispose;
 632
 633         g_object_class_install_property (gobject_class,
 634                                          PROP_MODEL,
 635                                          g_param_spec_object ("model",
 636                                                               "Model",
 637                                                               "The document model",
 638                                                               EV_TYPE_DOCUMENT_MODEL,
 639                                                               G_PARAM_WRITABLE |
 640                                                               G_PARAM_CONSTRUCT_ONLY));
 641 }
 642
 643 /* Public methods */
 644 GtkWidget *
 645 ev_previewer_window_new (EvDocumentModel *model)
 646 {
 647         return GTK_WIDGET (g_object_new (EV_TYPE_PREVIEWER_WINDOW, "model", model, NULL));
 648 }
 649
 650 void
 651 ev_previewer_window_set_print_settings (EvPreviewerWindow *window,
 652                                         const gchar       *print_settings)
 653 {
 654         if (window->print_settings)
 655                 g_object_unref (window->print_settings);
 656         if (window->print_page_setup)
 657                 g_object_unref (window->print_page_setup);
 658         if (window->print_job_title)
 659                 g_free (window->print_job_title);
 660
 661         if (print_settings && g_file_test (print_settings, G_FILE_TEST_IS_REGULAR)) {
 662                 GKeyFile *key_file;
 663                 GError   *error = NULL;
 664
 665                 key_file = g_key_file_new ();
 666                 g_key_file_load_from_file (key_file,
 667                                            print_settings,
 668                                            G_KEY_FILE_KEEP_COMMENTS |
 669                                            G_KEY_FILE_KEEP_TRANSLATIONS,
 670                                            &error);
 671                 if (!error) {
 672                         GtkPrintSettings *psettings;
 673                         GtkPageSetup     *psetup;
 674                         gchar            *job_name;
 675
 676                         psettings = gtk_print_settings_new_from_key_file (key_file,
 677                                                                           "Print Settings",
 678                                                                           NULL);
 679                         window->print_settings = psettings ? psettings : gtk_print_settings_new ();
 680
 681                         psetup = gtk_page_setup_new_from_key_file (key_file,
 682                                                                    "Page Setup",
 683                                                                    NULL);
 684                         window->print_page_setup = psetup ? psetup : gtk_page_setup_new ();
 685
 686                         job_name = g_key_file_get_string (key_file,
 687                                                           "Print Job", "title",
 688                                                           NULL);
 689                         if (job_name) {
 690                                 window->print_job_title = job_name;
 691                                 gtk_window_set_title (GTK_WINDOW (window), job_name);
 692                         }
 693                 } else {
 694                         window->print_settings = gtk_print_settings_new ();
 695                         window->print_page_setup = gtk_page_setup_new ();
 696                         g_error_free (error);
 697                 }
 698
 699                 g_key_file_free (key_file);
 700         } else {
 701                 window->print_settings = gtk_print_settings_new ();
 702                 window->print_page_setup = gtk_page_setup_new ();
 703         }
 704 }
 705
 706 void
 707 ev_previewer_window_set_source_file (EvPreviewerWindow *window,
 708                                      const gchar       *source_file)
 709 {
 710         if (window->source_file)
 711                 g_free (window->source_file);
 712         window->source_file = g_strdup (source_file);
 713 }