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  *
   7  *  Author:
   8  *    Martin Kretzschmar <martink@gnome.org>
   9  *
  10  * Evince is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * Evince is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #include "ev-window.h"
  30 #include "ev-sidebar.h"
  31 #include "ev-sidebar-bookmarks.h"
  32 #include "ev-sidebar-thumbnails.h"
  33 #include "ev-view.h"
  34 #include "eggfindbar.h"
  35
  36 #include "pdf-document.h"
  37
  38 #include <glib/gi18n.h>
  39 #include <gtk/gtk.h>
  40 #include <libgnomevfs/gnome-vfs-mime-utils.h>
  41
  42 #include <string.h>
  43
  44 #include "ev-application.h"
  45 #include "ev-stock-icons.h"
  46
  47 enum {
  48         PROP_0,
  49         PROP_ATTRIBUTE
  50 };
  51
  52 enum {
  53         SIGNAL,
  54         N_SIGNALS
  55 };
  56
  57 struct _EvWindowPrivate {
  58         GtkWidget *main_box;
  59         GtkWidget *hpaned;
  60         GtkWidget *sidebar;
  61         GtkWidget *find_bar;
  62         GtkWidget *view;
  63         GtkActionGroup *action_group;
  64         GtkUIManager *ui_manager;
  65         GtkWidget *statusbar;
  66         guint help_message_cid;
  67
  68         EvDocument *document;
  69 };
  70
  71 #if 0
  72 /* enable these to add support for signals */
  73 static guint ev_window_signals [N_SIGNALS] = { 0 };
  74 #endif
  75
  76 static GObjectClass *parent_class = NULL;
  77
  78 G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
  79
  80 #define EV_WINDOW_GET_PRIVATE(object) \
  81         (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_WINDOW, EvWindowPrivate))
  82
  83 #if 0
  84 const char *
  85 ev_window_get_attribute (EvWindow *self)
  86 {
  87         g_return_val_if_fail (self != NULL && EV_IS_WINDOW (self), NULL);
  88
  89         return self->priv->attribute;
  90 }
  91
  92 void
  93 ev_window_set_attribute (EvWindow* self, const char *attribute)
  94 {
  95         g_assert (self != NULL && EV_IS_WINDOW (self));
  96         g_assert (attribute != NULL);
  97
  98         if (self->priv->attribute != NULL) {
  99                 g_free (self->priv->attribute);
 100         }
 101
 102         self->priv->attribute = g_strdup (attribute);
 103
 104         g_object_notify (G_OBJECT (self), "attribute");
 105 }
 106
 107 static void
 108 ev_window_get_property (GObject *object, guint prop_id, GValue *value,
 109                         GParamSpec *param_spec)
 110 {
 111         EvWindow *self;
 112
 113         self = EV_WINDOW (object);
 114
 115         switch (prop_id) {
 116         case PROP_ATTRIBUTE:
 117                 g_value_set_string (value, self->priv->attribute);
 118                 break;
 119         default:
 120                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
 121                                                    prop_id,
 122                                                    param_spec);
 123                 break;
 124         }
 125 }
 126
 127 static void
 128 ev_window_set_property (GObject *object, guint prop_id, const GValue *value,
 129                         GParamSpec *param_spec)
 130 {
 131         EvWindow *self;
 132
 133         self = EV_WINDOW (object);
 134
 135         switch (prop_id) {
 136         case PROP_ATTRIBUTE:
 137                 ev_window_set_attribute (self, g_value_get_string (value));
 138                 break;
 139         default:
 140                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
 141                                                    prop_id,
 142                                                    param_spec);
 143                 break;
 144         }
 145 }
 146 #endif
 147
 148 static void
 149 set_action_sensitive (EvWindow   *ev_window,
 150                       const char *name,
 151                       gboolean    sensitive)
 152 {
 153         GtkAction *action = gtk_action_group_get_action (ev_window->priv->action_group,
 154                                                          name);
 155         gtk_action_set_sensitive (action, sensitive);
 156 }
 157
 158 static void
 159 update_action_sensitivity (EvWindow *ev_window)
 160 {
 161         int n_pages;
 162         int page;
 163
 164         if (ev_window->priv->document)
 165                 n_pages = ev_document_get_n_pages (ev_window->priv->document);
 166         else
 167                 n_pages = 1;
 168
 169         page = ev_view_get_page (EV_VIEW (ev_window->priv->view));
 170
 171         set_action_sensitive (ev_window, "GoFirstPage", page > 1);
 172         set_action_sensitive (ev_window, "GoPreviousPage", page > 1);
 173         set_action_sensitive (ev_window, "GoNextPage", page < n_pages);
 174         set_action_sensitive (ev_window, "GoLastPage", page < n_pages);
 175 }
 176
 177 gboolean
 178 ev_window_is_empty (const EvWindow *ev_window)
 179 {
 180         g_return_val_if_fail (EV_IS_WINDOW (ev_window), FALSE);
 181
 182         return ev_window->priv->document == NULL;
 183 }
 184
 185 static void
 186 unable_to_load (EvWindow   *ev_window,
 187                 const char *error_message)
 188 {
 189         GtkWidget *dialog;
 190
 191         dialog = gtk_message_dialog_new (GTK_WINDOW (ev_window),
 192                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 193                                          GTK_MESSAGE_ERROR,
 194                                          GTK_BUTTONS_CLOSE,
 195                                          _("Unable to open document"));
 196         gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
 197                                                   "%s", error_message);
 198         gtk_dialog_run (GTK_DIALOG (dialog));
 199         gtk_widget_destroy (dialog);
 200 }
 201
 202 void
 203 ev_window_open (EvWindow *ev_window, const char *uri)
 204 {
 205         EvDocument *document = NULL;
 206         char *mime_type;
 207
 208         mime_type = gnome_vfs_get_mime_type (uri);
 209
 210         if (!strcmp (mime_type, "application/pdf"))
 211                 document = g_object_new (PDF_TYPE_DOCUMENT, NULL);
 212
 213         if (document) {
 214                 GError *error = NULL;
 215
 216                 if (ev_document_load (document, uri, &error)) {
 217                         if (ev_window->priv->document)
 218                                 g_object_unref (ev_window->priv->document);
 219                         ev_window->priv->document = document;
 220
 221                         ev_view_set_document (EV_VIEW (ev_window->priv->view),
 222                                               document);
 223
 224                         update_action_sensitivity (ev_window);
 225
 226                 } else {
 227                         g_assert (error != NULL);
 228                         g_object_unref (document);
 229                         unable_to_load (ev_window, error->message);
 230                         g_error_free (error);
 231                 }
 232         } else {
 233                 char *error_message;
 234
 235                 error_message = g_strdup_printf (_("Unhandled MIME type: '%s'"),
 236                                                  mime_type);
 237                 unable_to_load (ev_window, error_message);
 238                 g_free (error_message);
 239         }
 240
 241         g_free (mime_type);
 242 }
 243
 244 static void
 245 ev_window_cmd_file_open (GtkAction *action, EvWindow *ev_window)
 246 {
 247         ev_application_open (EV_APP, NULL);
 248 }
 249
 250 static void
 251 ev_window_cmd_file_print (GtkAction *action, EvWindow *ev_window)
 252 {
 253         g_return_if_fail (EV_IS_WINDOW (ev_window));
 254         /* FIXME */
 255 }
 256
 257 static void
 258 ev_window_cmd_file_close_window (GtkAction *action, EvWindow *ev_window)
 259 {
 260         g_return_if_fail (EV_IS_WINDOW (ev_window));
 261
 262         gtk_widget_destroy (GTK_WIDGET (ev_window));
 263 }
 264
 265 static void
 266 ev_window_cmd_edit_find (GtkAction *action, EvWindow *ev_window)
 267 {
 268         g_return_if_fail (EV_IS_WINDOW (ev_window));
 269
 270         gtk_widget_show (ev_window->priv->find_bar);
 271         egg_find_bar_grab_focus (EGG_FIND_BAR (ev_window->priv->find_bar));
 272 }
 273
 274 static void
 275 ev_window_cmd_edit_copy (GtkAction *action, EvWindow *ev_window)
 276 {
 277         g_return_if_fail (EV_IS_WINDOW (ev_window));
 278
 279         /* FIXME */
 280 }
 281
 282 static void
 283 ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *ev_window)
 284 {
 285         g_return_if_fail (EV_IS_WINDOW (ev_window));
 286
 287         /* FIXME */
 288 }
 289
 290 static void
 291 ev_window_cmd_view_zoom_in (GtkAction *action, EvWindow *ev_window)
 292 {
 293         g_return_if_fail (EV_IS_WINDOW (ev_window));
 294
 295         ev_view_zoom_in (EV_VIEW (ev_window->priv->view));
 296 }
 297
 298 static void
 299 ev_window_cmd_view_zoom_out (GtkAction *action, EvWindow *ev_window)
 300 {
 301         g_return_if_fail (EV_IS_WINDOW (ev_window));
 302
 303         ev_view_zoom_out (EV_VIEW (ev_window->priv->view));
 304 }
 305
 306 static void
 307 ev_window_cmd_view_normal_size (GtkAction *action, EvWindow *ev_window)
 308 {
 309         g_return_if_fail (EV_IS_WINDOW (ev_window));
 310
 311         ev_view_normal_size (EV_VIEW (ev_window->priv->view));
 312 }
 313
 314 static void
 315 ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window)
 316 {
 317         g_return_if_fail (EV_IS_WINDOW (ev_window));
 318
 319         ev_view_best_fit (EV_VIEW (ev_window->priv->view));
 320 }
 321
 322 static void
 323 ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window)
 324 {
 325         g_return_if_fail (EV_IS_WINDOW (ev_window));
 326
 327         ev_view_fit_width (EV_VIEW (ev_window->priv->view));
 328 }
 329
 330 static void
 331 ev_window_cmd_go_back (GtkAction *action, EvWindow *ev_window)
 332 {
 333         g_return_if_fail (EV_IS_WINDOW (ev_window));
 334
 335         /* FIXME */
 336 }
 337
 338 static void
 339 ev_window_cmd_go_forward (GtkAction *action, EvWindow *ev_window)
 340 {
 341         g_return_if_fail (EV_IS_WINDOW (ev_window));
 342
 343         /* FIXME */
 344 }
 345
 346 static void
 347 ev_window_cmd_go_previous_page (GtkAction *action, EvWindow *ev_window)
 348 {
 349         g_return_if_fail (EV_IS_WINDOW (ev_window));
 350
 351         ev_view_set_page (EV_VIEW (ev_window->priv->view),
 352                           ev_view_get_page (EV_VIEW (ev_window->priv->view)) - 1);
 353 }
 354
 355 static void
 356 ev_window_cmd_go_next_page (GtkAction *action, EvWindow *ev_window)
 357 {
 358         g_return_if_fail (EV_IS_WINDOW (ev_window));
 359
 360         ev_view_set_page (EV_VIEW (ev_window->priv->view),
 361                           ev_view_get_page (EV_VIEW (ev_window->priv->view)) + 1);
 362 }
 363
 364 static void
 365 ev_window_cmd_go_first_page (GtkAction *action, EvWindow *ev_window)
 366 {
 367         g_return_if_fail (EV_IS_WINDOW (ev_window));
 368
 369         ev_view_set_page (EV_VIEW (ev_window->priv->view), 1);
 370 }
 371
 372 static void
 373 ev_window_cmd_go_last_page (GtkAction *action, EvWindow *ev_window)
 374 {
 375         g_return_if_fail (EV_IS_WINDOW (ev_window));
 376
 377         ev_view_set_page (EV_VIEW (ev_window->priv->view), G_MAXINT);
 378 }
 379
 380 static void
 381 ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
 382 {
 383         g_return_if_fail (EV_IS_WINDOW (ev_window));
 384
 385         /* FIXME */
 386 }
 387
 388 static void
 389 ev_window_cmd_help_about (GtkAction *action, EvWindow *ev_window)
 390 {
 391         const char *authors[] = {
 392                 N_("Many..."),
 393                 NULL
 394         };
 395
 396         const char *documenters[] = {
 397                 N_("Not so many..."),
 398                 NULL
 399         };
 400
 401         const char *license[] = {
 402                 N_("Evince is free software; you can redistribute it and/or modify\n"
 403                    "it under the terms of the GNU General Public License as published by\n"
 404                    "the Free Software Foundation; either version 2 of the License, or\n"
 405                    "(at your option) any later version.\n"),
 406                 N_("Evince is distributed in the hope that it will be useful,\n"
 407                    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 408                    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 409                    "GNU General Public License for more details.\n"),
 410                 N_("You should have received a copy of the GNU General Public License\n"
 411                    "along with Evince; if not, write to the Free Software Foundation, Inc.,\n"
 412                    "59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n")
 413         };
 414
 415         char *license_trans;
 416
 417 #ifdef ENABLE_NLS
 418         const char **p;
 419
 420         for (p = authors; *p; ++p)
 421                 *p = _(*p);
 422
 423         for (p = documenters; *p; ++p)
 424                 *p = _(*p);
 425 #endif
 426
 427         license_trans = g_strconcat (_(license[0]), "\n", _(license[1]), "\n",
 428                                      _(license[2]), "\n", NULL);
 429
 430         gtk_show_about_dialog (
 431                 GTK_WINDOW (ev_window),
 432                 "name", _("Evince"),
 433                 "version", VERSION,
 434                 "copyright",
 435                 _("\xc2\xa9 1996-2004 The Evince authors"),
 436                 "license", license_trans,
 437                 "website", "http://www.gnome.org/projects/evince",
 438                 "comments", _("PostScript and PDF File Viewer."),
 439                 "authors", authors,
 440                 "documenters", documenters,
 441                 "translator-credits", _("translator-credits"),
 442                 NULL);
 443
 444         g_free (license_trans);
 445 }
 446
 447 static void
 448 ev_window_view_toolbar_cb (GtkAction *action, EvWindow *ev_window)
 449 {
 450         g_object_set (
 451                 G_OBJECT (gtk_ui_manager_get_widget (
 452                                   ev_window->priv->ui_manager,
 453                                   "/ToolBar")),
 454                 "visible",
 455                 gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)),
 456                 NULL);
 457 }
 458
 459 static void
 460 ev_window_view_statusbar_cb (GtkAction *action, EvWindow *ev_window)
 461 {
 462         g_object_set (
 463                 ev_window->priv->statusbar,
 464                 "visible",
 465                 gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)),
 466                 NULL);
 467 }
 468
 469 static void
 470 ev_window_view_sidebar_cb (GtkAction *action, EvWindow *ev_window)
 471 {
 472         /* FIXME */
 473 }
 474
 475 static void
 476 menu_item_select_cb (GtkMenuItem *proxy, EvWindow *ev_window)
 477 {
 478         GtkAction *action;
 479         char *message;
 480
 481         action = g_object_get_data (G_OBJECT (proxy), "gtk-action");
 482         g_return_if_fail (action != NULL);
 483
 484         g_object_get (G_OBJECT (action), "tooltip", &message, NULL);
 485         if (message) {
 486                 gtk_statusbar_push (GTK_STATUSBAR (ev_window->priv->statusbar),
 487                                     ev_window->priv->help_message_cid, message);
 488                 g_free (message);
 489         }
 490 }
 491
 492 static void
 493 menu_item_deselect_cb (GtkMenuItem *proxy, EvWindow *ev_window)
 494 {
 495         gtk_statusbar_pop (GTK_STATUSBAR (ev_window->priv->statusbar),
 496                            ev_window->priv->help_message_cid);
 497 }
 498
 499 static void
 500 connect_proxy_cb (GtkUIManager *ui_manager, GtkAction *action,
 501                   GtkWidget *proxy, EvWindow *ev_window)
 502 {
 503         if (GTK_IS_MENU_ITEM (proxy)) {
 504                 g_signal_connect (proxy, "select",
 505                                   G_CALLBACK (menu_item_select_cb), ev_window);
 506                 g_signal_connect (proxy, "deselect",
 507                                   G_CALLBACK (menu_item_deselect_cb),
 508                                   ev_window);
 509         }
 510 }
 511
 512 static void
 513 disconnect_proxy_cb (GtkUIManager *ui_manager, GtkAction *action,
 514                      GtkWidget *proxy, EvWindow *ev_window)
 515 {
 516         if (GTK_IS_MENU_ITEM (proxy)) {
 517                 g_signal_handlers_disconnect_by_func
 518                         (proxy, G_CALLBACK (menu_item_select_cb), ev_window);
 519                 g_signal_handlers_disconnect_by_func
 520                         (proxy, G_CALLBACK (menu_item_deselect_cb), ev_window);
 521         }
 522 }
 523
 524 static void
 525 view_page_changed_cb (EvView   *view,
 526                       EvWindow *ev_window)
 527 {
 528         update_action_sensitivity (ev_window);
 529 }
 530
 531 static void
 532 find_bar_previous_cb (EggFindBar *find_bar,
 533                       EvWindow   *ev_window)
 534 {
 535         /* FIXME - highlight previous result */
 536         g_printerr ("Find Previous\n");
 537
 538 }
 539
 540 static void
 541 find_bar_next_cb (EggFindBar *find_bar,
 542                   EvWindow   *ev_window)
 543 {
 544         /* FIXME - highlight next result */
 545         g_printerr ("Find Next\n");
 546 }
 547
 548 static void
 549 find_bar_close_cb (EggFindBar *find_bar,
 550                    EvWindow   *ev_window)
 551 {
 552         gtk_widget_hide (ev_window->priv->find_bar);
 553 }
 554
 555 static void
 556 find_bar_search_changed_cb (EggFindBar *find_bar,
 557                             GParamSpec *param,
 558                             EvWindow   *ev_window)
 559 {
 560         gboolean case_sensitive;
 561         gboolean visible;
 562         const char *search_string;
 563
 564         g_return_if_fail (EV_IS_WINDOW (ev_window));
 565
 566         /* Either the string or case sensitivity could have changed,
 567          * we connect this callback to both. We also connect it
 568          * to ::visible so when the find bar is hidden, we should
 569          * pretend the search string is NULL/""
 570          */
 571
 572         case_sensitive = egg_find_bar_get_case_sensitive (find_bar);
 573         visible = GTK_WIDGET_VISIBLE (find_bar);
 574         search_string = egg_find_bar_get_search_string (find_bar);
 575
 576 #if 0
 577         g_printerr ("search for '%s'\n", search_string ? search_string : "(nil)");
 578 #endif
 579
 580         /* We don't require begin/end find calls to be matched up, it's really
 581          * start_find and cancel_any_find_that_may_not_be_finished
 582          */
 583         if (visible && search_string) {
 584                 ev_document_begin_find (ev_window->priv->document, search_string, case_sensitive);
 585         } else {
 586                 ev_document_end_find (ev_window->priv->document);
 587         }
 588 }
 589
 590 static void
 591 ev_window_dispose (GObject *object)
 592 {
 593         EvWindowPrivate *priv;
 594
 595         g_return_if_fail (object != NULL && EV_IS_WINDOW (object));
 596
 597         priv = EV_WINDOW (object)->priv;
 598
 599         if (priv->ui_manager) {
 600                 g_object_unref (priv->ui_manager);
 601                 priv->ui_manager = NULL;
 602         }
 603
 604         if (priv->action_group) {
 605                 g_object_unref (priv->action_group);
 606                 priv->action_group = NULL;
 607         }
 608
 609         G_OBJECT_CLASS (parent_class)->dispose (object);
 610 }
 611
 612 static void
 613 ev_window_class_init (EvWindowClass *ev_window_class)
 614 {
 615         GObjectClass *g_object_class;
 616
 617         parent_class = g_type_class_peek_parent (ev_window_class);
 618
 619         g_object_class = G_OBJECT_CLASS (ev_window_class);
 620         g_object_class->dispose = ev_window_dispose;
 621
 622         g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));
 623
 624 #if 0
 625         /* setting up signal system */
 626         ev_window_class->signal = ev_window_signal;
 627
 628         ev_window_signals [SIGNAL] = g_signal_new (
 629                 "signal",
 630                 EV_TYPE_WINDOW,
 631                 G_SIGNAL_RUN_LAST,
 632                 G_STRUCT_OFFSET (EvWindowClass,
 633                                  signal),
 634                 NULL,
 635                 NULL,
 636                 g_cclosure_marshal_VOID__STRING,
 637                 G_TYPE_NONE,
 638                 0);
 639         /* setting up property system */
 640         g_object_class->set_property = ev_window_set_property;
 641         g_object_class->get_property = ev_window_get_property;
 642
 643         g_object_class_install_property (
 644                 g_object_class,
 645                 PROP_ATTRIBUTE,
 646                 g_param_spec_string ("attribute",
 647                                      "Attribute",
 648                                      "A simple unneccessary attribute that "
 649                                      "does nothing special except being a "
 650                                      "demonstration for the correct implem"
 651                                      "entation of a GObject property",
 652                                      "default_value",
 653                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 654 #endif
 655 }
 656
 657 /* Normal items */
 658 static GtkActionEntry entries[] = {
 659         { "File", NULL, N_("_File") },
 660         { "Edit", NULL, N_("_Edit") },
 661         { "View", NULL, N_("_View") },
 662         { "Go", NULL, N_("_Go") },
 663         { "Help", NULL, N_("_Help") },
 664
 665         /* File menu */
 666         { "FileOpen", GTK_STOCK_OPEN, N_("_Open"), "<control>O",
 667           N_("Open a file"),
 668           G_CALLBACK (ev_window_cmd_file_open) },
 669         { "FilePrint", GTK_STOCK_PRINT, N_("_Print"), "<control>P",
 670           N_("Print this document"),
 671           G_CALLBACK (ev_window_cmd_file_print) },
 672         { "FileCloseWindow", GTK_STOCK_CLOSE, N_("_Close"), "<control>W",
 673           N_("Close this window"),
 674           G_CALLBACK (ev_window_cmd_file_close_window) },
 675
 676         /* Edit menu */
 677         { "EditCopy", GTK_STOCK_COPY, N_("_Copy"), "<control>C",
 678           N_("Copy text from the document"),
 679           G_CALLBACK (ev_window_cmd_edit_copy) },
 680
 681         { "EditFind", GTK_STOCK_FIND, N_("_Find"), "<control>F",
 682           N_("Find a word or phrase in the document"),
 683           G_CALLBACK (ev_window_cmd_edit_find) },
 684
 685         /* View menu */
 686         { "ViewFullscreen", NULL, N_("_Fullscreen"), "F11",
 687           N_("Expand the window to fill the screen"),
 688           G_CALLBACK (ev_window_cmd_view_fullscreen) },
 689         { "ViewZoomIn", GTK_STOCK_ZOOM_IN, N_("Zoom _In"), "<control>plus",
 690           N_("Enlarge the document"),
 691           G_CALLBACK (ev_window_cmd_view_zoom_in) },
 692         { "ViewZoomOut", GTK_STOCK_ZOOM_OUT, N_("Zoom _Out"), "<control>minus",
 693           N_("Shrink the document"),
 694           G_CALLBACK (ev_window_cmd_view_zoom_out) },
 695         { "ViewNormalSize", GTK_STOCK_ZOOM_100, N_("_Normal Size"), "<control>0",
 696           N_("Zoom to the normal size"),
 697           G_CALLBACK (ev_window_cmd_view_normal_size) },
 698         { "ViewBestFit", GTK_STOCK_ZOOM_FIT, N_("_Best Fit"), NULL,
 699           N_("Zoom to fit the document to the current window"),
 700           G_CALLBACK (ev_window_cmd_view_best_fit) },
 701         { "ViewPageWidth", EV_STOCK_ZOOM_FIT_WIDTH, N_("Fit Page _Width"), NULL,
 702           N_("Zoom to fit the width of the current window "),
 703           G_CALLBACK (ev_window_cmd_view_page_width) },
 704
 705         /* Go menu */
 706         { "GoBack", GTK_STOCK_GO_BACK, N_("_Back"), "<mod1>Left",
 707           N_("Go to the page viewed before this one"),
 708           G_CALLBACK (ev_window_cmd_go_back) },
 709         { "GoForward", GTK_STOCK_GO_FORWARD, N_("Fo_rward"), "<mod1>Right",
 710           N_("Go to the page viewed before this one"),
 711           G_CALLBACK (ev_window_cmd_go_forward) },
 712         { "GoPreviousPage", GTK_STOCK_GO_BACK, N_("_Previous Page"), "<control>Page_Up",
 713           N_("Go to the previous page"),
 714           G_CALLBACK (ev_window_cmd_go_previous_page) },
 715         { "GoNextPage", GTK_STOCK_GO_FORWARD, N_("_Next Page"), "<control>Page_Down",
 716           N_("Go to the next page"),
 717           G_CALLBACK (ev_window_cmd_go_next_page) },
 718         { "GoFirstPage", GTK_STOCK_GOTO_FIRST, N_("_First Page"), "<control>Home",
 719           N_("Go to the first page"),
 720           G_CALLBACK (ev_window_cmd_go_first_page) },
 721         { "GoLastPage", GTK_STOCK_GOTO_LAST, N_("_Last Page"), "<control>End",
 722           N_("Go to the last page"),
 723           G_CALLBACK (ev_window_cmd_go_last_page) },
 724
 725         /* Help menu */
 726         { "HelpContents", GTK_STOCK_HELP, N_("_Contents"), NULL,
 727           N_("Display help for the viewer application"),
 728           G_CALLBACK (ev_window_cmd_help_contents) },
 729
 730         { "HelpAbout", GTK_STOCK_ABOUT, N_("_About"), NULL,
 731           N_("Display credits for the document viewer creators"),
 732           G_CALLBACK (ev_window_cmd_help_about) },
 733 };
 734
 735 /* Toggle items */
 736 static GtkToggleActionEntry toggle_entries[] = {
 737         /* View Menu */
 738         { "ViewToolbar", NULL, N_("_Toolbar"), "<shift><control>T",
 739           N_("Show or hide toolbar"),
 740           G_CALLBACK (ev_window_view_toolbar_cb), TRUE },
 741         { "ViewStatusbar", NULL, N_("_Statusbar"), NULL,
 742           N_("Show or hide statusbar"),
 743           G_CALLBACK (ev_window_view_statusbar_cb), TRUE },
 744         { "ViewSidebar", NULL, N_("Side_bar"), "F9",
 745           N_("Show or hide sidebar"),
 746           G_CALLBACK (ev_window_view_sidebar_cb), FALSE },
 747 };
 748
 749 static void
 750 ev_window_init (EvWindow *ev_window)
 751 {
 752         GtkActionGroup *action_group;
 753         GtkAccelGroup *accel_group;
 754         GError *error = NULL;
 755         GtkWidget *scrolled_window;
 756         GtkWidget *menubar;
 757         GtkWidget *toolbar;
 758         GtkWidget *sidebar_widget;
 759
 760         ev_window->priv = EV_WINDOW_GET_PRIVATE (ev_window);
 761
 762         gtk_window_set_title (GTK_WINDOW (ev_window), _("Document Viewer"));
 763
 764         ev_window->priv->main_box = gtk_vbox_new (FALSE, 0);
 765         gtk_container_add (GTK_CONTAINER (ev_window), ev_window->priv->main_box);
 766         gtk_widget_show (ev_window->priv->main_box);
 767
 768         action_group = gtk_action_group_new ("MenuActions");
 769         ev_window->priv->action_group = action_group;
 770         gtk_action_group_set_translation_domain (action_group, NULL);
 771         gtk_action_group_add_actions (action_group, entries,
 772                                       G_N_ELEMENTS (entries), ev_window);
 773         gtk_action_group_add_toggle_actions (action_group, toggle_entries,
 774                                              G_N_ELEMENTS (toggle_entries),
 775                                              ev_window);
 776
 777         ev_window->priv->ui_manager = gtk_ui_manager_new ();
 778         gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
 779                                             action_group, 0);
 780
 781         accel_group =
 782                 gtk_ui_manager_get_accel_group (ev_window->priv->ui_manager);
 783         gtk_window_add_accel_group (GTK_WINDOW (ev_window), accel_group);
 784
 785         g_signal_connect (ev_window->priv->ui_manager, "connect_proxy",
 786                           G_CALLBACK (connect_proxy_cb), ev_window);
 787         g_signal_connect (ev_window->priv->ui_manager, "disconnect_proxy",
 788                           G_CALLBACK (disconnect_proxy_cb), ev_window);
 789
 790         if (!gtk_ui_manager_add_ui_from_file (ev_window->priv->ui_manager,
 791                                               DATADIR"/evince-ui.xml",
 792                                               &error)) {
 793                 g_message ("building menus failed: %s", error->message);
 794                 g_error_free (error);
 795         }
 796
 797         menubar = gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
 798                                              "/MainMenu");
 799         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), menubar,
 800                             FALSE, FALSE, 0);
 801
 802         toolbar = gtk_ui_manager_get_widget (ev_window->priv->ui_manager,
 803                                              "/ToolBar");
 804         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), toolbar,
 805                             FALSE, FALSE, 0);
 806
 807         /* Add the main area */
 808         ev_window->priv->hpaned = gtk_hpaned_new ();
 809         gtk_widget_show (ev_window->priv->hpaned);
 810         gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), ev_window->priv->hpaned,
 811                             TRUE, TRUE, 0);
 812
 813         ev_window->priv->sidebar = ev_sidebar_new ();
 814         gtk_widget_show (ev_window->priv->sidebar);
 815         gtk_paned_add1 (GTK_PANED (ev_window->priv->hpaned),
 816                         ev_window->priv->sidebar);
 817
 818         /* Stub sidebar, for now */
 819         sidebar_widget = ev_sidebar_bookmarks_new ();
 820         gtk_widget_show (sidebar_widget);
 821         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
 822                              "bookmarks",
 823                              _("Bookmarks"),
 824                              sidebar_widget);
 825
 826         sidebar_widget = ev_sidebar_thumbnails_new ();
 827         gtk_widget_show (sidebar_widget);
 828         ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
 829                              "thumbnails",
 830                              _("Thumbnails"),
 831                              sidebar_widget);
 832
 833         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 834         gtk_widget_show (scrolled_window);
 835         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 836                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 837
 838         gtk_paned_add2 (GTK_PANED (ev_window->priv->hpaned),
 839                         scrolled_window);
 840
 841         ev_window->priv->view = ev_view_new ();
 842         gtk_widget_show (ev_window->priv->view);
 843         gtk_container_add (GTK_CONTAINER (scrolled_window),
 844                            ev_window->priv->view);
 845         g_signal_connect (ev_window->priv->view,
 846                           "page-changed",
 847                           G_CALLBACK (view_page_changed_cb),
 848                           ev_window);
 849
 850         ev_window->priv->statusbar = gtk_statusbar_new ();
 851         gtk_widget_show (ev_window->priv->statusbar);
 852         gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
 853                           ev_window->priv->statusbar,
 854                           FALSE, TRUE, 0);
 855         ev_window->priv->help_message_cid = gtk_statusbar_get_context_id
 856                 (GTK_STATUSBAR (ev_window->priv->statusbar), "help_message");
 857
 858         ev_window->priv->find_bar = egg_find_bar_new ();
 859         gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
 860                           ev_window->priv->find_bar,
 861                           FALSE, TRUE, 0);
 862
 863         /* Connect to find bar signals */
 864         g_signal_connect (ev_window->priv->find_bar,
 865                           "previous",
 866                           G_CALLBACK (find_bar_previous_cb),
 867                           ev_window);
 868         g_signal_connect (ev_window->priv->find_bar,
 869                           "next",
 870                           G_CALLBACK (find_bar_next_cb),
 871                           ev_window);
 872         g_signal_connect (ev_window->priv->find_bar,
 873                           "close",
 874                           G_CALLBACK (find_bar_close_cb),
 875                           ev_window);
 876         g_signal_connect (ev_window->priv->find_bar,
 877                           "notify::search-string",
 878                           G_CALLBACK (find_bar_search_changed_cb),
 879                           ev_window);
 880         g_signal_connect (ev_window->priv->find_bar,
 881                           "notify::case-sensitive",
 882                           G_CALLBACK (find_bar_search_changed_cb),
 883                           ev_window);
 884         g_signal_connect (ev_window->priv->find_bar,
 885                           "notify::visible",
 886                           G_CALLBACK (find_bar_search_changed_cb),
 887                           ev_window);
 888
 889         update_action_sensitivity (ev_window);
 890 }