shell/ev-window.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
   2 /* this file is part of evince, a gnome document viewer
   3  *
   4  *  Copyright (C) 2004 Martin Kretzschmar
   5  *  Copyright (C) 2004 Red Hat, Inc.
   6  *  Copyright (C) 2000, 2001, 2002, 2003, 2004 Marco Pesenti Gritti
   7  *  Copyright (C) 2003, 2004, 2005 Christian Persch
   8  *
   9  *  Author:
  10  *    Martin Kretzschmar <martink@gnome.org>
  11  *
  12  * Evince is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * Evince is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include "ev-window.h"
  32 #include "ev-page-action.h"
  33 #include "ev-sidebar.h"
  34 #include "ev-sidebar-links.h"
  35 #include "ev-sidebar-thumbnails.h"
  36 #include "ev-view.h"
  37 #include "ev-password.h"
  38 #include "ev-password-view.h"
  39 #include "ev-print-job.h"
  40 #include "ev-document-thumbnails.h"
  41 #include "ev-document-links.h"
  42 #include "ev-document-find.h"
  43 #include "ev-document-security.h"
  44 #include "ev-job-queue.h"
  45 #include "eggfindbar.h"
  46 #include "egg-recent-view-gtk.h"
  47 #include "egg-recent-view.h"
  48 #include "egg-recent-model.h"
  49
  50 #include "ev-poppler.h"
  51 #include "pixbuf-document.h"
  52 #include "ps-document.h"
  53 #ifdef ENABLE_DVI
  54 #include "dvi-document.h"
  55 #endif
  56 #ifdef ENABLE_DJVU
  57 #include "djvu-document.h"
  58 #endif
  59
  60 #include <glib/gi18n.h>
  61 #include <gtk/gtk.h>
  62 #include <gnome.h>
  63
  64 #include <libgnomevfs/gnome-vfs-mime-utils.h>
  65 #include <libgnomevfs/gnome-vfs-uri.h>
  66 #include <libgnomevfs/gnome-vfs-utils.h>
  67 #include <libgnomeprintui/gnome-print-dialog.h>
  68
  69 #include <gconf/gconf-client.h>
  70
  71 #include <string.h>
  72
  73 #include "ev-application.h"
  74 #include "ev-stock-icons.h"
  75
  76 typedef enum {
  77         EV_SIZING_BEST_FIT,
  78         EV_SIZING_FIT_WIDTH,
  79         EV_SIZING_FREE,
  80 } EvSizingMode;
  81
  82 typedef enum {
  83         PAGE_MODE_SINGLE_PAGE,
  84         PAGE_MODE_CONTINUOUS_PAGE,
  85         PAGE_MODE_PASSWORD,
  86 } EvWindowPageMode;
  87
  88 typedef enum {
  89         EV_CHROME_MENUBAR       = 1 << 0,
  90         EV_CHROME_TOOLBAR       = 1 << 1,
  91         EV_CHROME_SIDEBAR       = 1 << 2,
  92         EV_CHROME_FINDBAR       = 1 << 3,
  93         EV_CHROME_STATUSBAR     = 1 << 4,
  94         EV_CHROME_NORMAL        = EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR | EV_CHROME_STATUSBAR
  95 } EvChrome;
  96
  97 struct _EvWindowPrivate {
  98         GtkWidget *main_box;
  99         GtkWidget *menubar;
 100         GtkWidget *toolbar_dock;
 101         GtkWidget *toolbar;
 102         GtkWidget *hpaned;
 103         GtkWidget *sidebar;
 104         GtkWidget *thumbs_sidebar;
 105         GtkWidget *find_bar;
 106         GtkWidget *scrolled_window;
 107         GtkWidget *view;
 108         GtkWidget *page_view;
 109         GtkWidget *password_view;
 110         GtkActionGroup *action_group;
 111         GtkUIManager *ui_manager;
 112         GtkWidget *statusbar;
 113         guint help_message_cid;
 114         guint view_message_cid;
 115         GtkWidget *fullscreen_toolbar;
 116         GtkWidget *fullscreen_popup;
 117         char *uri;
 118
 119         EvDocument *document;
 120         EvPageCache *page_cache;
 121
 122         EvWindowPageMode page_mode;
 123         /* These members are used temporarily when in PAGE_MODE_PASSWORD */
 124         EvDocument *password_document;
 125         GtkWidget *password_dialog;
 126         char *password_uri;
 127
 128         EvChrome chrome;
 129         gboolean fullscreen_mode;
 130         EvSizingMode sizing_mode;
 131         GSource *fullscreen_timeout_source;
 132
 133         /* recent file stuff */
 134         EggRecentModel *recent_model;
 135         EggRecentViewGtk *recent_view;
 136 };
 137
 138 static GtkTargetEntry ev_drop_types[] = {
 139         { "text/uri-list", 0, 0 }
 140 };
 141
 142
 143 #define EV_WINDOW_GET_PRIVATE(object) \
 144         (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_WINDOW, EvWindowPrivate))
 145
 146 #define PAGE_SELECTOR_ACTION    "PageSelector"
 147
 148 #define GCONF_CHROME_TOOLBAR    "/apps/evince/show_toolbar"
 149 #define GCONF_CHROME_SIDEBAR    "/apps/evince/show_sidebar"
 150 #define GCONF_CHROME_STATUSBAR  "/apps/evince/show_statusbar"
 151
 152 #define GCONF_SIDEBAR_SIZE      "/apps/evince/sidebar_size"
 153 #define SIDEBAR_DEFAULT_SIZE    132
 154
 155 static void     ev_window_update_fullscreen_popup (EvWindow         *window);
 156 static void     ev_window_sidebar_visibility_changed_cb (EvSidebar *ev_sidebar, GParamSpec *pspec,
 157                                                          EvWindow   *ev_window);
 158 static void     ev_window_set_page_mode           (EvWindow         *window,
 159                                                    EvWindowPageMode  page_mode);
 160 static gboolean start_loading_document            (EvWindow         *ev_window,
 161                                                    EvDocument       *document,
 162                                                    const char       *uri);
 163 static void     ev_window_set_sizing_mode         (EvWindow         *ev_window,
 164                                                    EvSizingMode      sizing_mode);
 165
 166 static void     ev_window_add_recent (EvWindow *window, const char *filename);
 167
 168 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
 169
 170 static void
 171 set_action_sensitive (EvWindow   *ev_window,
 172                       const char *name,
 173                       gboolean    sensitive)
 174 {
 175         GtkAction *action = gtk_action_group_get_action (ev_window->priv->action_group,
 176                                                          name);
 177         gtk_action_set_sensitive (action, sensitive);
 178 }
 179
 180 static void
 181 update_action_sensitivity (EvWindow *ev_window)
 182 {
 183         EvDocument *document;
 184         EvWindowPageMode page_mode;
 185         EvView *view;
 186         gboolean sensitive;
 187
 188         document = ev_window->priv->document;
 189         page_mode = ev_window->priv->page_mode;
 190         view = EV_VIEW (ev_window->priv->view);
 191
 192         /* File menu */
 193         /* "FileOpen": always sensitive */
 194         set_action_sensitive (ev_window, "FileSaveAs", document!=NULL);
 195         set_action_sensitive (ev_window, "FilePrint", document!=NULL);
 196         /* "FileCloseWindow": always sensitive */
 197
 198         /* Edit menu */
 199
 200         sensitive = document && ev_document_can_get_text (document);
 201         set_action_sensitive (ev_window, "EditCopy", sensitive);
 202         set_action_sensitive (ev_window, "EditSelectAll", sensitive);
 203
 204         if (document)
 205                 set_action_sensitive (ev_window, "EditFind", EV_IS_DOCUMENT_FIND (document));
 206         else
 207                 set_action_sensitive (ev_window, "EditFind", FALSE);
 208
 209         set_action_sensitive (ev_window, "EditFindNext",
 210                               ev_view_can_find_next (EV_VIEW (ev_window->priv->view)));
 211
 212         /* View menu */
 213         set_action_sensitive (ev_window, "ViewZoomIn", document!=NULL);
 214         set_action_sensitive (ev_window, "ViewZoomOut", document!=NULL);
 215         set_action_sensitive (ev_window, "ViewNormalSize", document!=NULL);
 216         set_action_sensitive (ev_window, "ViewBestFit", document!=NULL);
 217         set_action_sensitive (ev_window, "ViewPageWidth", document!=NULL);
 218         set_action_sensitive (ev_window, "ViewReload", document!=NULL);
 219
 220         /* Go menu */
 221         if (document) {
 222                 int n_pages;
 223                 int page;
 224                 page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
 225                 n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
 226
 227                 set_action_sensitive (ev_window, "GoPreviousPage", page > 0);
 228                 set_action_sensitive (ev_window, "GoNextPage", page < n_pages - 1);
 229                 set_action_sensitive (ev_window, "GoFirstPage", page > 0);
 230                 set_action_sensitive (ev_window, "GoLastPage", page < n_pages - 1);
 231         } else {
 232                 set_action_sensitive (ev_window, "GoFirstPage", FALSE);
 233                 set_action_sensitive (ev_window, "GoPreviousPage", FALSE);
 234                 set_action_sensitive (ev_window, "GoNextPage", FALSE);
 235                 set_action_sensitive (ev_window, "GoLastPage", FALSE);
 236         }
 237
 238         /* Page View radio group */
 239         if (document) {
 240                 set_action_sensitive (ev_window, "SinglePage", page_mode != PAGE_MODE_PASSWORD);
 241                 set_action_sensitive (ev_window, "ContinuousPage", page_mode != PAGE_MODE_PASSWORD);
 242         } else {
 243                 set_action_sensitive (ev_window, "SinglePage", FALSE);
 244                 set_action_sensitive (ev_window, "ContinuousPage", FALSE);
 245         }
 246         /* Help menu */
 247         /* "HelpContents": always sensitive */
 248         /* "HelpAbout": always sensitive */
 249
 250         /* Toolbar-specific actions: */
 251         set_action_sensitive (ev_window, PAGE_SELECTOR_ACTION, document!=NULL);
 252 }
 253
 254 static void
 255 set_widget_visibility (GtkWidget *widget, gboolean visible)
 256 {
 257         g_return_if_fail (GTK_IS_WIDGET (widget));
 258
 259         if (visible)
 260                 gtk_widget_show (widget);
 261         else
 262                 gtk_widget_hide (widget);
 263 }
 264
 265 static void
 266 update_chrome_visibility (EvWindow *window)
 267 {
 268         EvWindowPrivate *priv = window->priv;
 269         gboolean menubar, toolbar, sidebar, findbar, statusbar, fullscreen_toolbar;
 270
 271         menubar = (priv->chrome & EV_CHROME_MENUBAR) != 0 && !priv->fullscreen_mode;
 272         toolbar = (priv->chrome & EV_CHROME_TOOLBAR) != 0 && !priv->fullscreen_mode;
 273         sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !priv->fullscreen_mode;
 274         fullscreen_toolbar = (priv->chrome & EV_CHROME_TOOLBAR) != 0;
 275         statusbar = (priv->chrome & EV_CHROME_STATUSBAR) != 0 && !priv->fullscreen_mode;
 276         findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;
 277
 278         set_widget_visibility (priv->menubar, menubar);
 279         set_widget_visibility (priv->toolbar_dock, toolbar);
 280         set_widget_visibility (priv->sidebar, sidebar);
 281         set_widget_visibility (priv->find_bar, findbar);
 282         set_widget_visibility (priv->statusbar, statusbar);
 283         set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);
 284
 285         if (priv->fullscreen_popup != NULL) {
 286                 set_widget_visibility (priv->fullscreen_popup, priv->fullscreen_mode);
 287         }
 288 }
 289
 290 static void
 291 update_chrome_flag (EvWindow *window, EvChrome flag, const char *pref, gboolean active)
 292 {
 293         EvWindowPrivate *priv = window->priv;
 294         GConfClient *client;
 295
 296         if (active) {
 297                 priv->chrome |= flag;
 298         }
 299         else {
 300                 priv->chrome &= ~flag;
 301         }
 302
 303         if (pref != NULL) {
 304                 client = gconf_client_get_default ();
 305                 gconf_client_set_bool (client, pref, active, NULL);
 306                 g_object_unref (client);
 307         }
 308
 309         update_chrome_visibility (window);
 310 }
 311
 312 static void
 313 ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
 314 {
 315         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
 316                 ev_window_set_sizing_mode (ev_window, EV_SIZING_BEST_FIT);
 317         } else {
 318                 ev_window_set_sizing_mode (ev_window, EV_SIZING_FREE);
 319         }
 320 }
 321
 322 static void
 323 ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window)
 324 {
 325         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
 326                 ev_window_set_sizing_mode (ev_window, EV_SIZING_FIT_WIDTH);
 327         } else {
 328                 ev_window_set_sizing_mode (ev_window, EV_SIZING_FREE);
 329         }
 330 }
 331
 332 static void
 333 update_sizing_buttons (EvWindow *window)
 334 {
 335         GtkActionGroup *action_group = window->priv->action_group;
 336         GtkAction *action;
 337         gboolean best_fit, page_width;
 338
 339         switch (window->priv->sizing_mode) {
 340         case EV_SIZING_BEST_FIT:
 341                 best_fit = TRUE;
 342                 page_width = FALSE;
 343                 break;
 344         case EV_SIZING_FIT_WIDTH:
 345                 best_fit = FALSE;
 346                 page_width = TRUE;
 347                 break;
 348
 349         default:
 350                 best_fit = page_width = FALSE;
 351                 break;
 352         }
 353
 354         action = gtk_action_group_get_action (action_group, "ViewBestFit");
 355         g_signal_handlers_block_by_func
 356                 (action, G_CALLBACK (ev_window_cmd_view_best_fit), window);
 357         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), best_fit);
 358         g_signal_handlers_unblock_by_func
 359                 (action, G_CALLBACK (ev_window_cmd_view_best_fit), window);
 360
 361         action = gtk_action_group_get_action (action_group, "ViewPageWidth");
 362         g_signal_handlers_block_by_func
 363                 (action, G_CALLBACK (ev_window_cmd_view_page_width), window);
 364         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), page_width);
 365         g_signal_handlers_unblock_by_func
 366                 (action, G_CALLBACK (ev_window_cmd_view_page_width), window);
 367 }
 368
 369 void
 370 ev_window_open_page (EvWindow *ev_window, int page)
 371 {
 372         if (ev_window->priv->page_cache) {
 373             page = CLAMP (page, 0, ev_page_cache_get_n_pages (ev_window->priv->page_cache));
 374             ev_page_cache_set_current_page (ev_window->priv->page_cache, page);
 375         }
 376 }
 377
 378 void
 379 ev_window_open_link (EvWindow *ev_window, EvLink *link)
 380 {
 381         ev_view_go_to_link (EV_VIEW (ev_window->priv->view), link);
 382 }
 383
 384 gboolean
 385 ev_window_is_empty (const EvWindow *ev_window)
 386 {
 387         g_return_val_if_fail (EV_IS_WINDOW (ev_window), FALSE);
 388
 389         return ev_window->priv->document == NULL;
 390 }
 391
 392 static void
 393 unable_to_load (EvWindow   *ev_window,
 394                 const char *error_message)
 395 {
 396         GtkWidget *dialog;
 397
 398         dialog = gtk_message_dialog_new (GTK_WINDOW (ev_window),
 399                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 400                                          GTK_MESSAGE_ERROR,
 401                                          GTK_BUTTONS_CLOSE,
 402                                          _("Unable to open document"));
 403         gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
 404                                                   "%s", error_message);
 405         gtk_dialog_run (GTK_DIALOG (dialog));
 406         gtk_widget_destroy (dialog);
 407 }
 408
 409 /* Would be nice to have this in gdk-pixbuf */
 410 static gboolean
 411 mime_type_supported_by_gdk_pixbuf (const gchar *mime_type)
 412 {
 413         GSList *formats, *list;
 414         gboolean retval = FALSE;
 415
 416         formats = gdk_pixbuf_get_formats ();
 417
 418         list = formats;
 419         while (list) {
 420                 GdkPixbufFormat *format = list->data;
 421                 int i;
 422                 gchar **mime_types;
 423
 424                 if (gdk_pixbuf_format_is_disabled (format))
 425                         continue;
 426
 427                 mime_types = gdk_pixbuf_format_get_mime_types (format);
 428
 429                 for (i = 0; mime_types[i] != NULL; i++) {
 430                         if (strcmp (mime_types[i], mime_type) == 0) {
 431                                 retval = TRUE;
 432                                 break;
 433                         }
 434                 }
 435
 436                 if (retval)
 437                         break;
 438
 439                 list = list->next;
 440         }
 441
 442         g_slist_free (formats);
 443
 444         return retval;
 445 }
 446
 447 static void
 448 update_window_title (EvDocument *document, GParamSpec *pspec, EvWindow *ev_window)
 449 {
 450         char *title = NULL;
 451         char *doc_title = NULL;
 452         gboolean password_needed;
 453
 454         password_needed = (ev_window->priv->password_document != NULL);
 455         if (document) {
 456                 doc_title = ev_page_cache_get_title (ev_window->priv->page_cache);
 457
 458                 /* Make sure we get a valid title back */
 459                 if (doc_title) {
 460                         if (doc_title[0] == '\000' ||
 461                             !g_utf8_validate (doc_title, -1, NULL)) {
 462                                 g_free (doc_title);
 463                                 doc_title = NULL;
 464                         }
 465                 }
 466         }
 467
 468         if (doc_title) {
 469                 char *p;
 470
 471                 for (p = doc_title; *p; ++p) {
 472                         /* an '\n' byte is always ASCII, no need for UTF-8 special casing */
 473                         if (*p == '\n')
 474                                 *p = ' ';
 475                 }
 476         }
 477
 478         if (doc_title == NULL && ev_window->priv->uri) {
 479                 char *basename;
 480
 481                 basename = g_path_get_basename (ev_window->priv->uri);
 482                 doc_title = gnome_vfs_unescape_string_for_display (basename);
 483                 g_free (basename);
 484         }
 485
 486         if (password_needed) {
 487                 if (doc_title == NULL) {
 488                         title = g_strdup (_("Document Viewer - Password Required"));
 489                 } else {
 490                         title = g_strdup_printf (_("%s - Password Required"), doc_title);
 491                 }
 492         } else {
 493                 if (doc_title == NULL) {
 494                         title = g_strdup (_("Document Viewer"));
 495                 } else {
 496                         title = g_strdup (doc_title);
 497                 }
 498         }
 499
 500         gtk_window_set_title (GTK_WINDOW (ev_window), title);
 501
 502         g_free (doc_title);
 503         g_free (title);
 504 }
 505
 506 /* This function assumes that ev_window just had ev_window->document set.
 507  */
 508 static gboolean
 509 document_supports_sidebar (EvDocument *document)
 510 {
 511         return (EV_IS_DOCUMENT_THUMBNAILS (document) || (EV_IS_DOCUMENT_LINKS (document)));
 512 }
 513
 514 static void
 515 hide_sidebar_and_actions (EvWindow *ev_window)
 516 {
 517         GtkAction *action;
 518         /* Alsthough we update the hiddenness of the sidebar, we don't want to
 519          * store the value */
 520         g_signal_handlers_disconnect_by_func (ev_window->priv->sidebar,
 521                                               ev_window_sidebar_visibility_changed_cb,
 522                                               ev_window);
 523         gtk_widget_hide (ev_window->priv->sidebar);
 524         action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
 525         gtk_action_set_sensitive (action, FALSE);
 526
 527 }
 528
 529 static void
 530 find_changed_cb (EvDocument *document, int page, EvWindow *ev_window)
 531 {
 532         update_action_sensitivity (ev_window);
 533 }
 534
 535 static void
 536 page_changed_cb (EvPageCache *page_cache,
 537                  gint         page,
 538                  EvWindow    *ev_window)
 539 {
 540         update_action_sensitivity (ev_window);
 541 }
 542
 543 static void
 544 ev_window_setup_document (EvWindow *ev_window)
 545 {
 546         EvDocument *document;
 547         EvView *view = EV_VIEW (ev_window->priv->view);
 548         EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar);
 549         GtkAction *action;
 550
 551         document = ev_window->priv->document;
 552         ev_window->priv->page_cache = ev_document_get_page_cache (ev_window->priv->document);
 553         g_signal_connect (ev_window->priv->page_cache, "page-changed", G_CALLBACK (page_changed_cb), ev_window);
 554
 555         g_signal_connect_object (G_OBJECT (document),
 556                                  "notify::title",
 557                                  G_CALLBACK (update_window_title),
 558                                  ev_window, 0);
 559         if (EV_IS_DOCUMENT_FIND (document)) {
 560                 g_signal_connect_object (G_OBJECT (document),
 561                                          "find_changed",
 562                                          G_CALLBACK (find_changed_cb),
 563                                          ev_window, 0);
 564         }
 565
 566         ev_window_set_page_mode (ev_window, PAGE_MODE_SINGLE_PAGE);
 567
 568         if (document_supports_sidebar (document))
 569                 ev_sidebar_set_document (sidebar, document);
 570         else
 571                 hide_sidebar_and_actions (ev_window);
 572
 573         ev_view_set_document (view, document);
 574
 575         update_window_title (document, NULL, ev_window);
 576         action = gtk_action_group_get_action (ev_window->priv->action_group, PAGE_SELECTOR_ACTION);
 577         ev_page_action_set_document (EV_PAGE_ACTION (action), document);
 578         update_action_sensitivity (ev_window);
 579 }
 580
 581 static void
 582 password_dialog_response (GtkWidget *password_dialog,
 583                           gint       response_id,
 584                           EvWindow  *ev_window)
 585 {
 586         char *password;
 587
 588         if (response_id == GTK_RESPONSE_OK) {
 589                 EvDocument *document;
 590                 gchar *uri;
 591
 592                 password = ev_password_dialog_get_password (password_dialog);
 593                 if (password) {
 594                         g_mutex_lock (EV_DOC_MUTEX);
 595                         ev_document_security_set_password (EV_DOCUMENT_SECURITY (ev_window->priv->password_document),
 596                                                            password);
 597                         g_mutex_unlock (EV_DOC_MUTEX);
 598                 }
 599                 g_free (password);
 600
 601                 document = ev_window->priv->password_document;
 602                 uri = ev_window->priv->password_uri;
 603
 604                 ev_window->priv->password_document = NULL;
 605                 ev_window->priv->password_uri = NULL;
 606
 607                 if (start_loading_document (ev_window, document, uri)) {
 608                         gtk_widget_destroy (password_dialog);
 609                 }
 610
 611                 g_object_unref (document);
 612                 g_free (uri);
 613
 614                 return;
 615         }
 616
 617         gtk_widget_set_sensitive (ev_window->priv->password_view, TRUE);
 618         gtk_widget_destroy (password_dialog);
 619 }
 620
 621 /* Called either by start_loading_document or by the "unlock" callback on the
 622  * password_view page.  It assumes that ev_window->priv->password_* has been set
 623  * correctly.  These are cleared by password_dialog_response() */
 624
 625 static void
 626 ev_window_popup_password_dialog (EvWindow *ev_window)
 627 {
 628         g_assert (ev_window->priv->password_document);
 629         g_assert (ev_window->priv->password_uri);
 630
 631         gtk_widget_set_sensitive (ev_window->priv->password_view, FALSE);
 632
 633         update_window_title (ev_window->priv->password_document, NULL, ev_window);
 634         if (ev_window->priv->password_dialog == NULL) {
 635                 gchar *basename, *file_name;
 636
 637                 basename = g_path_get_basename (ev_window->priv->password_uri);
 638                 file_name = gnome_vfs_unescape_string_for_display (basename);
 639                 ev_window->priv->password_dialog =
 640                         ev_password_dialog_new (GTK_WIDGET (ev_window), file_name);
 641                 g_object_add_weak_pointer (G_OBJECT (ev_window->priv->password_dialog),
 642                                            (gpointer *) &(ev_window->priv->password_dialog));
 643                 g_signal_connect (ev_window->priv->password_dialog,
 644                                   "response",
 645                                   G_CALLBACK (password_dialog_response),
 646                                   ev_window);
 647                 g_free (basename);
 648                 g_free (file_name);
 649                 gtk_widget_show (ev_window->priv->password_dialog);
 650         } else {
 651                 ev_password_dialog_set_bad_pass (ev_window->priv->password_dialog);
 652         }
 653 }
 654
 655 /* This wil try to load the document.  It might be called multiple times on the
 656  * same document by the password dialog.
 657  *
 658  * Since the flow of the error dialog is very confusing, we assume that both
 659  * document and uri will go away after this function is called, and thus we need
 660  * to ref/dup them.  Additionally, it needs to clear
 661  * ev_window->priv->password_{uri,document}, and thus people who call this
 662  * function should _not_ necessarily expect those to exist after being
 663  * called. */
 664 static gboolean
 665 start_loading_document (EvWindow   *ev_window,
 666                         EvDocument *document,
 667                         const char *uri)
 668 {
 669         gboolean result;
 670         GError *error = NULL;
 671
 672         g_assert (document);
 673         g_assert (document != ev_window->priv->document);
 674         g_assert (uri);
 675         if (ev_window->priv->password_document) {
 676                 g_object_unref (ev_window->priv->password_document);
 677                 ev_window->priv->password_document = NULL;
 678         }
 679         if (ev_window->priv->password_uri) {
 680                 g_free (ev_window->priv->password_uri);
 681                 ev_window->priv->password_uri = NULL;
 682         }
 683
 684         result = ev_document_load (document, uri, &error);
 685
 686         /* Success! */
 687         if (result) {
 688                 if (ev_window->priv->document)
 689                         g_object_unref (ev_window->priv->document);
 690                 ev_window->priv->document = g_object_ref (document);
 691                 ev_window_setup_document (ev_window);
 692
 693                 ev_window_add_recent (ev_window, uri);
 694
 695                 return TRUE;
 696         }
 697
 698         /* unable to load the document */
 699         g_assert (error != NULL);
 700
 701         if (error->domain == EV_DOCUMENT_ERROR &&
 702             error->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
 703                 char *file_name;
 704
 705                 ev_window->priv->password_document = g_object_ref (document);
 706                 ev_window->priv->password_uri = g_strdup (uri);
 707
 708                 file_name = g_path_get_basename (uri);
 709                 ev_password_view_set_file_name (EV_PASSWORD_VIEW (ev_window->priv->password_view),
 710                                                 file_name);
 711                 g_free (file_name);
 712                 ev_window_set_page_mode (ev_window, PAGE_MODE_PASSWORD);
 713
 714                 ev_window_popup_password_dialog (ev_window);
 715         } else {
 716                 unable_to_load (ev_window, error->message);
 717         }
 718         g_error_free (error);
 719
 720         return FALSE;
 721 }
 722
 723 static gboolean
 724 is_file_supported (const gchar *mime_type)
 725 {
 726         static char *supported_types [] = {
 727                 "application/pdf",
 728                 "application/postscript",
 729                 "application/x-dvi",
 730                 "image/vnd.djvu",
 731                 "application/x-gzpostscript",
 732                 "image/x-eps",
 733                 NULL
 734         };
 735         gint   i;
 736
 737         g_return_val_if_fail (mime_type != NULL, FALSE);
 738
 739         if (mime_type_supported_by_gdk_pixbuf (mime_type))
 740                 return TRUE;
 741
 742         for (i = 0; supported_types[i] != NULL; i++) {
 743                 if (g_ascii_strcasecmp (mime_type, supported_types[i]) == 0)
 744                         return TRUE;
 745         }
 746
 747         return FALSE;
 748 }
 749
 750 void
 751 ev_window_open (EvWindow *ev_window, const char *uri)
 752 {
 753         EvDocument *document = NULL;
 754         char *mime_type;
 755
 756         g_free (ev_window->priv->uri);
 757         ev_window->priv->uri = g_strdup (uri);
 758
 759         mime_type = gnome_vfs_get_mime_type (uri);
 760
 761         if (mime_type == NULL)
 762                 document = NULL;
 763         else if (!strcmp (mime_type, "application/pdf"))
 764                 document = g_object_new (PDF_TYPE_DOCUMENT, NULL);
 765         else if (!strcmp (mime_type, "application/postscript") ||
 766                  !strcmp (mime_type, "application/x-gzpostscript") ||
 767                  !strcmp (mime_type, "image/x-eps"))
 768                 document = g_object_new (PS_TYPE_DOCUMENT, NULL);
 769 #ifdef ENABLE_DJVU
 770         else if (!strcmp (mime_type, "image/vnd.djvu"))
 771                 document = g_object_new (DJVU_TYPE_DOCUMENT, NULL);
 772 #endif
 773         else if (mime_type_supported_by_gdk_pixbuf (mime_type))
 774                 document = g_object_new (PIXBUF_TYPE_DOCUMENT, NULL);
 775 #ifdef ENABLE_DVI
 776         else if (!strcmp (mime_type, "application/x-dvi"))
 777                 document = g_object_new (DVI_TYPE_DOCUMENT, NULL);
 778 #endif
 779
 780         if (document) {
 781                 start_loading_document (ev_window, document, uri);
 782                 /* See the comment on start_loading_document on ref counting.
 783                  * As the password dialog flow is confusing, we're very explicit
 784                  * on ref counting. */
 785                 g_object_unref (document);
 786         } else {
 787                 char *error_message;
 788
 789                 error_message = g_strdup_printf (_("Unhandled MIME type: '%s'"),
 790                                                  mime_type?mime_type:"<Unknown MIME Type>");
 791                 unable_to_load (ev_window, error_message);
 792                 g_free (error_message);
 793         }
 794
 795         g_free (mime_type);
 796 }
 797
 798 static void
 799 ev_window_open_uri_list (EvWindow *ev_window, GList *uri_list)
 800 {
 801         GList *list;
 802         gchar *uri, *mime_type;
 803
 804         g_return_if_fail (uri_list != NULL);
 805
 806         list = uri_list;
 807         while (list) {
 808                 uri = gnome_vfs_uri_to_string (list->data, GNOME_VFS_URI_HIDE_NONE);
 809                 mime_type = gnome_vfs_get_mime_type (uri);
 810
 811                 if (is_file_supported (mime_type)) {
 812                         if (ev_window_is_empty (EV_WINDOW (ev_window))) {
 813                                 ev_window_open (ev_window, uri);
 814
 815                                 gtk_widget_show (GTK_WIDGET (ev_window));
 816                         } else {
 817                                 EvWindow *new_window;
 818
 819                                 new_window = ev_application_new_window (EV_APP);
 820                                 ev_window_open (new_window, uri);
 821
 822                                 gtk_widget_show (GTK_WIDGET (new_window));
 823                         }
 824                 }
 825
 826                 g_free (mime_type);
 827                 g_free (uri);
 828
 829                 list = g_list_next (list);
 830         }
 831 }
 832
 833 static void
 834 ev_window_cmd_file_open (GtkAction *action, EvWindow *ev_window)
 835 {
 836         ev_application_open (EV_APP, NULL);
 837 }
 838
 839 static void
 840 ev_window_cmd_recent_file_activate (EggRecentViewGtk *view, EggRecentItem *item,
 841                                     EvWindow *ev_window)
 842 {
 843         char *uri;
 844         GtkWidget *window;
 845
 846         uri = egg_recent_item_get_uri (item);
 847
 848         window = GTK_WIDGET (ev_application_get_empty_window (EV_APP));
 849         gtk_widget_show (window);
 850         ev_window_open (EV_WINDOW (window), uri);
 851
 852         g_free (uri);
 853 }
 854
 855 static void
 856 ev_window_add_recent (EvWindow *window, const char *filename)
 857 {
 858         EggRecentItem *item;
 859
 860         if (strstr (filename, "file:///") == NULL)
 861                 return;
 862
 863         item = egg_recent_item_new_from_uri (filename);
 864         egg_recent_item_add_group (item, "Evince");
 865         egg_recent_model_add_full (window->priv->recent_model, item);
 866 }
 867
 868 static void
 869 ev_window_setup_recent (EvWindow *ev_window)
 870 {
 871         GtkWidget *menu_item;
 872         GtkWidget *menu;
 873
 874         menu_item = gtk_ui_manager_get_widget (ev_window->priv->ui_manager, "/MainMenu/FileMenu");
 875         menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu_item));
 876         menu_item = gtk_ui_manager_get_widget (ev_window->priv->ui_manager, "/MainMenu/FileMenu/RecentFilesMenu");
 877
 878         g_return_if_fail (menu != NULL);
 879         g_return_if_fail (menu_item != NULL);
 880
 881         /* it would be better if we just filtered by mime-type, but there
 882          * doesn't seem to be an easy way to figure out which mime-types we
 883          * can handle */
 884         ev_window->priv->recent_model = egg_recent_model_new (EGG_RECENT_MODEL_SORT_MRU);
 885
 886         ev_window->priv->recent_view = egg_recent_view_gtk_new (menu, menu_item);
 887         egg_recent_view_gtk_show_icons (EGG_RECENT_VIEW_GTK (ev_window->priv->recent_view), FALSE);
 888         egg_recent_model_set_limit (ev_window->priv->recent_model, 5);
 889
 890         egg_recent_view_set_model (EGG_RECENT_VIEW (ev_window->priv->recent_view),
 891                                    ev_window->priv->recent_model);
 892
 893         egg_recent_model_set_filter_groups (ev_window->priv->recent_model,
 894                                             "Evince", NULL);
 895
 896         egg_recent_view_gtk_set_trailing_sep (ev_window->priv->recent_view, TRUE);
 897
 898         g_signal_connect (ev_window->priv->recent_view, "activate",
 899                         G_CALLBACK (ev_window_cmd_recent_file_activate), ev_window);
 900 }
 901
 902 /* FIXME
 903 static gboolean
 904 overwrite_existing_file (GtkWindow *window, const gchar *file_name)
 905 {
 906         GtkWidget *msgbox;
 907         gchar *utf8_file_name;
 908         AtkObject *obj;
 909         gint ret;
 910
 911         utf8_file_name = g_filename_to_utf8 (file_name, -1, NULL, NULL, NULL);
 912         msgbox = gtk_message_dialog_new (
 913                 window,
 914                 (GtkDialogFlags)GTK_DIALOG_DESTROY_WITH_PARENT,
 915                 GTK_MESSAGE_QUESTION,
 916                 GTK_BUTTONS_NONE,
 917                 _("A file named \"%s\" already exists."),
 918                 utf8_file_name);
 919         g_free (utf8_file_name);
 920
 921         gtk_message_dialog_format_secondary_text (
 922                 GTK_MESSAGE_DIALOG (msgbox),
 923                 _("Do you want to replace it with the one you are saving?"));
 924
 925         gtk_dialog_add_button (GTK_DIALOG (msgbox),
 926                                GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
 927
 928         gtk_dialog_add_button (GTK_DIALOG (msgbox),
 929                                _("_Replace"), GTK_RESPONSE_YES);
 930
 931         gtk_dialog_set_default_response (GTK_DIALOG (msgbox),
 932                                          GTK_RESPONSE_CANCEL);
 933
 934         obj = gtk_widget_get_accessible (msgbox);
 935
 936         if (GTK_IS_ACCESSIBLE (obj))
 937                 atk_object_set_name (obj, _("Question"));
 938
 939         ret = gtk_dialog_run (GTK_DIALOG (msgbox));
 940         gtk_widget_destroy (msgbox);
 941
 942         return (ret == GTK_RESPONSE_YES);
 943 }
 944 */
 945
 946 static void
 947 save_error_dialog (GtkWindow *window, const gchar *file_name)
 948 {
 949         GtkWidget *error_dialog;
 950
 951         error_dialog = gtk_message_dialog_new (
 952                 window,
 953                 (GtkDialogFlags)GTK_DIALOG_DESTROY_WITH_PARENT,
 954                 GTK_MESSAGE_ERROR,
 955                 GTK_BUTTONS_CLOSE,
 956                 _("The file could not be saved as \"%s\"."),
 957                 file_name);
 958
 959         /* Easy way to make the text bold while keeping the string
 960          * above free from pango markup (FIXME ?) */
 961         gtk_message_dialog_format_secondary_text (
 962                 GTK_MESSAGE_DIALOG (error_dialog), " ");
 963
 964         gtk_dialog_run (GTK_DIALOG (error_dialog));
 965         gtk_widget_destroy (error_dialog);
 966 }
 967
 968 static void
 969 ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
 970 {
 971         GtkWidget *fc;
 972         GtkFileFilter *pdf_filter, *all_filter;
 973         gchar *uri = NULL;
 974         gboolean success;
 975
 976         fc = gtk_file_chooser_dialog_new (
 977                 _("Save a Copy"),
 978                 NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
 979                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 980                 GTK_STOCK_SAVE, GTK_RESPONSE_OK,
 981                 NULL);
 982         gtk_window_set_modal (GTK_WINDOW (fc), TRUE);
 983
 984         pdf_filter = gtk_file_filter_new ();
 985         gtk_file_filter_set_name (pdf_filter, _("PDF Documents"));
 986         gtk_file_filter_add_mime_type (pdf_filter, "application/pdf");
 987         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fc), pdf_filter);
 988
 989         all_filter = gtk_file_filter_new ();
 990         gtk_file_filter_set_name (all_filter, _("All Files"));
 991         gtk_file_filter_add_pattern (all_filter, "*");
 992         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fc), all_filter);
 993         gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (fc), pdf_filter);
 994
 995         gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
 996
 997         gtk_widget_show (fc);
 998
 999         while (gtk_dialog_run (GTK_DIALOG (fc)) == GTK_RESPONSE_OK) {
1000                 uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
1001
1002 /* FIXME
1003                 if (g_file_test (uri, G_FILE_TEST_EXISTS) &&
1004                     !overwrite_existing_file (GTK_WINDOW (fc), uri))
1005                                 continue;
1006 */
1007
1008                 g_mutex_lock (EV_DOC_MUTEX);
1009                 success = ev_document_save (ev_window->priv->document, uri, NULL);
1010                 g_mutex_unlock (EV_DOC_MUTEX);
1011
1012                 if (success)
1013                         break;
1014                 else
1015                         save_error_dialog (GTK_WINDOW (fc), uri);
1016         }
1017         gtk_widget_destroy (fc);
1018 }
1019
1020 static gboolean
1021 using_postscript_printer (GnomePrintConfig *config)
1022 {
1023         const guchar *driver;
1024         const guchar *transport;
1025
1026         driver = gnome_print_config_get (
1027                 config, (const guchar *)"Settings.Engine.Backend.Driver");
1028
1029         transport = gnome_print_config_get (
1030                 config, (const guchar *)"Settings.Transport.Backend");
1031
1032         if (driver) {
1033                 if (!strcmp ((const gchar *)driver, "gnome-print-ps"))
1034                         return TRUE;
1035                 else
1036                         return FALSE;
1037         } else  if (transport) {
1038                 if (!strcmp ((const gchar *)transport, "CUPS"))
1039                         return TRUE;
1040         }
1041
1042         return FALSE;
1043 }
1044
1045 static void
1046 ev_window_print (EvWindow *ev_window)
1047 {
1048         GnomePrintConfig *config;
1049         GnomePrintJob *job;
1050         GtkWidget *print_dialog;
1051         EvPrintJob *print_job = NULL;
1052
1053         g_return_if_fail (EV_IS_WINDOW (ev_window));
1054         g_return_if_fail (ev_window->priv->document != NULL);
1055
1056         config = gnome_print_config_default ();
1057         job = gnome_print_job_new (config);
1058
1059         print_dialog = gnome_print_dialog_new (job, (guchar *) _("Print"),
1060                                                (GNOME_PRINT_DIALOG_RANGE |
1061                                                 GNOME_PRINT_DIALOG_COPIES));
1062         gtk_dialog_set_response_sensitive (GTK_DIALOG (print_dialog),
1063                                            GNOME_PRINT_DIALOG_RESPONSE_PREVIEW,
1064                                            FALSE);
1065
1066         while (TRUE) {
1067                 int response;
1068                 response = gtk_dialog_run (GTK_DIALOG (print_dialog));
1069
1070                 if (response != GNOME_PRINT_DIALOG_RESPONSE_PRINT)
1071                         break;
1072
1073                 /* FIXME: Change this when we have the first backend
1074                  * that can print more than postscript
1075                  */
1076                 if (!using_postscript_printer (config)) {
1077                         GtkWidget *dialog;
1078
1079                         dialog = gtk_message_dialog_new (
1080                                 GTK_WINDOW (print_dialog), GTK_DIALOG_MODAL,
1081                                 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1082                                 _("Printing is not supported on this printer."));
1083                         gtk_message_dialog_format_secondary_text (
1084                                 GTK_MESSAGE_DIALOG (dialog),
1085                                 _("You were trying to print to a printer using the \"%s\" driver. This program requires a PostScript printer driver."),
1086                                 gnome_print_config_get (
1087                                         config, (guchar *)"Settings.Engine.Backend.Driver"));
1088                         gtk_dialog_run (GTK_DIALOG (dialog));
1089                         gtk_widget_destroy (dialog);
1090
1091                         continue;
1092                 }
1093
1094                 print_job = g_object_new (EV_TYPE_PRINT_JOB,
1095                                           "gnome_print_job", job,
1096                                           "document", ev_window->priv->document,
1097                                           "print_dialog", print_dialog,
1098                                           NULL);
1099                 break;
1100         }
1101
1102         gtk_widget_destroy (print_dialog);
1103
1104         if (print_job != NULL) {
1105                 ev_print_job_print (print_job, GTK_WINDOW (ev_window));
1106                 g_object_unref (print_job);
1107         }
1108 }
1109
1110 static void
1111 ev_window_cmd_file_print (GtkAction *action, EvWindow *ev_window)
1112 {
1113         ev_window_print (ev_window);
1114 }
1115
1116 static void
1117 ev_window_cmd_file_close_window (GtkAction *action, EvWindow *ev_window)
1118 {
1119         g_return_if_fail (EV_IS_WINDOW (ev_window));
1120
1121         gtk_widget_destroy (GTK_WIDGET (ev_window));
1122 }
1123
1124 static void
1125 find_not_supported_dialog (EvWindow   *ev_window)
1126 {
1127         GtkWidget *dialog;
1128
1129         /* If you change this so it isn't modal, be sure you don't
1130          * allow multiple copies of the dialog...
1131          */
1132
1133         dialog = gtk_message_dialog_new (GTK_WINDOW (ev_window),
1134                                          GTK_DIALOG_DESTROY_WITH_PARENT,
1135                                          GTK_MESSAGE_ERROR,
1136                                          GTK_BUTTONS_CLOSE,
1137                                          _("The \"Find\" feature will not work with this document"));
1138         gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
1139                                                   _("Searching for text is only supported for PDF documents."));
1140         gtk_dialog_run (GTK_DIALOG (dialog));
1141         gtk_widget_destroy (dialog);
1142 }
1143
1144 static void
1145 ev_window_cmd_edit_select_all (GtkAction *action, EvWindow *ev_window)
1146 {
1147         g_return_if_fail (EV_IS_WINDOW (ev_window));
1148
1149         ev_view_select_all (EV_VIEW (ev_window->priv->view));
1150 }
1151
1152 static void
1153 ev_window_cmd_edit_find (GtkAction *action, EvWindow *ev_window)
1154 {
1155         g_return_if_fail (EV_IS_WINDOW (ev_window));
1156
1157         if (ev_window->priv->document == NULL) {
1158                 g_printerr ("We should have set the Find menu item insensitive since there's no document\n");
1159         } else if (!EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
1160                 find_not_supported_dialog (ev_window);
1161         } else {
1162                 update_chrome_flag (ev_window, EV_CHROME_FINDBAR, NULL, TRUE);
1163
1164                 gtk_widget_grab_focus (ev_window->priv->find_bar);
1165         }
1166 }
1167
1168 static void
1169 ev_window_cmd_edit_find_next (GtkAction *action, EvWindow *ev_window)
1170 {
1171         g_return_if_fail (EV_IS_WINDOW (ev_window));
1172
1173         ev_view_find_next (EV_VIEW (ev_window->priv->view));
1174 }
1175
1176 static void
1177 ev_window_cmd_edit_copy (GtkAction *action, EvWindow *ev_window)
1178 {
1179         g_return_if_fail (EV_IS_WINDOW (ev_window));
1180
1181         ev_view_copy (EV_VIEW (ev_window->priv->view));
1182 }
1183
1184 static void
1185 ev_window_update_fullscreen_popup (EvWindow *window)
1186 {
1187         GtkWidget *popup = window->priv->fullscreen_popup;
1188         int popup_width, popup_height;
1189         GdkRectangle screen_rect;
1190         gboolean toolbar;
1191
1192         g_return_if_fail (popup != NULL);
1193
1194         toolbar = (window->priv->chrome & EV_CHROME_TOOLBAR) != 0;
1195         popup_width = popup->requisition.width;
1196         popup_height = popup->requisition.height;
1197
1198         /* FIXME multihead */
1199         gdk_screen_get_monitor_geometry (gdk_screen_get_default (),
1200                         gdk_screen_get_monitor_at_window
1201                         (gdk_screen_get_default (),
1202                          GTK_WIDGET (window)->window),
1203                          &screen_rect);
1204         if (toolbar) {
1205                 gtk_widget_set_size_request (popup,
1206                                              screen_rect.width,
1207                                              -1);
1208                 gtk_window_move (GTK_WINDOW (popup),
1209                                  screen_rect.x,
1210                                  screen_rect.y);
1211
1212         } else {
1213                 if (gtk_widget_get_direction (popup) == GTK_TEXT_DIR_RTL)
1214                 {
1215                         gtk_window_move (GTK_WINDOW (popup),
1216                                          screen_rect.x,
1217                                          screen_rect.y);
1218                 } else {
1219                         gtk_window_move (GTK_WINDOW (popup),
1220                                          screen_rect.x + screen_rect.width - popup_width,
1221                                          screen_rect.y);
1222                 }
1223         }
1224 }
1225
1226 static void
1227 screen_size_changed_cb (GdkScreen *screen,
1228                         EvWindow *window)
1229 {
1230         ev_window_update_fullscreen_popup (window);
1231 }
1232
1233 static void
1234 ev_window_sidebar_position_change_cb (GObject *object, GParamSpec *pspec,
1235                                       EvWindow *ev_window)
1236 {
1237         GConfClient *client;
1238         int sidebar_size;
1239
1240         sidebar_size = gtk_paned_get_position (GTK_PANED (object));
1241
1242         client = gconf_client_get_default ();
1243         gconf_client_set_int (client, GCONF_SIDEBAR_SIZE, sidebar_size, NULL);
1244         g_object_unref (client);
1245 }
1246
1247 static void
1248 destroy_fullscreen_popup (EvWindow *window)
1249 {
1250         if (window->priv->fullscreen_popup != NULL)
1251         {
1252                 /* FIXME multihead */
1253                 g_signal_handlers_disconnect_by_func
1254                         (gdk_screen_get_default (),
1255                          G_CALLBACK (screen_size_changed_cb), window);
1256
1257                 gtk_widget_destroy (window->priv->fullscreen_popup);
1258                 window->priv->fullscreen_popup = NULL;
1259         }
1260 }
1261
1262 static void
1263 exit_fullscreen_button_clicked_cb (GtkWidget *button, EvWindow *window)
1264 {
1265         GtkAction *action;
1266
1267         action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen");
1268         g_return_if_fail (action != NULL);
1269
1270         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), FALSE);
1271 }
1272
1273 static void
1274 fullscreen_popup_size_request_cb (GtkWidget *popup, GtkRequisition *req, EvWindow *window)
1275 {
1276         ev_window_update_fullscreen_popup (window);
1277 }
1278
1279 static gboolean
1280 fullscreen_timeout_cb (gpointer data)
1281 {
1282         EvWindow *window = EV_WINDOW (data);
1283
1284         g_object_set (window->priv->fullscreen_popup, "visible", FALSE, NULL);
1285         ev_view_hide_cursor (EV_VIEW (window->priv->view));
1286         window->priv->fullscreen_timeout_source = NULL;
1287
1288         return FALSE;
1289 }
1290
1291 static void
1292 fullscreen_set_timeout (EvWindow *window)
1293 {
1294         GSource *source;
1295
1296         if (window->priv->fullscreen_timeout_source != NULL)
1297                 g_source_destroy (window->priv->fullscreen_timeout_source);
1298
1299         source = g_timeout_source_new (1000);
1300         g_source_set_callback (source, fullscreen_timeout_cb, window, NULL);
1301         g_source_attach (source, NULL);
1302         window->priv->fullscreen_timeout_source = source;
1303 }
1304
1305 static void
1306 fullscreen_clear_timeout (EvWindow *window)
1307 {
1308         if (window->priv->fullscreen_timeout_source != NULL)
1309                 g_source_destroy (window->priv->fullscreen_timeout_source);
1310
1311         window->priv->fullscreen_timeout_source = NULL;
1312         ev_view_show_cursor (EV_VIEW (window->priv->view));
1313 }
1314
1315 static gboolean
1316 fullscreen_motion_notify_cb (GtkWidget *widget,
1317                              GdkEventMotion *event,
1318                              gpointer user_data)
1319 {
1320         EvWindow *window = EV_WINDOW (user_data);
1321
1322         if (!GTK_WIDGET_VISIBLE (window->priv->fullscreen_popup)) {
1323                 g_object_set (window->priv->fullscreen_popup, "visible", TRUE, NULL);
1324                 ev_view_show_cursor (EV_VIEW (window->priv->view));
1325         }
1326
1327         fullscreen_set_timeout (window);
1328
1329         return FALSE;
1330 }
1331
1332 static gboolean
1333 fullscreen_leave_notify_cb (GtkWidget *widget,
1334                             GdkEventCrossing *event,
1335                             gpointer user_data)
1336 {
1337         EvWindow *window = EV_WINDOW (user_data);
1338
1339         fullscreen_clear_timeout (window);
1340
1341         return FALSE;
1342 }
1343
1344 static GtkWidget *
1345 ev_window_get_exit_fullscreen_button (EvWindow *window)
1346 {
1347         GtkWidget *button, *icon, *label, *hbox;
1348
1349         button = gtk_button_new ();
1350         g_signal_connect (button, "clicked",
1351                           G_CALLBACK (exit_fullscreen_button_clicked_cb),
1352                           window);
1353         gtk_widget_show (button);
1354
1355         hbox = gtk_hbox_new (FALSE, 2);
1356         gtk_widget_show (hbox);
1357         gtk_container_add (GTK_CONTAINER (button), hbox);
1358
1359         icon = gtk_image_new_from_stock (EV_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON);
1360         gtk_widget_show (icon);
1361         gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
1362
1363         label = gtk_label_new (_("Leave Fullscreen"));
1364         gtk_widget_show (label);
1365         gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1366
1367         return button;
1368 }
1369
1370 static GtkWidget *
1371 ev_window_create_fullscreen_popup (EvWindow *window)
1372 {
1373         GtkWidget *popup;
1374         GtkWidget *hbox;
1375         GtkWidget *button;
1376
1377         popup = gtk_window_new (GTK_WINDOW_POPUP);
1378         hbox = gtk_hbox_new (FALSE, 0);
1379         button = ev_window_get_exit_fullscreen_button (window);
1380
1381         gtk_container_add (GTK_CONTAINER (popup), hbox);
1382         gtk_box_pack_start (GTK_BOX (hbox), window->priv->fullscreen_toolbar,
1383                             TRUE, TRUE, 0);
1384         gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
1385
1386         gtk_widget_show (button);
1387         gtk_widget_show (hbox);
1388
1389         gtk_window_set_resizable (GTK_WINDOW (popup), FALSE);
1390
1391         /* FIXME multihead */
1392         g_signal_connect (gdk_screen_get_default (), "size-changed",
1393                           G_CALLBACK (screen_size_changed_cb), window);
1394         g_signal_connect (popup, "size_request",
1395                           G_CALLBACK (fullscreen_popup_size_request_cb), window);
1396
1397         return popup;
1398 }
1399
1400 static void
1401 ev_window_fullscreen (EvWindow *window)
1402 {
1403         window->priv->fullscreen_mode = TRUE;
1404
1405         if (window->priv->fullscreen_popup == NULL)
1406                 window->priv->fullscreen_popup
1407                         = ev_window_create_fullscreen_popup (window);
1408         update_chrome_visibility (window);
1409
1410         g_object_set (G_OBJECT (window->priv->scrolled_window),
1411                       "shadow-type", GTK_SHADOW_NONE,
1412                       NULL);
1413
1414         g_signal_connect (window->priv->view,
1415                           "motion-notify-event",
1416                           G_CALLBACK (fullscreen_motion_notify_cb),
1417                           window);
1418         g_signal_connect (window->priv->view,
1419                           "leave-notify-event",
1420                           G_CALLBACK (fullscreen_leave_notify_cb),
1421                           window);
1422         fullscreen_set_timeout (window);
1423
1424         gtk_widget_grab_focus (window->priv->view);
1425
1426         ev_window_update_fullscreen_popup (window);
1427 }
1428
1429 static void
1430 ev_window_unfullscreen (EvWindow *window)
1431 {
1432         window->priv->fullscreen_mode = FALSE;
1433
1434         g_object_set (G_OBJECT (window->priv->scrolled_window),
1435                       "shadow-type", GTK_SHADOW_IN,
1436                       NULL);
1437
1438         fullscreen_clear_timeout (window);
1439
1440         g_signal_handlers_disconnect_by_func (window->priv->view,
1441                                               (gpointer) fullscreen_motion_notify_cb,
1442                                               window);
1443
1444 //      destroy_fullscreen_popup (window);
1445
1446         update_chrome_visibility (window);
1447 }
1448
1449 static void
1450 ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *ev_window)
1451 {
1452         gboolean fullscreen;
1453
1454         g_return_if_fail (EV_IS_WINDOW (ev_window));
1455
1456         fullscreen = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
1457
1458         if (fullscreen) {
1459                 gtk_window_fullscreen (GTK_WINDOW (ev_window));
1460         } else {
1461                 gtk_window_unfullscreen (GTK_WINDOW (ev_window));
1462         }
1463 }
1464
1465 static gboolean
1466 ev_window_state_event_cb (GtkWidget *widget, GdkEventWindowState *event, EvWindow *window)
1467 {
1468         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
1469         {
1470                 GtkActionGroup *action_group;
1471                 GtkAction *action;
1472                 gboolean fullscreen;
1473
1474                 fullscreen = event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN;
1475
1476                 if (fullscreen)
1477                 {
1478                         ev_window_fullscreen (window);
1479                 }
1480                 else
1481                 {
1482                         ev_window_unfullscreen (window);
1483                 }
1484
1485                 action_group = window->priv->action_group;
1486
1487                 action = gtk_action_group_get_action (action_group, "ViewFullscreen");
1488                 g_signal_handlers_block_by_func
1489                         (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
1490                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), fullscreen);
1491                 g_signal_handlers_unblock_by_func
1492                         (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window);
1493
1494         }
1495
1496         return FALSE;
1497 }
1498
1499 static gboolean
1500 ev_window_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
1501 {
1502         EvWindow *window = EV_WINDOW (widget);
1503         EvWindowPrivate *priv = window->priv;
1504
1505         if (priv->fullscreen_mode)
1506         {
1507                 gtk_widget_show (priv->fullscreen_popup);
1508         }
1509
1510         return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_in_event (widget, event);
1511 }
1512
1513 static gboolean
1514 ev_window_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
1515 {
1516         EvWindow *window = EV_WINDOW (widget);
1517         EvWindowPrivate *priv = window->priv;
1518
1519         if (priv->fullscreen_mode)
1520         {
1521                 gtk_widget_hide (priv->fullscreen_popup);
1522         }
1523
1524         return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_out_event (widget, event);
1525 }
1526
1527 static void
1528 ev_window_set_page_mode (EvWindow         *window,
1529                          EvWindowPageMode  page_mode)
1530 {
1531         GtkWidget *child = NULL;
1532         GtkWidget *real_child;
1533
1534         if (window->priv->page_mode == page_mode)
1535                 return;
1536
1537         window->priv->page_mode = page_mode;
1538
1539         switch (page_mode) {
1540         case PAGE_MODE_SINGLE_PAGE:
1541                 child = window->priv->view;
1542                 break;
1543         case PAGE_MODE_PASSWORD:
1544                 child = window->priv->password_view;
1545                 break;
1546         case PAGE_MODE_CONTINUOUS_PAGE:
1547                 child = window->priv->page_view;
1548                 break;
1549         default:
1550                 g_assert_not_reached ();
1551         }
1552
1553         real_child = gtk_bin_get_child (GTK_BIN (window->priv->scrolled_window));
1554         if (child != real_child) {
1555                 gtk_container_remove (GTK_CONTAINER (window->priv->scrolled_window),
1556                                       real_child);
1557                 gtk_container_add (GTK_CONTAINER (window->priv->scrolled_window),
1558                                    child);
1559         }
1560         update_action_sensitivity (window);
1561 }
1562
1563 static void
1564 ev_window_cmd_view_zoom_in (GtkAction *action, EvWindow *ev_window)
1565 {
1566         g_return_if_fail (EV_IS_WINDOW (ev_window));
1567
1568         ev_window_set_sizing_mode (ev_window, EV_SIZING_FREE);
1569
1570         ev_view_zoom_in (EV_VIEW (ev_window->priv->view));
1571 }
1572
1573 static void
1574 ev_window_cmd_view_zoom_out (GtkAction *action, EvWindow *ev_window)
1575 {
1576         g_return_if_fail (EV_IS_WINDOW (ev_window));
1577
1578         ev_window_set_sizing_mode (ev_window, EV_SIZING_FREE);
1579
1580         ev_view_zoom_out (EV_VIEW (ev_window->priv->view));
1581 }
1582
1583 static void
1584 ev_window_cmd_view_normal_size (GtkAction *action, EvWindow *ev_window)
1585 {
1586         g_return_if_fail (EV_IS_WINDOW (ev_window));
1587
1588         ev_view_set_size (EV_VIEW (ev_window->priv->view), -1, -1);
1589 }
1590
1591 static void
1592 ev_window_cmd_go_previous_page (GtkAction *action, EvWindow *ev_window)
1593 {
1594         g_return_if_fail (EV_IS_WINDOW (ev_window));
1595
1596         ev_page_cache_prev_page (ev_window->priv->page_cache);
1597 }
1598
1599 static void
1600 ev_window_cmd_go_next_page (GtkAction *action, EvWindow *ev_window)
1601 {
1602         g_return_if_fail (EV_IS_WINDOW (ev_window));
1603
1604         ev_page_cache_next_page (ev_window->priv->page_cache);
1605 }
1606
1607 static void
1608 ev_window_cmd_go_first_page (GtkAction *action, EvWindow *ev_window)
1609 {
1610         g_return_if_fail (EV_IS_WINDOW (ev_window));
1611
1612         ev_page_cache_set_current_page (ev_window->priv->page_cache, 0);
1613 }
1614
1615 static void
1616 ev_window_cmd_go_last_page (GtkAction *action, EvWindow *ev_window)
1617 {
1618         int n_pages;
1619
1620         g_return_if_fail (EV_IS_WINDOW (ev_window));
1621
1622         n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
1623         ev_page_cache_set_current_page (ev_window->priv->page_cache, n_pages - 1);
1624 }
1625
1626 static void
1627 ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window)
1628 {
1629         char *uri;
1630         int page;
1631
1632         g_return_if_fail (EV_IS_WINDOW (ev_window));
1633
1634         page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
1635         uri = g_strdup (ev_window->priv->uri);
1636
1637         ev_window_open (ev_window, uri);
1638         ev_window_open_page (ev_window, page);
1639
1640         g_free (uri);
1641 }
1642
1643 static void
1644 ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
1645 {
1646         GError *error = NULL;
1647
1648         g_return_if_fail (EV_IS_WINDOW (ev_window));
1649
1650         gnome_help_display ("evince.xml", NULL, &error);
1651
1652         if(error != NULL) {
1653                 g_warning (error->message);
1654                 g_error_free (error);
1655         }
1656 }
1657
1658 static void
1659 ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window)
1660 {
1661         gtk_window_unfullscreen (GTK_WINDOW (window));
1662 }
1663
1664 static void
1665 ev_window_cmd_escape (GtkAction *action, EvWindow *window)
1666 {
1667         GtkWidget *widget;
1668
1669         widget = gtk_window_get_focus (GTK_WINDOW (window));
1670         if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
1671                 update_chrome_flag (window, EV_CHROME_FINDBAR, NULL, FALSE);
1672         } else {
1673                 gtk_window_unfullscreen (GTK_WINDOW (window));
1674         }
1675 }
1676
1677 static void
1678 update_view_size (EvWindow *window)
1679 {
1680         int width, height;
1681         GtkRequisition vsb_requisition;
1682         int scrollbar_spacing;
1683
1684         width = window->priv->scrolled_window->allocation.width;
1685         height = window->priv->scrolled_window->allocation.height;
1686
1687         /* the scrolled window has a GTK_SHADOW_IN */
1688         width -= 2 * window->priv->view->style->xthickness;
1689         height -= 2 * window->priv->view->style->ythickness;
1690
1691         if (window->priv->sizing_mode == EV_SIZING_BEST_FIT) {
1692                 ev_view_set_size (EV_VIEW (window->priv->view),
1693                                   MAX (1, width), MAX (1, height));
1694         } else if (window->priv->sizing_mode == EV_SIZING_FIT_WIDTH) {
1695                 gtk_widget_size_request (GTK_SCROLLED_WINDOW (window->priv->scrolled_window)->vscrollbar,
1696                                          &vsb_requisition);
1697                 gtk_widget_style_get (window->priv->scrolled_window,
1698                                       "scrollbar_spacing", &scrollbar_spacing,
1699                                       NULL);
1700                 ev_view_set_size (EV_VIEW (window->priv->view),
1701                                   width - vsb_requisition.width - scrollbar_spacing, -1);
1702         }
1703 }
1704
1705 static void
1706 size_allocate_cb (GtkWidget     *scrolled_window,
1707                   GtkAllocation *allocation,
1708                   EvWindow      *window)
1709 {
1710         update_view_size (window);
1711 }
1712
1713 static void
1714 ev_window_set_sizing_mode (EvWindow     *ev_window,
1715                            EvSizingMode  sizing_mode)
1716 {
1717         GtkWidget *scrolled_window;
1718
1719         if (ev_window->priv->sizing_mode == sizing_mode)
1720                 return;
1721
1722         scrolled_window = ev_window->priv->scrolled_window;
1723         ev_window->priv->sizing_mode = sizing_mode;
1724
1725         g_signal_handlers_disconnect_by_func (scrolled_window, size_allocate_cb, ev_window);
1726
1727         update_view_size (ev_window);
1728
1729         switch (sizing_mode) {
1730         case EV_SIZING_BEST_FIT:
1731                 g_object_set (G_OBJECT (scrolled_window),
1732                               "hscrollbar-policy", GTK_POLICY_NEVER,
1733                               "vscrollbar-policy", GTK_POLICY_NEVER,
1734                               NULL);
1735                 g_signal_connect (scrolled_window, "size-allocate",
1736                                   G_CALLBACK (size_allocate_cb),
1737                                   ev_window);
1738                 break;
1739         case EV_SIZING_FIT_WIDTH:
1740                 g_object_set (G_OBJECT (scrolled_window),
1741                               "hscrollbar-policy", GTK_POLICY_NEVER,
1742                               "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
1743                               NULL);
1744                 g_signal_connect (scrolled_window, "size-allocate",
1745                                   G_CALLBACK (size_allocate_cb),
1746                                   ev_window);
1747                 break;
1748         case EV_SIZING_FREE:
1749                 g_object_set (G_OBJECT (scrolled_window),
1750                               "hscrollbar-policy", GTK_POLICY_AUTOMATIC,
1751                               "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
1752                               NULL);
1753                 break;
1754         }
1755
1756         update_sizing_buttons (ev_window);
1757 }
1758
1759 static void
1760 ev_window_cmd_help_about (GtkAction *action, EvWindow *ev_window)
1761 {
1762         const char *authors[] = {
1763                 N_("Many..."),
1764                 NULL
1765         };
1766
1767         const char *documenters[] = {
1768                 N_("Not so many..."),
1769                 NULL
1770         };
1771
1772         const char *license[] = {
1773                 N_("Evince is free software; you can redistribute it and/or modify\n"
1774                    "it under the terms of the GNU General Public License as published by\n"
1775                    "the Free Software Foundation; either version 2 of the License, or\n"
1776                    "(at your option) any later version.\n"),
1777                 N_("Evince is distributed in the hope that it will be useful,\n"
1778                    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
1779                    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
1780                    "GNU General Public License for more details.\n"),
1781                 N_("You should have received a copy of the GNU General Public License\n"
1782                    "along with Evince; if not, write to the Free Software Foundation, Inc.,\n"
1783                    "59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n")
1784         };
1785
1786         char *license_trans;
1787
1788 #ifdef ENABLE_NLS
1789         const char **p;
1790
1791         for (p = authors; *p; ++p)
1792                 *p = _(*p);
1793
1794         for (p = documenters; *p; ++p)
1795                 *p = _(*p);
1796 #endif
1797
1798         license_trans = g_strconcat (_(license[0]), "\n", _(license[1]), "\n",
1799                                      _(license[2]), "\n", NULL);
1800
1801         gtk_show_about_dialog (
1802                 GTK_WINDOW (ev_window),
1803                 "name", _("Evince"),
1804                 "version", VERSION,
1805                 "copyright",
1806                 _("\xc2\xa9 1996-2004 The Evince authors"),
1807                 "license", license_trans,
1808                 "website", "http://www.gnome.org/projects/evince",
1809                 "comments", _("PostScript and PDF File Viewer."),
1810                 "authors", authors,
1811                 "documenters", documenters,
1812                 "translator-credits", _("translator-credits"),
1813                 NULL);
1814
1815         g_free (license_trans);
1816 }
1817
1818 static void
1819 ev_window_view_toolbar_cb (GtkAction *action, EvWindow *ev_window)
1820 {
1821         update_chrome_flag (ev_window, EV_CHROME_TOOLBAR,
1822                             GCONF_CHROME_TOOLBAR,
1823                             gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
1824 }
1825
1826 static void
1827 ev_window_view_statusbar_cb (GtkAction *action, EvWindow *ev_window)
1828 {
1829         update_chrome_flag (ev_window, EV_CHROME_STATUSBAR,
1830                             GCONF_CHROME_STATUSBAR,
1831                             gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
1832 }
1833
1834 static void
1835 ev_window_view_sidebar_cb (GtkAction *action, EvWindow *ev_window)
1836 {
1837         update_chrome_flag (ev_window, EV_CHROME_SIDEBAR,
1838                             GCONF_CHROME_SIDEBAR,
1839                             gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
1840 }
1841
1842 static void
1843 ev_window_sidebar_visibility_changed_cb (EvSidebar *ev_sidebar, GParamSpec *pspec,
1844                                          EvWindow   *ev_window)
1845 {
1846         GtkAction *action;
1847         gboolean visible;
1848
1849         visible = GTK_WIDGET_VISIBLE (ev_sidebar);
1850
1851         /* In fullscreen mode the sidebar is not visible,
1852          * but we don't want to update the chrome
1853          */
1854         if (ev_window->priv->fullscreen_mode)
1855                 return;
1856
1857         action = gtk_action_group_get_action (ev_window->priv->action_group, "ViewSidebar");
1858
1859         g_signal_handlers_block_by_func
1860                 (action, G_CALLBACK (ev_window_view_sidebar_cb), ev_window);
1861         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);
1862         g_signal_handlers_unblock_by_func
1863                 (action, G_CALLBACK (ev_window_view_sidebar_cb), ev_window);
1864
1865         update_chrome_flag (ev_window, EV_CHROME_SIDEBAR,
1866                             GCONF_CHROME_SIDEBAR, visible);
1867 }
1868
1869 static void
1870 menu_item_select_cb (GtkMenuItem *proxy, EvWindow *ev_window)
1871 {
1872         GtkAction *action;
1873         char *message;
1874
1875         action = g_object_get_data (G_OBJECT (proxy), "gtk-action");
1876         g_return_if_fail (action != NULL);
1877
1878         g_object_get (G_OBJECT (action), "tooltip", &message, NULL);
1879         if (message) {
1880                 gtk_statusbar_push (GTK_STATUSBAR (ev_window->priv->statusbar),
1881                                     ev_window->priv->help_message_cid, message);
1882                 g_free (message);
1883         }
1884 }
1885
1886 static void
1887 menu_item_deselect_cb (GtkMenuItem *proxy, EvWindow *ev_window)
1888 {
1889         gtk_statusbar_pop (GTK_STATUSBAR (ev_window->priv->statusbar),
1890                            ev_window->priv->help_message_cid);
1891 }
1892
1893 static void
1894 connect_proxy_cb (GtkUIManager *ui_manager, GtkAction *action,
1895                   GtkWidget *proxy, EvWindow *ev_window)
1896 {
1897         if (GTK_IS_MENU_ITEM (proxy)) {
1898                 g_signal_connect (proxy, "select",
1899                                   G_CALLBACK (menu_item_select_cb), ev_window);
1900                 g_signal_connect (proxy, "deselect",
1901                                   G_CALLBACK (menu_item_deselect_cb),
1902                                   ev_window);
1903         }
1904 }
1905
1906 static void
1907 disconnect_proxy_cb (GtkUIManager *ui_manager, GtkAction *action,
1908                      GtkWidget *proxy, EvWindow *ev_window)
1909 {
1910         if (GTK_IS_MENU_ITEM (proxy)) {
1911                 g_signal_handlers_disconnect_by_func
1912                         (proxy, G_CALLBACK (menu_item_select_cb), ev_window);
1913                 g_signal_handlers_disconnect_by_func
1914                         (proxy, G_CALLBACK (menu_item_deselect_cb), ev_window);
1915         }
1916 }
1917
1918 static void
1919 view_status_changed_cb (EvView     *view,
1920                         GParamSpec *pspec,
1921                         EvWindow   *ev_window)
1922 {
1923         const char *message;
1924
1925         gtk_statusbar_pop (GTK_STATUSBAR (ev_window->priv->statusbar),
1926                            ev_window->priv->view_message_cid);
1927
1928         message = ev_view_get_status (view);
1929         if (message) {
1930                 gtk_statusbar_push (GTK_STATUSBAR (ev_window->priv->statusbar),
1931                                     ev_window->priv->view_message_cid, message);
1932         }
1933 }
1934
1935 static void
1936 view_find_status_changed_cb (EvView     *view,
1937                              GParamSpec *pspec,
1938                              EvWindow   *ev_window)
1939 {
1940         const char *text;
1941
1942         text = ev_view_get_find_status (view);
1943         egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar),
1944                                       text);
1945 }
1946
1947 static void
1948 find_bar_previous_cb (EggFindBar *find_bar,
1949                       EvWindow   *ev_window)
1950 {
1951         ev_view_find_previous (EV_VIEW (ev_window->priv->view));
1952 }
1953
1954 static void
1955 find_bar_next_cb (EggFindBar *find_bar,
1956                   EvWindow   *ev_window)
1957 {
1958         ev_view_find_next (EV_VIEW (ev_window->priv->view));
1959 }
1960
1961 static void
1962 find_bar_close_cb (EggFindBar *find_bar,
1963                    EvWindow   *ev_window)
1964 {
1965         update_chrome_flag (ev_window, EV_CHROME_FINDBAR, NULL, FALSE);
1966 }
1967
1968 static void
1969 ev_window_page_mode_cb (GtkRadioAction *action,
1970                         GtkRadioAction *activated_action,
1971                         EvWindow       *window)
1972 {
1973         int mode;
1974
1975         mode = gtk_radio_action_get_current_value (action);
1976
1977         g_assert (mode == PAGE_MODE_CONTINUOUS_PAGE ||
1978                   mode == PAGE_MODE_SINGLE_PAGE);
1979
1980         ev_window_set_page_mode (window, (EvWindowPageMode) mode);
1981 }
1982
1983 static void
1984 find_bar_search_changed_cb (EggFindBar *find_bar,
1985                             GParamSpec *param,
1986                             EvWindow   *ev_window)
1987 {
1988         gboolean case_sensitive;
1989         gboolean visible;
1990         const char *search_string;
1991
1992         g_return_if_fail (EV_IS_WINDOW (ev_window));
1993
1994         /* Either the string or case sensitivity could have changed,
1995          * we connect this callback to both. We also connect it
1996          * to ::visible so when the find bar is hidden, we should
1997          * pretend the search string is NULL/""
1998          */
1999
2000         case_sensitive = egg_find_bar_get_case_sensitive (find_bar);
2001         visible = GTK_WIDGET_VISIBLE (find_bar);
2002         search_string = egg_find_bar_get_search_string (find_bar);
2003
2004 #if 0
2005         g_printerr ("search for '%s'\n", search_string ? search_string : "(nil)");
2006 #endif
2007
2008         if (ev_window->priv->document &&
2009             EV_IS_DOCUMENT_FIND (ev_window->priv->document)) {
2010                 if (visible && search_string && search_string[0]) {
2011                         g_mutex_lock (EV_DOC_MUTEX);
2012                         ev_document_find_begin (EV_DOCUMENT_FIND (ev_window->priv->document),
2013                                                 ev_view_get_page (EV_VIEW (ev_window->priv->view)),
2014                                                 search_string,
2015                                                 case_sensitive);
2016                         g_mutex_unlock (EV_DOC_MUTEX);
2017                 } else {
2018                         g_mutex_lock (EV_DOC_MUTEX);
2019                         ev_document_find_cancel (EV_DOCUMENT_FIND (ev_window->priv->document));
2020                         g_mutex_unlock (EV_DOC_MUTEX);
2021
2022                         egg_find_bar_set_status_text (EGG_FIND_BAR (ev_window->priv->find_bar),
2023                                                       NULL);
2024                         gtk_widget_queue_draw (GTK_WIDGET (ev_window->priv->view));
2025                 }
2026         }
2027 }
2028
2029 static void
2030 ev_window_dispose (GObject *object)
2031 {
2032         EvWindow *window = EV_WINDOW (object);
2033         EvWindowPrivate *priv = window->priv;
2034
2035         if (priv->ui_manager) {
2036                 g_object_unref (priv->ui_manager);
2037                 priv->ui_manager = NULL;
2038         }
2039
2040         if (priv->action_group) {
2041                 g_object_unref (priv->action_group);
2042                 priv->action_group = NULL;
2043         }
2044
2045         if (priv->document) {
2046                 g_object_unref (priv->document);
2047                 priv->document = NULL;
2048         }
2049
2050         if (priv->view) {
2051                 g_object_unref (priv->view);
2052                 priv->view = NULL;
2053         }
2054
2055         if (priv->page_view) {
2056                 g_object_unref (priv->page_view);
2057                 priv->page_view = NULL;
2058         }
2059
2060         if (priv->password_document) {
2061                 g_object_unref (priv->password_document);
2062                 priv->password_document = NULL;
2063         }
2064
2065         if (priv->password_uri) {
2066                 g_free (priv->password_uri);
2067                 priv->password_uri = NULL;
2068         }
2069
2070         if (priv->find_bar) {
2071                 g_signal_handlers_disconnect_by_func
2072                         (window->priv->find_bar,
2073                          G_CALLBACK (find_bar_close_cb),
2074                          window);
2075                 priv->find_bar = NULL;
2076         }
2077
2078         destroy_fullscreen_popup (window);
2079
2080         G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
2081 }
2082
2083 static void
2084 ev_window_class_init (EvWindowClass *ev_window_class)
2085 {
2086         GObjectClass *g_object_class = G_OBJECT_CLASS (ev_window_class);
2087         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (ev_window_class);
2088
2089         g_object_class->dispose = ev_window_dispose;
2090
2091         widget_class->focus_in_event = ev_window_focus_in_event;
2092         widget_class->focus_out_event = ev_window_focus_out_event;
2093
2094         g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));
2095 }
2096
2097 /* Normal items */
2098 static GtkActionEntry entries[] = {
2099         { "File", NULL, N_("_File") },
2100         { "Edit", NULL, N_("_Edit") },
2101         { "View", NULL, N_("_View") },
2102         { "Go", NULL, N_("_Go") },
2103         { "Help", NULL, N_("_Help") },
2104
2105         /* File menu */
2106         { "FileOpen", GTK_STOCK_OPEN, NULL, "<control>O",
2107           N_("Open an existing document"),
2108           G_CALLBACK (ev_window_cmd_file_open) },
2109         { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), NULL,
2110           N_("Save the current document with a new filename"),
2111           G_CALLBACK (ev_window_cmd_save_as) },
2112         { "FilePrint", GTK_STOCK_PRINT, N_("Print..."), "<control>P",
2113           N_("Print this document"),
2114           G_CALLBACK (ev_window_cmd_file_print) },
2115         { "FileCloseWindow", GTK_STOCK_CLOSE, NULL, "<control>W",
2116           N_("Close this window"),
2117           G_CALLBACK (ev_window_cmd_file_close_window) },
2118
2119         /* Edit menu */
2120         { "EditCopy", GTK_STOCK_COPY, NULL, "<control>C",
2121           N_("Copy text from the document"),
2122           G_CALLBACK (ev_window_cmd_edit_copy) },
2123         { "EditSelectAll", NULL, N_("Select _All"), "<control>A",
2124           N_("Select the entire page"),
2125           G_CALLBACK (ev_window_cmd_edit_select_all) },
2126         { "EditFind", GTK_STOCK_FIND, NULL, "<control>F",
2127           N_("Find a word or phrase in the document"),
2128           G_CALLBACK (ev_window_cmd_edit_find) },
2129         { "EditFindNext", NULL, N_("Find Ne_xt"), "<control>G",
2130           N_("Find next occurrence of the word or phrase"),
2131           G_CALLBACK (ev_window_cmd_edit_find_next) },
2132
2133         /* View menu */
2134         { "ViewZoomIn", GTK_STOCK_ZOOM_IN, NULL, "<control>plus",
2135           N_("Enlarge the document"),
2136           G_CALLBACK (ev_window_cmd_view_zoom_in) },
2137         { "ViewZoomOut", GTK_STOCK_ZOOM_OUT, NULL, "<control>minus",
2138           N_("Shrink the document"),
2139           G_CALLBACK (ev_window_cmd_view_zoom_out) },
2140         { "ViewNormalSize", GTK_STOCK_ZOOM_100, NULL, "<control>0",
2141           N_("Reset the zoom level to the default value"),
2142           G_CALLBACK (ev_window_cmd_view_normal_size) },
2143         { "ViewReload", GTK_STOCK_REFRESH, N_("_Reload"), "<control>R",
2144           N_("Reload the document"),
2145           G_CALLBACK (ev_window_cmd_view_reload) },
2146
2147         /* Go menu */
2148         { "GoPreviousPage", GTK_STOCK_GO_BACK, N_("_Previous Page"), "Page_Up",
2149           N_("Go to the previous page"),
2150           G_CALLBACK (ev_window_cmd_go_previous_page) },
2151         { "GoNextPage", GTK_STOCK_GO_FORWARD, N_("_Next Page"), "Page_Down",
2152           N_("Go to the next page"),
2153           G_CALLBACK (ev_window_cmd_go_next_page) },
2154         { "GoFirstPage", GTK_STOCK_GOTO_FIRST, N_("_First Page"), "<control>Home",
2155           N_("Go to the first page"),
2156           G_CALLBACK (ev_window_cmd_go_first_page) },
2157         { "GoLastPage", GTK_STOCK_GOTO_LAST, N_("_Last Page"), "<control>End",
2158           N_("Go to the last page"),
2159           G_CALLBACK (ev_window_cmd_go_last_page) },
2160
2161         /* Help menu */
2162         { "HelpContents", GTK_STOCK_HELP, N_("_Contents"), "F1",
2163           N_("Display help for the viewer application"),
2164           G_CALLBACK (ev_window_cmd_help_contents) },
2165
2166         { "HelpAbout", GTK_STOCK_ABOUT, N_("_About"), NULL,
2167           N_("Display credits for the document viewer creators"),
2168           G_CALLBACK (ev_window_cmd_help_about) },
2169
2170         /* Toolbar-only */
2171         { "LeaveFullscreen", EV_STOCK_LEAVE_FULLSCREEN, N_("Leave Fullscreen"), NULL,
2172           N_("Leave fullscreen mode"),
2173           G_CALLBACK (ev_window_cmd_leave_fullscreen) },
2174
2175         { "Escape", NULL, N_("Selection Caret"), "Escape", "",
2176           G_CALLBACK (ev_window_cmd_escape) }
2177 };
2178
2179 /* Toggle items */
2180 static GtkToggleActionEntry toggle_entries[] = {
2181         /* View Menu */
2182         { "ViewToolbar", NULL, N_("_Toolbar"), "<shift><control>T",
2183           N_("Show or hide the toolbar"),
2184           G_CALLBACK (ev_window_view_toolbar_cb), TRUE },
2185         { "ViewStatusbar", NULL, N_("_Statusbar"), NULL,
2186           N_("Show or hide the statusbar"),
2187           G_CALLBACK (ev_window_view_statusbar_cb), TRUE },
2188         { "ViewSidebar", NULL, N_("Side _pane"), "F9",
2189           N_("Show or hide the side pane"),
2190           G_CALLBACK (ev_window_view_sidebar_cb), TRUE },
2191         { "ViewFullscreen", NULL, N_("_Fullscreen"), "F11",
2192           N_("Expand the window to fill the screen"),
2193           G_CALLBACK (ev_window_cmd_view_fullscreen) },
2194         { "ViewBestFit", EV_STOCK_ZOOM_PAGE, N_("_Best Fit"), NULL,
2195           N_("Make the current document fill the window"),
2196           G_CALLBACK (ev_window_cmd_view_best_fit) },
2197         { "ViewPageWidth", EV_STOCK_ZOOM_WIDTH, N_("Fit Page _Width"), NULL,
2198           N_("Make the current document fill the window width"),
2199           G_CALLBACK (ev_window_cmd_view_page_width) },
2200 };
2201
2202 static GtkRadioActionEntry page_view_entries[] = {
2203         { "SinglePage", GTK_STOCK_DND, N_("Single"), NULL,
2204           N_("Show the document one page at a time"),
2205           PAGE_MODE_SINGLE_PAGE },
2206         { "ContinuousPage", GTK_STOCK_DND_MULTIPLE, N_("Multi"), NULL,
2207           N_("Show the full document at once"),
2208           PAGE_MODE_CONTINUOUS_PAGE }
2209 };
2210
2211 static void
2212 drag_data_received_cb (GtkWidget *widget, GdkDragContext *context,
2213                        gint x, gint y, GtkSelectionData *selection_data,
2214                        guint info, guint time, gpointer gdata)
2215 {
2216         GList    *uri_list = NULL;
2217
2218         uri_list = gnome_vfs_uri_list_parse ((gchar *) selection_data->data);
2219
2220         if (uri_list) {
2221                 ev_window_open_uri_list (EV_WINDOW (widget), uri_list);
2222
2223                 gnome_vfs_uri_list_free (uri_list);
2224
2225                 gtk_drag_finish (context, TRUE, FALSE, time);
2226         }
2227 }
2228
2229 static void
2230 register_custom_actions (EvWindow *window, GtkActionGroup *group)
2231 {
2232         GtkAction *action;
2233
2234         action = g_object_new (EV_TYPE_PAGE_ACTION,
2235                                "name", PAGE_SELECTOR_ACTION,
2236                                "label", _("Page"),
2237                                "tooltip", _("Select Page"),
2238                                NULL);
2239         gtk_action_group_add_action (group, action);
2240         g_object_unref (action);
2241 }
2242
2243 static void
2244 set_action_properties (GtkActionGroup *action_group)
2245 {
2246         GtkAction *action;
2247
2248         action = gtk_action_group_get_action (action_group, "GoPreviousPage");
2249         /*translators: this is the label for toolbar button*/
2250         g_object_set (action, "short_label", _("Previous"), NULL);
2251         g_object_set (action, "is-important", TRUE, NULL);
2252
2253         action = gtk_action_group_get_action (action_group, "GoNextPage");
2254         g_object_set (action, "is-important", TRUE, NULL);
2255         /*translators: this is the label for toolbar button*/
2256         g_object_set (action, "short_label", _("Next"), NULL);
2257
2258         action = gtk_action_group_get_action (action_group, "ViewZoomIn");
2259         /*translators: this is the label for toolbar button*/
2260         g_object_set (action, "short_label", _("Zoom In"), NULL);
2261         action = gtk_action_group_get_action (action_group, "ViewZoomIn");
2262
2263         action = gtk_action_group_get_action (action_group, "ViewZoomOut");
2264         /*translators: this is the label for toolbar button*/
2265         g_object_set (action, "short_label", _("Zoom Out"), NULL);
2266         action = gtk_action_group_get_action (action_group, "ViewZoomIn");
2267
2268         action = gtk_action_group_get_action (action_group, "ViewBestFit");
2269         /*translators: this is the label for toolbar button*/
2270         g_object_set (action, "short_label", _("Best Fit"), NULL);
2271         action = gtk_action_group_get_action (action_group, "ViewZoomIn");
2272
2273         action = gtk_action_group_get_action (action_group, "ViewPageWidth");
2274         /*translators: this is the label for toolbar button*/
2275         g_object_set (action, "short_label", _("Fit Width"), NULL);
2276         action = gtk_action_group_get_action (action_group, "ViewZoomIn");
2277
2278         action = gtk_action_group_get_action (action_group, "LeaveFullscreen");
2279         g_object_set (action, "is-important", TRUE, NULL);
2280 }
2281
2282 static void
2283 set_chrome_actions (EvWindow *window)
2284 {
2285         EvWindowPrivate *priv = window->priv;
2286         GtkActionGroup *action_group = priv->action_group;
2287         GtkAction *action;
2288
2289         action= gtk_action_group_get_action (action_group, "ViewToolbar");
2290         g_signal_handlers_block_by_func
2291                 (action, G_CALLBACK (ev_window_view_toolbar_cb), window);
2292         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
2293                                       (priv->chrome & EV_CHROME_TOOLBAR) != 0);
2294         g_signal_handlers_unblock_by_func
2295                 (action, G_CALLBACK (ev_window_view_toolbar_cb), window);
2296
2297         action= gtk_action_group_get_action (action_group, "ViewSidebar");
2298         g_signal_handlers_block_by_func
2299                 (action, G_CALLBACK (ev_window_view_sidebar_cb), window);
2300         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
2301                                       (priv->chrome & EV_CHROME_SIDEBAR) != 0);
2302         g_signal_handlers_unblock_by_func
2303                 (action, G_CALLBACK (ev_window_view_sidebar_cb), window);
2304
2305         action= gtk_action_group_get_action (action_group, "ViewStatusbar");
2306         g_signal_handlers_block_by_func
2307                 (action, G_CALLBACK (ev_window_view_statusbar_cb), window);
2308         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
2309                                       (priv->chrome & EV_CHROME_STATUSBAR) != 0);
2310         g_signal_handlers_unblock_by_func
2311                 (action, G_CALLBACK (ev_window_view_statusbar_cb), window);
2312 }
2313
2314 static EvChrome
2315 load_chrome (void)
2316 {
2317         EvChrome chrome = EV_CHROME_NORMAL;
2318         GConfClient *client;
2319         GConfValue *value;
2320
2321         client = gconf_client_get_default ();
2322
2323         value = gconf_client_get (client, GCONF_CHROME_TOOLBAR, NULL);
2324         if (value != NULL) {
2325                 if (value->type == GCONF_VALUE_BOOL && !gconf_value_get_bool (value)) {
2326                         chrome &= ~EV_CHROME_TOOLBAR;
2327                 }
2328                 gconf_value_free (value);
2329         }
2330
2331         value = gconf_client_get (client, GCONF_CHROME_SIDEBAR, NULL);
2332         if (value != NULL) {
2333                 if (value->type == GCONF_VALUE_BOOL && !gconf_value_get_bool (value)) {
2334                         chrome &= ~EV_CHROME_SIDEBAR;
2335                 }
2336                 gconf_value_free (value);
2337         }
2338
2339         value = gconf_client_get (client, GCONF_CHROME_STATUSBAR, NULL);
2340         if (value != NULL) {
2341                 if (value->type == GCONF_VALUE_BOOL && !gconf_value_get_bool (value)) {
2342                         chrome &= ~EV_CHROME_STATUSBAR;
2343                 }
2344                 gconf_value_free (value);
2345         }
2346
2347         g_object_unref (client);
2348
2349         return chrome;
2350 }
2351
2352 static void
2353 sidebar_widget_model_set (EvSidebarLinks *ev_sidebar_links,
2354                           GParamSpec     *pspec,
2355                           EvWindow       *ev_window)
2356 {
2357         GtkTreeModel *model;
2358         GtkAction *action;
2359
2360         g_object_get (G_OBJECT (ev_sidebar_links),
2361                       "model", &model,
2362                       NULL);
2363
2364         action = gtk_action_group_get_action (ev_window->priv->action_group, PAGE_SELECTOR_ACTION);
2365         ev_page_action_set_model (EV_PAGE_ACTION (action), model);
2366 }
2367
2368 static void
2369 ev_window_init (EvWindow *ev_window)
2370 {
2371         GtkActionGroup *action_group;
2372         GtkAccelGroup *accel_group;
2373         GError *error = NULL;
2374         GtkWidget *sidebar_widget, *toolbar_dock;
2375         GConfValue *value;
2376         GConfClient *client;
2377         int sidebar_size;
2378
2379         ev_window->priv = EV_WINDOW_GET_PRIVATE (ev_window);
2380
2381         ev_window->priv->page_mode = PAGE_MODE_SINGLE_PAGE;
2382         update_window_title (NULL, NULL, ev_window);
2383
2384         ev_window->priv->main_box = gtk_vbox_new (FALSE, 0);
2385         gtk_container_add (GTK_CONTAINER (ev_window), ev_window->priv->main_box);
2386         gtk_widget_show (ev_window->priv->main_box);
2387
2388         action_group = gtk_action_group_new ("MenuActions");
2389         ev_window->priv->action_group = action_group;
2390         gtk_action_group_set_translation_domain (action_group, NULL);
2391         gtk_action_group_add_actions (action_group, entries,
2392                                       G_N_ELEMENTS (entries), ev_window);
2393         gtk_action_group_add_toggle_actions (action_group, toggle_entries,
2394                                              G_N_ELEMENTS (toggle_entries),
2395                                              ev_window);
2396         gtk_action_group_add_radio_actions (action_group, page_view_entries,
2397                                             G_N_ELEMENTS (page_view_entries),
2398                                             ev_window->priv->page_mode,
2399                                             G_CALLBACK (ev_window_page_mode_cb),
2400                                             ev_window);
2401         set_action_properties (action_group);
2402         register_custom_actions (ev_window, action_group);
2403
2404         ev_window->priv->ui_manager = gtk_ui_manager_new ();
2405         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
2406                                             action_group, 0);
2407
2408         accel_group =
2409                 gtk_ui_manager_get_accel_group (ev_window->priv->ui_manager);
2410         gtk_window_add_accel_group (GTK_WINDOW (ev_window), accel_group);
2411
2412         g_signal_connect (ev_window->priv->ui_manager, "connect_proxy",
2413                           G_CALLBACK (connect_proxy_cb), ev_window);
2414         g_signal_connect (ev_window->priv->ui_manager, "disconnect_proxy",
2415                           G_CALLBACK (disconnect_proxy_cb), ev_window);
2416
2417         if (!gtk_ui_manager_add_ui_from_file (ev_window->priv->ui_manager,
2418                                               DATADIR"/evince-ui.xml",
2419                                               &error)) {
2420                 g_message ("building menus failed: %s", error->message);
2421                 g_error_free (error);
2422         }
2423
2424         ev_window->priv->menubar =
2425                  gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
2426                                             "/MainMenu");
2427         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box),
2428                             ev_window->priv->menubar,
2429                             FALSE, FALSE, 0);
2430
2431         /* This sucks, but there is no way to have a draw=no, expand=true separator
2432          * in a GtkUIManager-built toolbar. So, just add another toolbar.
2433          * See gtk+ bug 166489.
2434          */
2435         toolbar_dock = ev_window->priv->toolbar_dock = gtk_hbox_new (FALSE, 0);
2436         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), toolbar_dock,
2437                             FALSE, FALSE, 0);
2438         gtk_widget_show (toolbar_dock);
2439
2440         ev_window->priv->toolbar =
2441                 gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
2442                                            "/ToolBar");
2443         gtk_box_pack_start (GTK_BOX (toolbar_dock), ev_window->priv->toolbar,
2444                             TRUE, TRUE, 0);
2445         gtk_widget_show (ev_window->priv->toolbar);
2446
2447         ev_window->priv->fullscreen_toolbar =
2448                 gtk_ui_manager_get_widget (ev_window->priv->ui_manager, "/LeaveFullscreenToolbar");
2449         gtk_toolbar_set_show_arrow (GTK_TOOLBAR (ev_window->priv->fullscreen_toolbar), TRUE);
2450         gtk_toolbar_set_style (GTK_TOOLBAR (ev_window->priv->fullscreen_toolbar), GTK_TOOLBAR_BOTH_HORIZ);
2451
2452         /* Add the main area */
2453         ev_window->priv->hpaned = gtk_hpaned_new ();
2454         g_signal_connect (ev_window->priv->hpaned,
2455                           "notify::position",
2456                           G_CALLBACK (ev_window_sidebar_position_change_cb),
2457                           ev_window);
2458
2459         sidebar_size = SIDEBAR_DEFAULT_SIZE;
2460         client = gconf_client_get_default ();
2461         value = gconf_client_get (client, GCONF_SIDEBAR_SIZE, NULL);
2462         if (value != NULL) {
2463                 if (value->type == GCONF_VALUE_INT) {
2464                         sidebar_size = gconf_value_get_int (value);
2465                 }
2466                 gconf_value_free (value);
2467         }
2468         g_object_unref (client);
2469         gtk_paned_set_position (GTK_PANED (ev_window->priv->hpaned), sidebar_size);
2470         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), ev_window->priv->hpaned,
2471                             TRUE, TRUE, 0);
2472         gtk_widget_show (ev_window->priv->hpaned);
2473
2474         ev_window->priv->sidebar = ev_sidebar_new ();
2475         gtk_paned_pack1 (GTK_PANED (ev_window->priv->hpaned),
2476                          ev_window->priv->sidebar, FALSE, FALSE);
2477         gtk_widget_show (ev_window->priv->sidebar);
2478
2479         /* Stub sidebar, for now */
2480         sidebar_widget = ev_sidebar_links_new ();
2481         g_signal_connect (sidebar_widget,
2482                           "notify::model",
2483                           G_CALLBACK (sidebar_widget_model_set),
2484                           ev_window);
2485         gtk_widget_show (sidebar_widget);
2486         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
2487                              "index",
2488                              _("Index"),
2489                              sidebar_widget);
2490
2491         ev_window->priv->thumbs_sidebar = ev_sidebar_thumbnails_new ();
2492         gtk_widget_show (ev_window->priv->thumbs_sidebar);
2493         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
2494                              "thumbnails",
2495                              _("Thumbnails"),
2496                              ev_window->priv->thumbs_sidebar);
2497
2498         ev_window->priv->scrolled_window =
2499                 GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
2500                                           "shadow-type", GTK_SHADOW_IN,
2501                                           NULL));
2502         gtk_widget_show (ev_window->priv->scrolled_window);
2503
2504         gtk_paned_add2 (GTK_PANED (ev_window->priv->hpaned),
2505                         ev_window->priv->scrolled_window);
2506
2507         ev_window->priv->view = ev_view_new ();
2508         //ev_window->priv->page_view = ev_page_view_new ();
2509         ev_window->priv->password_view = ev_password_view_new ();
2510         g_signal_connect_swapped (ev_window->priv->password_view,
2511                                   "unlock",
2512                                   G_CALLBACK (ev_window_popup_password_dialog),
2513                                   ev_window);
2514         gtk_widget_show (ev_window->priv->view);
2515         //gtk_widget_show (ev_window->priv->page_view);
2516         gtk_widget_show (ev_window->priv->password_view);
2517
2518         /* We own a ref on these widgets, as we can swap them in and out */
2519         g_object_ref (ev_window->priv->view);
2520         //g_object_ref (ev_window->priv->page_view);
2521         g_object_ref (ev_window->priv->password_view);
2522
2523         gtk_container_add (GTK_CONTAINER (ev_window->priv->scrolled_window),
2524                            ev_window->priv->view);
2525         g_signal_connect (ev_window->priv->view,
2526                           "notify::find-status",
2527                           G_CALLBACK (view_find_status_changed_cb),
2528                           ev_window);
2529         g_signal_connect (ev_window->priv->view,
2530                           "notify::status",
2531                           G_CALLBACK (view_status_changed_cb),
2532                           ev_window);
2533
2534         ev_window->priv->statusbar = gtk_statusbar_new ();
2535         gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
2536                           ev_window->priv->statusbar,
2537                           FALSE, TRUE, 0);
2538         ev_window->priv->help_message_cid = gtk_statusbar_get_context_id
2539                 (GTK_STATUSBAR (ev_window->priv->statusbar), "help_message");
2540         ev_window->priv->view_message_cid = gtk_statusbar_get_context_id
2541                 (GTK_STATUSBAR (ev_window->priv->statusbar), "view_message");
2542
2543         ev_window->priv->find_bar = egg_find_bar_new ();
2544         gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
2545                           ev_window->priv->find_bar,
2546                           FALSE, TRUE, 0);
2547
2548         ev_window_setup_recent (ev_window);
2549         ev_window->priv->chrome = load_chrome ();
2550         set_chrome_actions (ev_window);
2551         update_chrome_visibility (ev_window);
2552
2553         /* Connect sidebar signals */
2554         g_signal_connect (ev_window->priv->sidebar,
2555                           "notify::visible",
2556                           G_CALLBACK (ev_window_sidebar_visibility_changed_cb),
2557                           ev_window);
2558
2559         /* Connect to find bar signals */
2560         g_signal_connect (ev_window->priv->find_bar,
2561                           "previous",
2562                           G_CALLBACK (find_bar_previous_cb),
2563                           ev_window);
2564         g_signal_connect (ev_window->priv->find_bar,
2565                           "next",
2566                           G_CALLBACK (find_bar_next_cb),
2567                           ev_window);
2568         g_signal_connect (ev_window->priv->find_bar,
2569                           "close",
2570                           G_CALLBACK (find_bar_close_cb),
2571                           ev_window);
2572         g_signal_connect (ev_window->priv->find_bar,
2573                           "notify::search-string",
2574                           G_CALLBACK (find_bar_search_changed_cb),
2575                           ev_window);
2576         g_signal_connect (ev_window->priv->find_bar,
2577                           "notify::case-sensitive",
2578                           G_CALLBACK (find_bar_search_changed_cb),
2579                           ev_window);
2580         g_signal_connect (ev_window->priv->find_bar,
2581                           "notify::visible",
2582                           G_CALLBACK (find_bar_search_changed_cb),
2583                           ev_window);
2584
2585         g_signal_connect (ev_window, "window-state-event",
2586                           G_CALLBACK (ev_window_state_event_cb),
2587                           ev_window);
2588
2589         /* Give focus to the scrolled window */
2590         gtk_widget_grab_focus (ev_window->priv->scrolled_window);
2591
2592         /* Drag and Drop */
2593         gtk_drag_dest_unset (GTK_WIDGET (ev_window));
2594         gtk_drag_dest_set (GTK_WIDGET (ev_window), GTK_DEST_DEFAULT_ALL, ev_drop_types,
2595                            sizeof (ev_drop_types) / sizeof (ev_drop_types[0]),
2596                            GDK_ACTION_COPY);
2597         g_signal_connect (G_OBJECT (ev_window), "drag_data_received",
2598                           G_CALLBACK (drag_data_received_cb), NULL);
2599
2600         /* Set it to something random to force a change */
2601         ev_window->priv->sizing_mode = EV_SIZING_FREE;
2602         ev_window_set_sizing_mode (ev_window,  EV_SIZING_FIT_WIDTH);
2603         update_action_sensitivity (ev_window);
2604 }