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