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