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