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