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