shell/ev-sidebar.c

   1 /* this file is part of evince, a gnome document viewer
   2  *
   3  *  Copyright (C) 2004 Red Hat, Inc.
   4  *
   5  *  Author:
   6  *    Jonathan Blandford <jrb@alum.mit.edu>
   7  *
   8  * Evince is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * Evince is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <string.h>
  28 #include <gtk/gtk.h>
  29 #include <gdk/gdkkeysyms.h>
  30
  31 #include "ev-sidebar.h"
  32 #include "ev-sidebar-page.h"
  33
  34 enum
  35 {
  36         PROP_0,
  37         PROP_CURRENT_PAGE
  38 };
  39
  40 enum
  41 {
  42         PAGE_COLUMN_TITLE,
  43         PAGE_COLUMN_MENU_ITEM,
  44         PAGE_COLUMN_MAIN_WIDGET,
  45         PAGE_COLUMN_NOTEBOOK_INDEX,
  46         PAGE_COLUMN_NUM_COLS
  47 };
  48
  49 struct _EvSidebarPrivate {
  50         GtkWidget *notebook;
  51         GtkWidget *select_button;
  52         GtkWidget *menu;
  53         GtkWidget *hbox;
  54         GtkWidget *label;
  55
  56         GtkTreeModel *page_model;
  57 };
  58
  59 G_DEFINE_TYPE (EvSidebar, ev_sidebar, GTK_TYPE_VBOX)
  60
  61 #define EV_SIDEBAR_GET_PRIVATE(object) \
  62                 (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_SIDEBAR, EvSidebarPrivate))
  63
  64 static void
  65 ev_sidebar_destroy (GtkObject *object)
  66 {
  67         EvSidebar *ev_sidebar = EV_SIDEBAR (object);
  68
  69         if (ev_sidebar->priv->menu) {
  70                 gtk_menu_detach (GTK_MENU (ev_sidebar->priv->menu));
  71                 ev_sidebar->priv->menu = NULL;
  72         }
  73
  74         if (ev_sidebar->priv->page_model) {
  75                 g_object_unref (ev_sidebar->priv->page_model);
  76                 ev_sidebar->priv->page_model = NULL;
  77         }
  78
  79
  80         (* GTK_OBJECT_CLASS (ev_sidebar_parent_class)->destroy) (object);
  81 }
  82
  83 static void
  84 ev_sidebar_select_page (EvSidebar *ev_sidebar,  GtkTreeIter *iter)
  85 {
  86         char *title;
  87         int index;
  88
  89         gtk_tree_model_get (ev_sidebar->priv->page_model, iter,
  90                             PAGE_COLUMN_TITLE, &title,
  91                             PAGE_COLUMN_NOTEBOOK_INDEX, &index,
  92                             -1);
  93
  94         gtk_notebook_set_current_page (GTK_NOTEBOOK (ev_sidebar->priv->notebook), index);
  95         gtk_label_set_text (GTK_LABEL (ev_sidebar->priv->label), title);
  96
  97         g_free (title);
  98 }
  99
 100 void
 101 ev_sidebar_set_page (EvSidebar   *ev_sidebar,
 102                      GtkWidget   *main_widget)
 103 {
 104         GtkTreeIter iter;
 105         gboolean valid;
 106
 107         valid = gtk_tree_model_get_iter_first (ev_sidebar->priv->page_model, &iter);
 108
 109         while (valid) {
 110                 GtkWidget *widget;
 111
 112                 gtk_tree_model_get (ev_sidebar->priv->page_model, &iter,
 113                                     PAGE_COLUMN_MAIN_WIDGET, &widget,
 114                                     -1);
 115
 116                 if (widget == main_widget) {
 117                         ev_sidebar_select_page (ev_sidebar, &iter);
 118                         valid = FALSE;
 119                 } else {
 120                         valid = gtk_tree_model_iter_next (ev_sidebar->priv->page_model, &iter);
 121                 }
 122                 g_object_unref (widget);
 123         }
 124
 125         g_object_notify (G_OBJECT (ev_sidebar), "current-page");
 126 }
 127
 128 static void
 129 ev_sidebar_set_property (GObject      *object,
 130                          guint         prop_id,
 131                          const GValue *value,
 132                          GParamSpec   *pspec)
 133 {
 134         EvSidebar *sidebar = EV_SIDEBAR (object);
 135
 136         switch (prop_id)
 137         {
 138         case PROP_CURRENT_PAGE:
 139                 ev_sidebar_set_page (sidebar, g_value_get_object (value));
 140                 break;
 141         default:
 142                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 143         }
 144 }
 145
 146 static GtkWidget *
 147 ev_sidebar_get_current_page (EvSidebar *sidebar)
 148 {
 149         GtkNotebook *notebook = GTK_NOTEBOOK (sidebar->priv->notebook);
 150
 151         return gtk_notebook_get_nth_page
 152                 (notebook, gtk_notebook_get_current_page (notebook));
 153 }
 154
 155 static void
 156 ev_sidebar_get_property (GObject *object,
 157                          guint prop_id,
 158                          GValue *value,
 159                          GParamSpec *pspec)
 160 {
 161         EvSidebar *sidebar = EV_SIDEBAR (object);
 162
 163         switch (prop_id)
 164         {
 165         case PROP_CURRENT_PAGE:
 166                 g_value_set_object (value, ev_sidebar_get_current_page (sidebar));
 167                 break;
 168         default:
 169                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 170         }
 171 }
 172
 173 static void
 174 ev_sidebar_class_init (EvSidebarClass *ev_sidebar_class)
 175 {
 176         GObjectClass *g_object_class;
 177         GtkWidgetClass *widget_class;
 178         GtkObjectClass *gtk_object_klass;
 179
 180         g_object_class = G_OBJECT_CLASS (ev_sidebar_class);
 181         widget_class = GTK_WIDGET_CLASS (ev_sidebar_class);
 182         gtk_object_klass = GTK_OBJECT_CLASS (ev_sidebar_class);
 183
 184         g_type_class_add_private (g_object_class, sizeof (EvSidebarPrivate));
 185
 186         gtk_object_klass->destroy = ev_sidebar_destroy;
 187         g_object_class->get_property = ev_sidebar_get_property;
 188         g_object_class->set_property = ev_sidebar_set_property;
 189
 190         g_object_class_install_property (g_object_class,
 191                                          PROP_CURRENT_PAGE,
 192                                          g_param_spec_object ("current-page",
 193                                                               "Current page",
 194                                                               "The currently visible page",
 195                                                               GTK_TYPE_WIDGET,
 196                                                               G_PARAM_READWRITE));
 197 }
 198
 199 static void
 200 ev_sidebar_menu_position_under (GtkMenu  *menu,
 201                                 int      *x,
 202                                 int      *y,
 203                                 gboolean *push_in,
 204                                 gpointer  user_data)
 205 {
 206         GtkWidget *widget;
 207
 208         g_return_if_fail (GTK_IS_BUTTON (user_data));
 209         g_return_if_fail (GTK_WIDGET_NO_WINDOW (user_data));
 210
 211         widget = GTK_WIDGET (user_data);
 212
 213         gdk_window_get_origin (widget->window, x, y);
 214
 215         *x += widget->allocation.x;
 216         *y += widget->allocation.y + widget->allocation.height;
 217
 218         *push_in = FALSE;
 219 }
 220
 221 static gboolean
 222 ev_sidebar_select_button_press_cb (GtkWidget      *widget,
 223                                    GdkEventButton *event,
 224                                    gpointer        user_data)
 225 {
 226         EvSidebar *ev_sidebar = EV_SIDEBAR (user_data);
 227
 228         if (event->button == 1) {
 229                 GtkRequisition requisition;
 230                 gint width;
 231
 232                 width = widget->allocation.width;
 233                 gtk_widget_set_size_request (ev_sidebar->priv->menu, -1, -1);
 234                 gtk_widget_size_request (ev_sidebar->priv->menu, &requisition);
 235                 gtk_widget_set_size_request (ev_sidebar->priv->menu,
 236                                              MAX (width, requisition.width), -1);
 237
 238                 gtk_widget_grab_focus (widget);
 239
 240                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
 241                 gtk_menu_popup (GTK_MENU (ev_sidebar->priv->menu),
 242                                 NULL, NULL, ev_sidebar_menu_position_under, widget,
 243                                 event->button, event->time);
 244
 245                 return TRUE;
 246         }
 247
 248         return FALSE;
 249 }
 250
 251 static gboolean
 252 ev_sidebar_select_button_key_press_cb (GtkWidget   *widget,
 253                                        GdkEventKey *event,
 254                                        gpointer     user_data)
 255 {
 256         EvSidebar *ev_sidebar = EV_SIDEBAR (user_data);
 257
 258         if (event->keyval == GDK_space ||
 259             event->keyval == GDK_KP_Space ||
 260             event->keyval == GDK_Return ||
 261             event->keyval == GDK_KP_Enter) {
 262                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
 263                 gtk_menu_popup (GTK_MENU (ev_sidebar->priv->menu),
 264                                 NULL, NULL, ev_sidebar_menu_position_under, widget,
 265                                 1, event->time);
 266                 return TRUE;
 267         }
 268
 269         return FALSE;
 270 }
 271
 272 static void
 273 ev_sidebar_close_clicked_cb (GtkWidget *widget,
 274                              gpointer   user_data)
 275 {
 276         EvSidebar *ev_sidebar = EV_SIDEBAR (user_data);
 277
 278         gtk_widget_hide (GTK_WIDGET (ev_sidebar));
 279 }
 280
 281 static void
 282 ev_sidebar_menu_deactivate_cb (GtkWidget *widget,
 283                                gpointer   user_data)
 284 {
 285         GtkWidget *menu_button;
 286
 287         menu_button = GTK_WIDGET (user_data);
 288
 289         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menu_button), FALSE);
 290 }
 291
 292 static void
 293 ev_sidebar_menu_detach_cb (GtkWidget *widget,
 294                            GtkMenu   *menu)
 295 {
 296         EvSidebar *ev_sidebar = EV_SIDEBAR (widget);
 297
 298         ev_sidebar->priv->menu = NULL;
 299 }
 300
 301 static void
 302 ev_sidebar_menu_item_activate_cb (GtkWidget *widget,
 303                                   gpointer   user_data)
 304 {
 305         EvSidebar *ev_sidebar = EV_SIDEBAR (user_data);
 306         GtkTreeIter iter;
 307         GtkWidget *menu_item, *item;
 308         gboolean valid;
 309
 310         menu_item = gtk_menu_get_active (GTK_MENU (ev_sidebar->priv->menu));
 311         valid = gtk_tree_model_get_iter_first (ev_sidebar->priv->page_model, &iter);
 312
 313         while (valid) {
 314                 gtk_tree_model_get (ev_sidebar->priv->page_model, &iter,
 315                                     PAGE_COLUMN_MENU_ITEM, &item,
 316                                     -1);
 317
 318                 if (item == menu_item) {
 319                         ev_sidebar_select_page (ev_sidebar, &iter);
 320                         valid = FALSE;
 321                 } else {
 322                         valid = gtk_tree_model_iter_next (ev_sidebar->priv->page_model, &iter);
 323                 }
 324                 g_object_unref (item);
 325         }
 326
 327         g_object_notify (G_OBJECT (ev_sidebar), "current-page");
 328 }
 329
 330 static void
 331 ev_sidebar_init (EvSidebar *ev_sidebar)
 332 {
 333         GtkWidget *hbox;
 334         GtkWidget *close_button;
 335         GtkWidget *select_hbox;
 336         GtkWidget *arrow;
 337         GtkWidget *image;
 338
 339         ev_sidebar->priv = EV_SIDEBAR_GET_PRIVATE (ev_sidebar);
 340
 341         /* data model */
 342         ev_sidebar->priv->page_model = (GtkTreeModel *)
 343                         gtk_list_store_new (PAGE_COLUMN_NUM_COLS,
 344                                             G_TYPE_STRING,
 345                                             GTK_TYPE_WIDGET,
 346                                             GTK_TYPE_WIDGET,
 347                                             G_TYPE_INT);
 348
 349         /* top option menu */
 350         hbox = gtk_hbox_new (FALSE, 0);
 351         ev_sidebar->priv->hbox = hbox;
 352         gtk_box_pack_start (GTK_BOX (ev_sidebar), hbox, FALSE, FALSE, 0);
 353         gtk_widget_show (hbox);
 354
 355         ev_sidebar->priv->select_button = gtk_toggle_button_new ();
 356         gtk_button_set_relief (GTK_BUTTON (ev_sidebar->priv->select_button), GTK_RELIEF_NONE);
 357         g_signal_connect (ev_sidebar->priv->select_button, "button_press_event",
 358                           G_CALLBACK (ev_sidebar_select_button_press_cb),
 359                           ev_sidebar);
 360         g_signal_connect (ev_sidebar->priv->select_button, "key_press_event",
 361                           G_CALLBACK (ev_sidebar_select_button_key_press_cb),
 362                           ev_sidebar);
 363
 364         select_hbox = gtk_hbox_new (FALSE, 0);
 365
 366         ev_sidebar->priv->label = gtk_label_new ("");
 367         gtk_box_pack_start (GTK_BOX (select_hbox),
 368                             ev_sidebar->priv->label,
 369                             FALSE, FALSE, 0);
 370         gtk_widget_show (ev_sidebar->priv->label);
 371
 372         arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
 373         gtk_box_pack_end (GTK_BOX (select_hbox), arrow, FALSE, FALSE, 0);
 374         gtk_widget_show (arrow);
 375
 376         gtk_container_add (GTK_CONTAINER (ev_sidebar->priv->select_button), select_hbox);
 377         gtk_widget_show (select_hbox);
 378
 379         gtk_box_pack_start (GTK_BOX (hbox), ev_sidebar->priv->select_button, TRUE, TRUE, 0);
 380         gtk_widget_show (ev_sidebar->priv->select_button);
 381
 382         close_button = gtk_button_new ();
 383         gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
 384         g_signal_connect (close_button, "clicked",
 385                           G_CALLBACK (ev_sidebar_close_clicked_cb),
 386                           ev_sidebar);
 387
 388         image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
 389                                           GTK_ICON_SIZE_MENU);
 390         gtk_container_add (GTK_CONTAINER (close_button), image);
 391         gtk_widget_show (image);
 392
 393         gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
 394         gtk_widget_show (close_button);
 395
 396         ev_sidebar->priv->menu = gtk_menu_new ();
 397         g_signal_connect (ev_sidebar->priv->menu, "deactivate",
 398                           G_CALLBACK (ev_sidebar_menu_deactivate_cb),
 399                           ev_sidebar->priv->select_button);
 400         gtk_menu_attach_to_widget (GTK_MENU (ev_sidebar->priv->menu),
 401                                    GTK_WIDGET (ev_sidebar),
 402                                    ev_sidebar_menu_detach_cb);
 403         gtk_widget_show (ev_sidebar->priv->menu);
 404
 405         ev_sidebar->priv->notebook = gtk_notebook_new ();
 406         gtk_notebook_set_show_border (GTK_NOTEBOOK (ev_sidebar->priv->notebook), FALSE);
 407         gtk_notebook_set_show_tabs (GTK_NOTEBOOK (ev_sidebar->priv->notebook), FALSE);
 408         gtk_box_pack_start (GTK_BOX (ev_sidebar), ev_sidebar->priv->notebook,
 409                             TRUE, TRUE, 0);
 410         gtk_widget_show (ev_sidebar->priv->notebook);
 411
 412         gtk_widget_set_sensitive (GTK_WIDGET (ev_sidebar->priv->notebook), FALSE);
 413         gtk_widget_set_sensitive (GTK_WIDGET (ev_sidebar->priv->select_button), FALSE);
 414 }
 415
 416 /* Public functions */
 417
 418 GtkWidget *
 419 ev_sidebar_new (void)
 420 {
 421         GtkWidget *ev_sidebar;
 422
 423         ev_sidebar = g_object_new (EV_TYPE_SIDEBAR, NULL);
 424
 425         return ev_sidebar;
 426 }
 427
 428 void
 429 ev_sidebar_add_page (EvSidebar   *ev_sidebar,
 430                      GtkWidget   *main_widget)
 431 {
 432         GtkTreeIter iter;
 433         GtkWidget *menu_item;
 434         gchar *label_title;
 435         const gchar *title;
 436         int index;
 437
 438         g_return_if_fail (EV_IS_SIDEBAR (ev_sidebar));
 439         g_return_if_fail (EV_IS_SIDEBAR_PAGE (main_widget));
 440         g_return_if_fail (GTK_IS_WIDGET (main_widget));
 441
 442         title = ev_sidebar_page_get_label (EV_SIDEBAR_PAGE (main_widget));
 443
 444         index = gtk_notebook_append_page (GTK_NOTEBOOK (ev_sidebar->priv->notebook),
 445                                           main_widget, NULL);
 446
 447         menu_item = gtk_image_menu_item_new_with_label (title);
 448         g_signal_connect (menu_item, "activate",
 449                           G_CALLBACK (ev_sidebar_menu_item_activate_cb),
 450                           ev_sidebar);
 451         gtk_widget_show (menu_item);
 452         gtk_menu_shell_append (GTK_MENU_SHELL (ev_sidebar->priv->menu),
 453                                menu_item);
 454
 455         /* Insert and move to end */
 456         gtk_list_store_insert_with_values (GTK_LIST_STORE (ev_sidebar->priv->page_model),
 457                                            &iter, 0,
 458                                            PAGE_COLUMN_TITLE, title,
 459                                            PAGE_COLUMN_MENU_ITEM, menu_item,
 460                                            PAGE_COLUMN_MAIN_WIDGET, main_widget,
 461                                            PAGE_COLUMN_NOTEBOOK_INDEX, index,
 462                                            -1);
 463         gtk_list_store_move_before(GTK_LIST_STORE(ev_sidebar->priv->page_model),
 464                                            &iter, NULL);
 465
 466
 467         /* Set the first item added as active */
 468         gtk_tree_model_get_iter_first (ev_sidebar->priv->page_model, &iter);
 469         gtk_tree_model_get (ev_sidebar->priv->page_model,
 470                             &iter,
 471                             PAGE_COLUMN_TITLE, &label_title,
 472                             PAGE_COLUMN_NOTEBOOK_INDEX, &index,
 473                             -1);
 474
 475         gtk_menu_set_active (GTK_MENU (ev_sidebar->priv->menu), index);
 476         gtk_label_set_text (GTK_LABEL (ev_sidebar->priv->label), label_title);
 477         gtk_notebook_set_current_page (GTK_NOTEBOOK (ev_sidebar->priv->notebook),
 478                                        index);
 479         g_free (label_title);
 480 }
 481
 482 void
 483 ev_sidebar_set_document (EvSidebar   *sidebar,
 484                          EvDocument  *document)
 485 {
 486         EvSidebarPrivate *priv;
 487         GtkTreeIter iter;
 488         gboolean valid;
 489         gboolean has_pages;
 490
 491         g_return_if_fail (EV_IS_SIDEBAR (sidebar));
 492         g_return_if_fail (EV_IS_DOCUMENT (document));
 493
 494         priv = sidebar->priv;
 495
 496         has_pages = FALSE;
 497
 498         for (valid = gtk_tree_model_get_iter_first (priv->page_model, &iter);
 499              valid;
 500              valid = gtk_tree_model_iter_next (priv->page_model, &iter)) {
 501                 GtkWidget *widget;
 502                 GtkWidget *menu_widget;
 503
 504                 gtk_tree_model_get (priv->page_model, &iter,
 505                                     PAGE_COLUMN_MAIN_WIDGET, &widget,
 506                                     PAGE_COLUMN_MENU_ITEM, &menu_widget,
 507                                     -1);
 508
 509
 510                 if (ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (widget), document)) {
 511                                 ev_sidebar_page_set_document (EV_SIDEBAR_PAGE (widget), document);
 512                                 has_pages = TRUE;
 513                 } else {
 514                                 gtk_widget_set_sensitive (menu_widget, FALSE);
 515                 }
 516                 g_object_unref (widget);
 517                 g_object_unref (menu_widget);
 518         }
 519
 520         if (!has_pages) {
 521                 gtk_widget_hide (GTK_WIDGET (sidebar));
 522         } else {
 523                 gtk_widget_set_sensitive (GTK_WIDGET (sidebar->priv->notebook), TRUE);
 524                 gtk_widget_set_sensitive (GTK_WIDGET (sidebar->priv->select_button), TRUE);
 525         }
 526 }
 527