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         GtkUIManager     *ui_manager;
  40
  41         GtkWidget        *swindow;
  42         EvView           *view;
  43         gdouble           dpi;
  44
  45         /* Printing */
  46         GtkPrintSettings *print_settings;
  47         GtkPageSetup     *print_page_setup;
  48 #if GTKUNIXPRINT_ENABLED
  49         GtkPrinter       *printer;
  50 #endif
  51         gchar            *print_job_title;
  52         gchar            *source_file;
  53 };
  54
  55 struct _EvPreviewerWindowClass {
  56         GtkWindowClass base_class;
  57 };
  58
  59 enum {
  60         PROP_0,
  61         PROP_MODEL
  62 };
  63
  64 #define MIN_SCALE 0.05409
  65 #define MAX_SCALE 4.0
  66
  67 G_DEFINE_TYPE (EvPreviewerWindow, ev_previewer_window, GTK_TYPE_WINDOW)
  68
  69 static gdouble
  70 get_screen_dpi (GtkWindow *window)
  71 {
  72         GdkScreen *screen;
  73         gdouble    xdpi, ydpi;
  74
  75         screen = gtk_window_get_screen (window);
  76
  77         xdpi = 25.4 * gdk_screen_get_width (screen) / gdk_screen_get_width_mm (screen);
  78         ydpi = 25.4 * gdk_screen_get_height (screen) / gdk_screen_get_height_mm (screen);
  79
  80         return (xdpi + ydpi) / 2.0;
  81 }
  82
  83 #if GTKUNIXPRINT_ENABLED
  84 static void
  85 ev_previewer_window_error_dialog_run (EvPreviewerWindow *window,
  86                                       GError            *error)
  87 {
  88         GtkWidget *dialog;
  89
  90         dialog = gtk_message_dialog_new (GTK_WINDOW (window),
  91                                          GTK_DIALOG_MODAL |
  92                                          GTK_DIALOG_DESTROY_WITH_PARENT,
  93                                          GTK_MESSAGE_ERROR,
  94                                          GTK_BUTTONS_CLOSE,
  95                                          "%s", _("Failed to print document"));
  96         gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
  97                                                   "%s", error->message);
  98         gtk_dialog_run (GTK_DIALOG (dialog));
  99         gtk_widget_destroy (dialog);
 100 }
 101 #endif
 102
 103 static void
 104 ev_previewer_window_previous_page (GtkAction         *action,
 105                                    EvPreviewerWindow *window)
 106 {
 107         ev_view_previous_page (window->view);
 108 }
 109
 110 static void
 111 ev_previewer_window_next_page (GtkAction         *action,
 112                                EvPreviewerWindow *window)
 113 {
 114         ev_view_next_page (window->view);
 115 }
 116
 117 static void
 118 ev_previewer_window_zoom_in (GtkAction         *action,
 119                              EvPreviewerWindow *window)
 120 {
 121         ev_document_model_set_sizing_mode (window->model, EV_SIZING_FREE);
 122         ev_view_zoom_in (window->view);
 123 }
 124
 125 static void
 126 ev_previewer_window_zoom_out (GtkAction         *action,
 127                               EvPreviewerWindow *window)
 128 {
 129         ev_document_model_set_sizing_mode (window->model, EV_SIZING_FREE);
 130         ev_view_zoom_out (window->view);
 131 }
 132
 133 static void
 134 ev_previewer_window_zoom_best_fit (GtkToggleAction   *action,
 135                                    EvPreviewerWindow *window)
 136 {
 137         ev_document_model_set_sizing_mode (window->model,
 138                                            gtk_toggle_action_get_active (action) ?
 139                                            EV_SIZING_BEST_FIT : EV_SIZING_FREE);
 140 }
 141
 142 static void
 143 ev_previewer_window_zoom_page_width (GtkToggleAction   *action,
 144                                      EvPreviewerWindow *window)
 145 {
 146         ev_document_model_set_sizing_mode (window->model,
 147                                            gtk_toggle_action_get_active (action) ?
 148                                            EV_SIZING_FIT_WIDTH : EV_SIZING_FREE);
 149 }
 150
 151 static void
 152 ev_previewer_window_action_page_activated (GtkAction         *action,
 153                                            EvLink            *link,
 154                                            EvPreviewerWindow *window)
 155 {
 156         ev_view_handle_link (window->view, link);
 157         gtk_widget_grab_focus (GTK_WIDGET (window->view));
 158 }
 159
 160 #if GTKUNIXPRINT_ENABLED
 161 static void
 162 ev_previewer_window_print_finished (GtkPrintJob       *print_job,
 163                                     EvPreviewerWindow *window,
 164                                     GError            *error)
 165 {
 166         if (error) {
 167                 ev_previewer_window_error_dialog_run (window, error);
 168         }
 169
 170         g_object_unref (print_job);
 171         gtk_widget_destroy (GTK_WIDGET (window));
 172 }
 173
 174 static void
 175 ev_previewer_window_do_print (EvPreviewerWindow *window)
 176 {
 177         GtkPrintJob *job;
 178         GError      *error = NULL;
 179
 180         job = gtk_print_job_new (window->print_job_title ?
 181                                  window->print_job_title :
 182                                  window->source_file,
 183                                  window->printer,
 184                                  window->print_settings,
 185                                  window->print_page_setup);
 186         if (gtk_print_job_set_source_file (job, window->source_file, &error)) {
 187                 gtk_print_job_send (job,
 188                                     (GtkPrintJobCompleteFunc)ev_previewer_window_print_finished,
 189                                     window, NULL);
 190         } else {
 191                 ev_previewer_window_error_dialog_run (window, error);
 192                 g_error_free (error);
 193         }
 194
 195         gtk_widget_hide (GTK_WIDGET (window));
 196 }
 197
 198 static void
 199 ev_previewer_window_enumerate_finished (EvPreviewerWindow *window)
 200 {
 201         if (window->printer) {
 202                 ev_previewer_window_do_print (window);
 203         } else {
 204                 GError *error = NULL;
 205
 206                 g_set_error (&error,
 207                              GTK_PRINT_ERROR,
 208                              GTK_PRINT_ERROR_GENERAL,
 209                              _("The selected printer '%s' could not be found"),
 210                              gtk_print_settings_get_printer (window->print_settings));
 211
 212                 ev_previewer_window_error_dialog_run (window, error);
 213                 g_error_free (error);
 214         }
 215 }
 216
 217 static gboolean
 218 ev_previewer_window_enumerate_printers (GtkPrinter        *printer,
 219                                         EvPreviewerWindow *window)
 220 {
 221         const gchar *printer_name;
 222
 223         printer_name = gtk_print_settings_get_printer (window->print_settings);
 224         if ((printer_name
 225              && strcmp (printer_name, gtk_printer_get_name (printer)) == 0) ||
 226             (!printer_name && gtk_printer_is_default (printer))) {
 227                 if (window->printer)
 228                         g_object_unref (window->printer);
 229                 window->printer = g_object_ref (printer);
 230
 231                 return TRUE; /* we're done */
 232         }
 233
 234         return FALSE; /* continue the enumeration */
 235 }
 236
 237 static void
 238 ev_previewer_window_print (GtkAction         *action,
 239                            EvPreviewerWindow *window)
 240 {
 241         if (!window->print_settings)
 242                 window->print_settings = gtk_print_settings_new ();
 243         if (!window->print_page_setup)
 244                 window->print_page_setup = gtk_page_setup_new ();
 245         gtk_enumerate_printers ((GtkPrinterFunc)ev_previewer_window_enumerate_printers,
 246                                 window,
 247                                 (GDestroyNotify)ev_previewer_window_enumerate_finished,
 248                                 FALSE);
 249 }
 250 #endif
 251
 252 static const GtkActionEntry action_entries[] = {
 253         { "GoPreviousPage", GTK_STOCK_GO_UP, N_("_Previous Page"), "<control>Page_Up",
 254           N_("Go to the previous page"),
 255           G_CALLBACK (ev_previewer_window_previous_page) },
 256         { "GoNextPage", GTK_STOCK_GO_DOWN, N_("_Next Page"), "<control>Page_Down",
 257           N_("Go to the next page"),
 258           G_CALLBACK (ev_previewer_window_next_page) },
 259         { "ViewZoomIn", GTK_STOCK_ZOOM_IN, NULL, "<control>plus",
 260           N_("Enlarge the document"),
 261           G_CALLBACK (ev_previewer_window_zoom_in) },
 262         { "ViewZoomOut", GTK_STOCK_ZOOM_OUT, NULL, "<control>minus",
 263           N_("Shrink the document"),
 264           G_CALLBACK (ev_previewer_window_zoom_out) },
 265 #if GTKUNIXPRINT_ENABLED
 266         { "PreviewPrint", GTK_STOCK_PRINT, N_("Print"), NULL,
 267           N_("Print this document"),
 268           G_CALLBACK (ev_previewer_window_print) }
 269 #endif
 270 };
 271
 272 static const GtkToggleActionEntry toggle_action_entries[] = {
 273         { "ViewBestFit", EV_STOCK_ZOOM_PAGE, N_("_Best Fit"), NULL,
 274           N_("Make the current document fill the window"),
 275           G_CALLBACK (ev_previewer_window_zoom_best_fit) },
 276         { "ViewPageWidth", EV_STOCK_ZOOM_WIDTH, N_("Fit Page _Width"), NULL,
 277           N_("Make the current document fill the window width"),
 278           G_CALLBACK (ev_previewer_window_zoom_page_width) }
 279 };
 280
 281 static void
 282 view_sizing_mode_changed (EvDocumentModel   *model,
 283                           GParamSpec        *pspec,
 284                           EvPreviewerWindow *window)
 285 {
 286         EvSizingMode sizing_mode = ev_document_model_get_sizing_mode (model);
 287         GtkAction   *action;
 288
 289         action = gtk_action_group_get_action (window->action_group, "ViewBestFit");
 290         g_signal_handlers_block_by_func (action,
 291                                          G_CALLBACK (ev_previewer_window_zoom_best_fit),
 292                                          window);
 293         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 294                                       sizing_mode == EV_SIZING_BEST_FIT);
 295         g_signal_handlers_unblock_by_func (action,
 296                                            G_CALLBACK (ev_previewer_window_zoom_best_fit),
 297                                            window);
 298
 299         action = gtk_action_group_get_action (window->action_group, "ViewPageWidth");
 300         g_signal_handlers_block_by_func (action,
 301                                          G_CALLBACK (ev_previewer_window_zoom_page_width),
 302                                          window);
 303         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 304                                       sizing_mode == EV_SIZING_FIT_WIDTH);
 305         g_signal_handlers_unblock_by_func (action,
 306                                            G_CALLBACK (ev_previewer_window_zoom_page_width),
 307                                            window);
 308 }
 309
 310 static void
 311 ev_previewer_window_set_document (EvPreviewerWindow *window,
 312                                   GParamSpec        *pspec,
 313                                   EvDocumentModel   *model)
 314 {
 315         EvDocument *document = ev_document_model_get_document (model);
 316
 317         window->document = g_object_ref (document);
 318
 319         g_signal_connect (model, "notify::sizing-mode",
 320                           G_CALLBACK (view_sizing_mode_changed),
 321                           window);
 322         ev_view_set_loading (window->view, FALSE);
 323         gtk_action_group_set_sensitive (window->action_group, TRUE);
 324 }
 325
 326 static void
 327 ev_previewer_window_dispose (GObject *object)
 328 {
 329         EvPreviewerWindow *window = EV_PREVIEWER_WINDOW (object);
 330
 331         if (window->model) {
 332                 g_object_unref (window->model);
 333                 window->model = NULL;
 334         }
 335
 336         if (window->document) {
 337                 g_object_unref (window->document);
 338                 window->document = NULL;
 339         }
 340
 341         if (window->action_group) {
 342                 g_object_unref (window->action_group);
 343                 window->action_group = NULL;
 344         }
 345
 346         if (window->ui_manager) {
 347                 g_object_unref (window->ui_manager);
 348                 window->ui_manager = NULL;
 349         }
 350
 351         if (window->print_settings) {
 352                 g_object_unref (window->print_settings);
 353                 window->print_settings = NULL;
 354         }
 355
 356         if (window->print_page_setup) {
 357                 g_object_unref (window->print_page_setup);
 358                 window->print_page_setup = NULL;
 359         }
 360
 361 #if GTKUNIXPRINT_ENABLED
 362         if (window->printer) {
 363                 g_object_unref (window->printer);
 364                 window->printer = NULL;
 365         }
 366 #endif
 367
 368         if (window->print_job_title) {
 369                 g_free (window->print_job_title);
 370                 window->print_job_title = NULL;
 371         }
 372
 373         if (window->source_file) {
 374                 g_free (window->source_file);
 375                 window->source_file = NULL;
 376         }
 377
 378         G_OBJECT_CLASS (ev_previewer_window_parent_class)->dispose (object);
 379 }
 380
 381 static gchar*
 382 data_dir (void)
 383 {
 384         gchar *datadir;
 385 #ifdef G_OS_WIN32
 386         gchar *dir;
 387
 388         dir = g_win32_get_package_installation_directory_of_module (NULL);
 389         datadir = g_build_filename (dir, "share", "evince", NULL);
 390         g_free (dir);
 391 #else
 392         datadir = g_strdup (DATADIR);
 393 #endif
 394
 395        return datadir;
 396 }
 397
 398 static void
 399 ev_previewer_window_init (EvPreviewerWindow *window)
 400 {
 401         gtk_window_set_default_size (GTK_WINDOW (window), 600, 600);
 402 }
 403
 404 static void
 405 ev_previewer_window_set_property (GObject      *object,
 406                                   guint         prop_id,
 407                                   const GValue *value,
 408                                   GParamSpec   *pspec)
 409 {
 410         EvPreviewerWindow *window = EV_PREVIEWER_WINDOW (object);
 411
 412         switch (prop_id) {
 413         case PROP_MODEL:
 414                 window->model = g_value_dup_object (value);
 415                 break;
 416         default:
 417                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 418         }
 419 }
 420
 421 static GObject *
 422 ev_previewer_window_constructor (GType                  type,
 423                                  guint                  n_construct_properties,
 424                                  GObjectConstructParam *construct_params)
 425 {
 426         GObject           *object;
 427         EvPreviewerWindow *window;
 428         GtkWidget         *vbox;
 429         GtkWidget         *toolbar;
 430         GtkAction         *action;
 431         GError            *error = NULL;
 432         gchar             *datadir, *ui_path;
 433         gdouble            dpi;
 434
 435         object = G_OBJECT_CLASS (ev_previewer_window_parent_class)->constructor (type,
 436                                                                                  n_construct_properties,
 437                                                                                  construct_params);
 438         window = EV_PREVIEWER_WINDOW (object);
 439
 440         dpi = get_screen_dpi (GTK_WINDOW (window));
 441         ev_document_model_set_min_scale (window->model, MIN_SCALE * dpi / 72.0);
 442         ev_document_model_set_max_scale (window->model, MAX_SCALE * dpi / 72.0);
 443         ev_document_model_set_sizing_mode (window->model, EV_SIZING_FIT_WIDTH);
 444         g_signal_connect_swapped (window->model, "notify::document",
 445                                   G_CALLBACK (ev_previewer_window_set_document),
 446                                   window);
 447
 448         window->action_group = gtk_action_group_new ("PreviewerActions");
 449         gtk_action_group_set_translation_domain (window->action_group, NULL);
 450         gtk_action_group_add_actions (window->action_group, action_entries,
 451                                       G_N_ELEMENTS (action_entries),
 452                                       window);
 453         gtk_action_group_add_toggle_actions (window->action_group, toggle_action_entries,
 454                                              G_N_ELEMENTS (toggle_action_entries),
 455                                              window);
 456         gtk_action_group_set_sensitive (window->action_group, FALSE);
 457
 458         action = g_object_new (EV_TYPE_PAGE_ACTION,
 459                                "name", "PageSelector",
 460                                "label", _("Page"),
 461                                "tooltip", _("Select Page"),
 462                                "icon_name", "text-x-generic",
 463                                "visible_overflown", FALSE,
 464                                NULL);
 465         ev_page_action_set_model (EV_PAGE_ACTION (action), window->model);
 466         g_signal_connect (action, "activate_link",
 467                           G_CALLBACK (ev_previewer_window_action_page_activated),
 468                           window);
 469         gtk_action_group_add_action (window->action_group, action);
 470         g_object_unref (action);
 471
 472         window->ui_manager = gtk_ui_manager_new ();
 473         gtk_ui_manager_insert_action_group (window->ui_manager,
 474                                             window->action_group, 0);
 475         gtk_window_add_accel_group (GTK_WINDOW (window),
 476                                     gtk_ui_manager_get_accel_group (window->ui_manager));
 477         datadir = data_dir ();
 478         ui_path = g_build_filename (datadir, "evince-previewer-ui.xml", NULL);
 479         if (!gtk_ui_manager_add_ui_from_file (window->ui_manager, ui_path, &error)) {
 480                 g_warning ("Failed to load ui from evince-previewer-ui.xml: %s", error->message);
 481                 g_error_free (error);
 482         }
 483         g_free (ui_path);
 484         g_free (datadir);
 485
 486         view_sizing_mode_changed (window->model, NULL, window);
 487
 488         vbox = gtk_vbox_new (FALSE, 0);
 489
 490         toolbar = gtk_ui_manager_get_widget (window->ui_manager, "/PreviewToolbar");
 491         gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
 492         gtk_widget_show (toolbar);
 493
 494         window->swindow = gtk_scrolled_window_new (NULL, NULL);
 495         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (window->swindow),
 496                                         GTK_POLICY_AUTOMATIC,
 497                                         GTK_POLICY_AUTOMATIC);
 498
 499         window->view = EV_VIEW (ev_view_new ());
 500         ev_view_set_model (window->view, window->model);
 501         ev_view_set_continuous (window->view, FALSE);
 502         ev_view_set_loading (window->view, TRUE);
 503
 504         gtk_container_add (GTK_CONTAINER (window->swindow), GTK_WIDGET (window->view));
 505         gtk_widget_show (GTK_WIDGET (window->view));
 506
 507         gtk_box_pack_start (GTK_BOX (vbox), window->swindow, TRUE, TRUE, 0);
 508         gtk_widget_show (window->swindow);
 509
 510         gtk_container_add (GTK_CONTAINER (window), vbox);
 511         gtk_widget_show (vbox);
 512
 513         return object;
 514 }
 515
 516
 517 static void
 518 ev_previewer_window_class_init (EvPreviewerWindowClass *klass)
 519 {
 520         GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 521
 522         gobject_class->constructor = ev_previewer_window_constructor;
 523         gobject_class->set_property = ev_previewer_window_set_property;
 524         gobject_class->dispose = ev_previewer_window_dispose;
 525
 526         g_object_class_install_property (gobject_class,
 527                                          PROP_MODEL,
 528                                          g_param_spec_object ("model",
 529                                                               "Model",
 530                                                               "The document model",
 531                                                               EV_TYPE_DOCUMENT_MODEL,
 532                                                               G_PARAM_WRITABLE |
 533                                                               G_PARAM_CONSTRUCT_ONLY));
 534 }
 535
 536 /* Public methods */
 537 GtkWidget *
 538 ev_previewer_window_new (EvDocumentModel *model)
 539 {
 540         return GTK_WIDGET (g_object_new (EV_TYPE_PREVIEWER_WINDOW, "model", model, NULL));
 541 }
 542
 543 void
 544 ev_previewer_window_set_print_settings (EvPreviewerWindow *window,
 545                                         const gchar       *print_settings)
 546 {
 547         if (window->print_settings)
 548                 g_object_unref (window->print_settings);
 549         if (window->print_page_setup)
 550                 g_object_unref (window->print_page_setup);
 551         if (window->print_job_title)
 552                 g_free (window->print_job_title);
 553
 554         if (print_settings && g_file_test (print_settings, G_FILE_TEST_IS_REGULAR)) {
 555                 GKeyFile *key_file;
 556                 GError   *error = NULL;
 557
 558                 key_file = g_key_file_new ();
 559                 g_key_file_load_from_file (key_file,
 560                                            print_settings,
 561                                            G_KEY_FILE_KEEP_COMMENTS |
 562                                            G_KEY_FILE_KEEP_TRANSLATIONS,
 563                                            &error);
 564                 if (!error) {
 565                         GtkPrintSettings *psettings;
 566                         GtkPageSetup     *psetup;
 567                         gchar            *job_name;
 568
 569                         psettings = gtk_print_settings_new_from_key_file (key_file,
 570                                                                           "Print Settings",
 571                                                                           NULL);
 572                         window->print_settings = psettings ? psettings : gtk_print_settings_new ();
 573
 574                         psetup = gtk_page_setup_new_from_key_file (key_file,
 575                                                                    "Page Setup",
 576                                                                    NULL);
 577                         window->print_page_setup = psetup ? psetup : gtk_page_setup_new ();
 578
 579                         job_name = g_key_file_get_string (key_file,
 580                                                           "Print Job", "title",
 581                                                           NULL);
 582                         if (job_name) {
 583                                 window->print_job_title = job_name;
 584                                 gtk_window_set_title (GTK_WINDOW (window), job_name);
 585                         }
 586                 } else {
 587                         window->print_settings = gtk_print_settings_new ();
 588                         window->print_page_setup = gtk_page_setup_new ();
 589                         g_error_free (error);
 590                 }
 591
 592                 g_key_file_free (key_file);
 593         } else {
 594                 window->print_settings = gtk_print_settings_new ();
 595                 window->print_page_setup = gtk_page_setup_new ();
 596         }
 597 }
 598
 599 void
 600 ev_previewer_window_set_source_file (EvPreviewerWindow *window,
 601                                      const gchar       *source_file)
 602 {
 603         if (window->source_file)
 604                 g_free (window->source_file);
 605         window->source_file = g_strdup (source_file);
 606 }