src/libgdl/gdl-switcher.c

   1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 8 -*- */
   2 /* gdl-switcher.c
   3  *
   4  * Copyright (C) 2003  Ettore Perazzoli,
   5  *               2007  Naba Kumar
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of version 2 of the GNU General Public
   9  * License as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  * Copied and adapted from ESidebar.[ch] from evolution
  22  *
  23  * Authors: Ettore Perazzoli <ettore@ximian.com>
  24  *          Naba Kumar  <naba@gnome.org>
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include <config.h>
  29 #endif
  30
  31 #include "gdl-i18n.h"
  32 #include "gdl-switcher.h"
  33 #include "gdl-tools.h"
  34 #include "libgdlmarshal.h"
  35 #include "libgdltypebuiltins.h"
  36
  37 #include <gtk/gtk.h>
  38 #include <gtk/gtkhbox.h>
  39 #include <gtk/gtkimage.h>
  40 #include <gtk/gtklabel.h>
  41 #include <gtk/gtktogglebutton.h>
  42
  43 #if HAVE_GNOME
  44 #include <gconf/gconf-client.h>
  45 #include <libgnome/gnome-gconf.h>
  46 #endif
  47
  48 static void gdl_switcher_set_property  (GObject            *object,
  49                                         guint               prop_id,
  50                                         const GValue       *value,
  51                                         GParamSpec         *pspec);
  52 static void gdl_switcher_get_property  (GObject            *object,
  53                                         guint               prop_id,
  54                                         GValue             *value,
  55                                         GParamSpec         *pspec);
  56
  57 static void gdl_switcher_add_button  (GdlSwitcher *switcher,
  58                                       const gchar *label,
  59                                       const gchar *tooltips,
  60                                       const gchar *stock_id,
  61                                       const GdkPixbuf *pixbuf_icon,
  62                                       gint switcher_id);
  63 static void gdl_switcher_remove_button (GdlSwitcher *switcher, gint switcher_id);
  64 static void gdl_switcher_select_page (GdlSwitcher *switcher, gint switcher_id);
  65 static void gdl_switcher_select_button (GdlSwitcher *switcher, gint switcher_id);
  66 static void gdl_switcher_set_show_buttons (GdlSwitcher *switcher, gboolean show);
  67 static void gdl_switcher_set_style (GdlSwitcher *switcher,
  68                                     GdlSwitcherStyle switcher_style);
  69 static GdlSwitcherStyle gdl_switcher_get_style (GdlSwitcher *switcher);
  70
  71 enum {
  72     PROP_0,
  73     PROP_SWITCHER_STYLE
  74 };
  75
  76 typedef struct {
  77     GtkWidget *button_widget;
  78     GtkWidget *label;
  79     GtkWidget *icon;
  80     GtkWidget *arrow;
  81     GtkWidget *hbox;
  82     GtkTooltips *tooltips;
  83     int id;
  84 } Button;
  85
  86 struct _GdlSwitcherPrivate {
  87     GdlSwitcherStyle switcher_style;
  88     GdlSwitcherStyle toolbar_style;
  89
  90     gboolean show;
  91     GSList *buttons;
  92
  93     guint style_changed_id;
  94     gint buttons_height_request;
  95     gboolean in_toggle;
  96 };
  97
  98 GDL_CLASS_BOILERPLATE (GdlSwitcher, gdl_switcher, GtkNotebook, GTK_TYPE_NOTEBOOK)
  99
 100 #define INTERNAL_MODE(switcher)  (switcher->priv->switcher_style == \
 101             GDL_SWITCHER_STYLE_TOOLBAR ? switcher->priv->toolbar_style : \
 102             switcher->priv->switcher_style)
 103
 104 #define H_PADDING 2
 105 #define V_PADDING 2
 106
 107 /* Utility functions.  */
 108
 109 static Button *
 110 button_new (GtkWidget *button_widget, GtkWidget *label, GtkWidget *icon,
 111             GtkTooltips *tooltips, GtkWidget *arrow, GtkWidget *hbox, int id)
 112 {
 113     Button *button = g_new (Button, 1);
 114
 115     button->button_widget = button_widget;
 116     button->label = label;
 117     button->icon = icon;
 118     button->arrow = arrow;
 119     button->hbox = hbox;
 120     button->tooltips = tooltips;
 121     button->id = id;
 122
 123     g_object_ref (button_widget);
 124     g_object_ref (label);
 125     g_object_ref (icon);
 126     g_object_ref (arrow);
 127     g_object_ref (hbox);
 128     g_object_ref (tooltips);
 129
 130     return button;
 131 }
 132
 133 static void
 134 button_free (Button *button)
 135 {
 136     g_object_unref (button->button_widget);
 137     g_object_unref (button->label);
 138     g_object_unref (button->icon);
 139     g_object_unref (button->hbox);
 140     g_object_unref (button->tooltips);
 141     g_free (button);
 142 }
 143
 144 static gint
 145 gdl_switcher_get_page_id (GtkWidget *widget)
 146 {
 147     static gint switcher_id_count = 0;
 148     gint switcher_id;
 149     switcher_id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
 150                                                       "__switcher_id"));
 151     if (switcher_id <= 0) {
 152         switcher_id = ++switcher_id_count;
 153         g_object_set_data (G_OBJECT (widget), "__switcher_id",
 154                            GINT_TO_POINTER (switcher_id));
 155     }
 156     return switcher_id;
 157 }
 158
 159 static void
 160 update_buttons (GdlSwitcher *switcher, int new_selected_id)
 161 {
 162     GSList *p;
 163
 164     switcher->priv->in_toggle = TRUE;
 165
 166     for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 167         Button *button = p->data;
 168
 169         if (button->id == new_selected_id) {
 170             gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
 171                                           (button->button_widget), TRUE);
 172             gtk_widget_set_sensitive (button->arrow, TRUE);
 173         } else {
 174             gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
 175                                           (button->button_widget), FALSE);
 176             gtk_widget_set_sensitive (button->arrow, FALSE);
 177         }
 178     }
 179
 180     switcher->priv->in_toggle = FALSE;
 181 }
 182
 183 /* Callbacks.  */
 184
 185 static void
 186 button_toggled_callback (GtkToggleButton *toggle_button,
 187                          GdlSwitcher *switcher)
 188 {
 189     int id = 0;
 190     gboolean is_active = FALSE;
 191     GSList *p;
 192
 193     if (switcher->priv->in_toggle)
 194         return;
 195
 196     switcher->priv->in_toggle = TRUE;
 197
 198     if (gtk_toggle_button_get_active (toggle_button))
 199         is_active = TRUE;
 200
 201     for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 202         Button *button = p->data;
 203
 204         if (button->button_widget != GTK_WIDGET (toggle_button)) {
 205             gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
 206                                           (button->button_widget), FALSE);
 207             gtk_widget_set_sensitive (button->arrow, FALSE);
 208         } else {
 209             gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
 210                                           (button->button_widget), TRUE);
 211             gtk_widget_set_sensitive (button->arrow, TRUE);
 212             id = button->id;
 213         }
 214     }
 215
 216     switcher->priv->in_toggle = FALSE;
 217
 218     if (is_active)
 219     {
 220         gdl_switcher_select_page (switcher, id);
 221     }
 222 }
 223
 224 /* Returns -1 if layout didn't happen because a resize request was queued */
 225 static int
 226 layout_buttons (GdlSwitcher *switcher)
 227 {
 228     GtkRequisition client_requisition;
 229     GtkAllocation *allocation = & GTK_WIDGET (switcher)->allocation;
 230     GdlSwitcherStyle switcher_style;
 231     gboolean icons_only;
 232     int num_btns = g_slist_length (switcher->priv->buttons);
 233     int btns_per_row;
 234     GSList **rows, *p;
 235     Button *button;
 236     int row_number;
 237     int max_btn_width = 0, max_btn_height = 0;
 238     int optimal_layout_width = 0;
 239     int row_last;
 240     int x, y;
 241     int i;
 242     int rows_count;
 243     int last_buttons_height;
 244
 245     last_buttons_height = switcher->priv->buttons_height_request;
 246
 247     GDL_CALL_PARENT (GTK_WIDGET_CLASS, size_request,
 248                      (GTK_WIDGET (switcher), &client_requisition));
 249
 250     y = allocation->y + allocation->height - V_PADDING - 1;
 251
 252     if (num_btns == 0)
 253         return y;
 254
 255     switcher_style = INTERNAL_MODE (switcher);
 256     icons_only = (switcher_style == GDL_SWITCHER_STYLE_ICON);
 257
 258     /* Figure out the max width and height */
 259     optimal_layout_width = H_PADDING;
 260     for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 261         GtkRequisition requisition;
 262
 263         button = p->data;
 264         gtk_widget_size_request (GTK_WIDGET (button->button_widget),
 265                                  &requisition);
 266         optimal_layout_width += requisition.width + H_PADDING;
 267         max_btn_height = MAX (max_btn_height, requisition.height);
 268         max_btn_width = MAX (max_btn_width, requisition.width);
 269     }
 270
 271     /* Figure out how many rows and columns we'll use. */
 272     btns_per_row = allocation->width / (max_btn_width + H_PADDING);
 273
 274     /* If all the buttons could fit in the single row, have it so */
 275     if (allocation->width >= optimal_layout_width)
 276     {
 277         btns_per_row = num_btns;
 278     }
 279     if (!icons_only) {
 280         /* If using text buttons, we want to try to have a
 281          * completely filled-in grid, but if we can't, we want
 282          * the odd row to have just a single button.
 283          */
 284         while (num_btns % btns_per_row > 1)
 285             btns_per_row--;
 286     }
 287
 288     rows_count = num_btns / btns_per_row;
 289     if (num_btns % btns_per_row != 0)
 290         rows_count++;
 291
 292     /* Assign buttons to rows */
 293     rows = g_new0 (GSList *, rows_count);
 294
 295     if (!icons_only && num_btns % btns_per_row != 0) {
 296         button = switcher->priv->buttons->data;
 297         rows [0] = g_slist_append (rows [0], button->button_widget);
 298
 299         p = switcher->priv->buttons->next;
 300         row_number = p ? 1 : 0;
 301     } else {
 302         p = switcher->priv->buttons;
 303         row_number = 0;
 304     }
 305
 306     for (; p != NULL; p = p->next) {
 307         button = p->data;
 308
 309         if (g_slist_length (rows [row_number]) == btns_per_row)
 310             row_number ++;
 311
 312         rows [row_number] = g_slist_append (rows [row_number],
 313                                             button->button_widget);
 314     }
 315
 316     row_last = row_number;
 317
 318     /* If there are more than 1 row of buttons, save the current height
 319      * requirement for subsequent size requests.
 320      */
 321     if (row_last > 0)
 322     {
 323         switcher->priv->buttons_height_request =
 324             (row_last + 1) * (max_btn_height + V_PADDING) + 1;
 325     } else { /* Otherwize clear it */
 326         if (last_buttons_height >= 0) {
 327
 328             switcher->priv->buttons_height_request = -1;
 329         }
 330     }
 331
 332     /* If it turns out that we now require smaller height for the buttons
 333      * than it was last time, make a resize request to ensure our
 334      * size requisition is properly communicated to the parent (otherwise
 335      * parent tend to keep assuming the older size).
 336      */
 337     if (last_buttons_height > switcher->priv->buttons_height_request)
 338     {
 339         gtk_widget_queue_resize (GTK_WIDGET (switcher));
 340         return -1;
 341     }
 342
 343     /* Layout the buttons. */
 344     for (i = row_last; i >= 0; i --) {
 345         int len, extra_width;
 346
 347         y -= max_btn_height;
 348
 349         /* Check for possible size over flow (taking into account client
 350          * requisition
 351          */
 352         if (y < (allocation->y + client_requisition.height)) {
 353             /* We have an overflow: Insufficient allocation */
 354             if (last_buttons_height < switcher->priv->buttons_height_request) {
 355                 /* Request for a new resize */
 356                 gtk_widget_queue_resize (GTK_WIDGET (switcher));
 357                 return -1;
 358             }
 359         }
 360         x = H_PADDING + allocation->x;
 361         len = g_slist_length (rows[i]);
 362         if (switcher_style == GDL_SWITCHER_STYLE_TEXT ||
 363             switcher_style == GDL_SWITCHER_STYLE_BOTH)
 364             extra_width = (allocation->width - (len * max_btn_width )
 365                            - (len * H_PADDING)) / len;
 366         else
 367             extra_width = 0;
 368         for (p = rows [i]; p != NULL; p = p->next) {
 369             GtkAllocation child_allocation;
 370
 371             child_allocation.x = x;
 372             child_allocation.y = y;
 373             if (rows_count == 1 && row_number == 0)
 374             {
 375                 GtkRequisition child_requisition;
 376                 gtk_widget_size_request (GTK_WIDGET (p->data),
 377                                          &child_requisition);
 378                 child_allocation.width = child_requisition.width;
 379             }
 380             else
 381             {
 382                 child_allocation.width = max_btn_width + extra_width;
 383             }
 384             child_allocation.height = max_btn_height;
 385
 386             gtk_widget_size_allocate (GTK_WIDGET (p->data), &child_allocation);
 387
 388             x += child_allocation.width + H_PADDING;
 389         }
 390
 391         y -= V_PADDING;
 392     }
 393
 394     for (i = 0; i <= row_last; i ++)
 395         g_slist_free (rows [i]);
 396     g_free (rows);
 397
 398     return y;
 399 }
 400
 401 static void
 402 do_layout (GdlSwitcher *switcher)
 403 {
 404     GtkAllocation *allocation = & GTK_WIDGET (switcher)->allocation;
 405     GtkAllocation child_allocation;
 406     int y;
 407
 408     if (switcher->priv->show) {
 409         y = layout_buttons (switcher);
 410         if (y < 0) /* Layout did not happen and a resize was requested */
 411             return;
 412     }
 413     else
 414         y = allocation->y + allocation->height;
 415
 416     /* Place the parent widget.  */
 417     child_allocation.x = allocation->x;
 418     child_allocation.y = allocation->y;
 419     child_allocation.width = allocation->width;
 420     child_allocation.height = y - allocation->y;
 421
 422     GDL_CALL_PARENT (GTK_WIDGET_CLASS, size_allocate,
 423                      (GTK_WIDGET (switcher), &child_allocation));
 424 }
 425
 426 /* GtkContainer methods.  */
 427
 428 static void
 429 gdl_switcher_forall (GtkContainer *container, gboolean include_internals,
 430                      GtkCallback callback, void *callback_data)
 431 {
 432     GdlSwitcher *switcher =
 433         GDL_SWITCHER (container);
 434     GSList *p;
 435
 436     GDL_CALL_PARENT (GTK_CONTAINER_CLASS, forall,
 437                      (GTK_CONTAINER (switcher), include_internals,
 438                       callback, callback_data));
 439     if (include_internals) {
 440         for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 441             GtkWidget *widget = ((Button *) p->data)->button_widget;
 442             (* callback) (widget, callback_data);
 443         }
 444     }
 445 }
 446
 447 static void
 448 gdl_switcher_remove (GtkContainer *container, GtkWidget *widget)
 449 {
 450     gint switcher_id;
 451     GdlSwitcher *switcher =
 452         GDL_SWITCHER (container);
 453     GSList *p;
 454
 455     switcher_id = gdl_switcher_get_page_id (widget);
 456     for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 457         Button *b = (Button *) p->data;
 458
 459         if (b->id == switcher_id) {
 460             gtk_widget_unparent (b->button_widget);
 461             switcher->priv->buttons =
 462                 g_slist_remove_link (switcher->priv->buttons, p);
 463             button_free (b);
 464             gtk_widget_queue_resize (GTK_WIDGET (switcher));
 465             break;
 466         }
 467     }
 468     GDL_CALL_PARENT (GTK_CONTAINER_CLASS, remove,
 469                      (GTK_CONTAINER (switcher), widget));
 470 }
 471
 472 /* GtkWidget methods.  */
 473
 474 static void
 475 gdl_switcher_size_request (GtkWidget *widget, GtkRequisition *requisition)
 476 {
 477     GdlSwitcher *switcher = GDL_SWITCHER (widget);
 478     GSList *p;
 479     gint button_height = 0;
 480
 481     GDL_CALL_PARENT (GTK_WIDGET_CLASS, size_request,
 482                      (GTK_WIDGET (switcher), requisition));
 483
 484     if (!switcher->priv->show)
 485         return;
 486
 487     for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 488         gint button_width;
 489         Button *button = p->data;
 490         GtkRequisition button_requisition;
 491
 492         gtk_widget_size_request (button->button_widget, &button_requisition);
 493         button_width = button_requisition.width + 2 * H_PADDING;
 494         requisition->width = MAX (requisition->width, button_width);
 495         button_height = MAX (button_height,
 496                              button_requisition.height + 2 * V_PADDING);
 497     }
 498
 499     if (switcher->priv->buttons_height_request > 0) {
 500         requisition->height += switcher->priv->buttons_height_request;
 501     } else {
 502         requisition->height += button_height + V_PADDING;
 503     }
 504 }
 505
 506 static void
 507 gdl_switcher_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 508 {
 509     widget->allocation = *allocation;
 510     do_layout (GDL_SWITCHER (widget));
 511 }
 512
 513 static gint
 514 gdl_switcher_expose (GtkWidget *widget, GdkEventExpose *event)
 515 {
 516     GSList *p;
 517     GdlSwitcher *switcher = GDL_SWITCHER (widget);
 518     if (switcher->priv->show) {
 519         for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 520             GtkWidget *button = ((Button *) p->data)->button_widget;
 521             gtk_container_propagate_expose (GTK_CONTAINER (widget),
 522                                             button, event);
 523         }
 524     }
 525     GDL_CALL_PARENT_WITH_DEFAULT (GTK_WIDGET_CLASS, expose_event,
 526                                   (widget, event), FALSE);
 527 }
 528
 529 static void
 530 gdl_switcher_map (GtkWidget *widget)
 531 {
 532     GSList *p;
 533     GdlSwitcher *switcher = GDL_SWITCHER (widget);
 534
 535     if (switcher->priv->show) {
 536         for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 537             GtkWidget *button = ((Button *) p->data)->button_widget;
 538             gtk_widget_map (button);
 539         }
 540     }
 541     GDL_CALL_PARENT (GTK_WIDGET_CLASS, map, (widget));
 542 }
 543
 544 /* GObject methods.  */
 545
 546 static void
 547 gdl_switcher_set_property  (GObject      *object,
 548                             guint         prop_id,
 549                             const GValue *value,
 550                             GParamSpec   *pspec)
 551 {
 552     GdlSwitcher *switcher = GDL_SWITCHER (object);
 553
 554     switch (prop_id) {
 555         case PROP_SWITCHER_STYLE:
 556             gdl_switcher_set_style (switcher, g_value_get_enum (value));
 557             break;
 558         default:
 559             G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 560             break;
 561     }
 562 }
 563
 564 static void
 565 gdl_switcher_get_property  (GObject      *object,
 566                             guint         prop_id,
 567                             GValue       *value,
 568                             GParamSpec   *pspec)
 569 {
 570     GdlSwitcher *switcher = GDL_SWITCHER (object);
 571
 572     switch (prop_id) {
 573         case PROP_SWITCHER_STYLE:
 574             g_value_set_enum (value, gdl_switcher_get_style (switcher));
 575             break;
 576         default:
 577             G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 578             break;
 579     }
 580 }
 581
 582 static void
 583 gdl_switcher_dispose (GObject *object)
 584 {
 585     GdlSwitcherPrivate *priv = GDL_SWITCHER (object)->priv;
 586
 587 #if HAVE_GNOME
 588     GConfClient *gconf_client = gconf_client_get_default ();
 589
 590     if (priv->style_changed_id) {
 591         gconf_client_notify_remove (gconf_client, priv->style_changed_id);
 592         priv->style_changed_id = 0;
 593     }
 594     g_object_unref (gconf_client);
 595 #endif
 596
 597     g_slist_foreach (priv->buttons, (GFunc) button_free, NULL);
 598     g_slist_free (priv->buttons);
 599     priv->buttons = NULL;
 600
 601     GDL_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
 602 }
 603
 604 static void
 605 gdl_switcher_finalize (GObject *object)
 606 {
 607     GdlSwitcherPrivate *priv = GDL_SWITCHER (object)->priv;
 608
 609     g_free (priv);
 610
 611     GDL_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
 612 }
 613
 614 /* Signal handlers */
 615
 616 static void
 617 gdl_switcher_notify_cb (GObject *g_object, GParamSpec *pspec,
 618                         GdlSwitcher *switcher)
 619 {
 620     gboolean show_tabs;
 621     g_return_if_fail (switcher != NULL && GDL_IS_SWITCHER (switcher));
 622     show_tabs = gtk_notebook_get_show_tabs (GTK_NOTEBOOK (switcher));
 623     gdl_switcher_set_show_buttons (switcher, !show_tabs);
 624 }
 625
 626 static void
 627 gdl_switcher_switch_page_cb (GtkNotebook *nb, GtkNotebookPage *page,
 628                              gint page_num, GdlSwitcher *switcher)
 629 {
 630     GtkWidget       *page_widget;
 631     GtkWidget       *tablabel;
 632     gint             switcher_id;
 633
 634     /* Change switcher button */
 635     page_widget = gtk_notebook_get_nth_page (nb, page_num);
 636     switcher_id = gdl_switcher_get_page_id (page_widget);
 637     gdl_switcher_select_button (GDL_SWITCHER (switcher), switcher_id);
 638 }
 639
 640 static void
 641 gdl_switcher_page_added_cb (GtkNotebook *nb, GtkWidget *page,
 642                             gint page_num, GdlSwitcher *switcher)
 643 {
 644     gint         switcher_id;
 645
 646     switcher_id = gdl_switcher_get_page_id (page);
 647
 648     gdl_switcher_add_button (GDL_SWITCHER (switcher), NULL, NULL, NULL, NULL,
 649                              switcher_id);
 650     gdl_switcher_select_button (GDL_SWITCHER (switcher), switcher_id);
 651 }
 652
 653 static void
 654 gdl_switcher_select_page (GdlSwitcher *switcher, gint id)
 655 {
 656     GList *children, *node;
 657     children = gtk_container_get_children (GTK_CONTAINER (switcher));
 658     node = children;
 659     while (node)
 660     {
 661         gint switcher_id;
 662         switcher_id = gdl_switcher_get_page_id (GTK_WIDGET (node->data));
 663         if (switcher_id == id)
 664         {
 665             gint page_num;
 666             page_num = gtk_notebook_page_num (GTK_NOTEBOOK (switcher),
 667                                               GTK_WIDGET (node->data));
 668             g_signal_handlers_block_by_func (switcher,
 669                                              gdl_switcher_switch_page_cb,
 670                                              switcher);
 671             gtk_notebook_set_current_page (GTK_NOTEBOOK (switcher), page_num);
 672             g_signal_handlers_unblock_by_func (switcher,
 673                                                gdl_switcher_switch_page_cb,
 674                                                switcher);
 675             break;
 676         }
 677         node = g_list_next (node);
 678     }
 679     g_list_free (children);
 680 }
 681
 682 /* Initialization.  */
 683
 684 static void
 685 gdl_switcher_class_init (GdlSwitcherClass *klass)
 686 {
 687     GtkNotebookClass *notebook_class = GTK_NOTEBOOK_CLASS (klass);
 688     GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 689     GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 690     GObjectClass *object_class = G_OBJECT_CLASS (klass);
 691
 692     container_class->forall = gdl_switcher_forall;
 693     container_class->remove = gdl_switcher_remove;
 694
 695     widget_class->size_request = gdl_switcher_size_request;
 696     widget_class->size_allocate = gdl_switcher_size_allocate;
 697     widget_class->expose_event = gdl_switcher_expose;
 698     widget_class->map = gdl_switcher_map;
 699
 700     object_class->dispose  = gdl_switcher_dispose;
 701     object_class->finalize = gdl_switcher_finalize;
 702     object_class->set_property = gdl_switcher_set_property;
 703     object_class->get_property = gdl_switcher_get_property;
 704
 705     g_object_class_install_property (
 706         object_class, PROP_SWITCHER_STYLE,
 707         g_param_spec_enum ("switcher-style", _("Switcher Style"),
 708                            _("Switcher buttons style"),
 709                            GDL_TYPE_SWITCHER_STYLE,
 710                            GDL_SWITCHER_STYLE_BOTH,
 711                            G_PARAM_READWRITE));
 712 }
 713
 714 static void
 715 gdl_switcher_instance_init (GdlSwitcher *switcher)
 716 {
 717     GdlSwitcherPrivate *priv;
 718
 719     GTK_WIDGET_SET_FLAGS (switcher, GTK_NO_WINDOW);
 720
 721     priv = g_new0 (GdlSwitcherPrivate, 1);
 722     switcher->priv = priv;
 723
 724     priv->show = TRUE;
 725     priv->buttons_height_request = -1;
 726
 727     gtk_notebook_set_tab_pos (GTK_NOTEBOOK (switcher), GTK_POS_BOTTOM);
 728     gtk_notebook_set_show_tabs (GTK_NOTEBOOK (switcher), FALSE);
 729     gtk_notebook_set_show_border (GTK_NOTEBOOK (switcher), FALSE);
 730     gdl_switcher_set_style (switcher, GDL_SWITCHER_STYLE_BOTH);
 731
 732     /* notebook signals */
 733     g_signal_connect (switcher, "switch-page",
 734                       G_CALLBACK (gdl_switcher_switch_page_cb), switcher);
 735     g_signal_connect (switcher, "page-added",
 736                       G_CALLBACK (gdl_switcher_page_added_cb), switcher);
 737     g_signal_connect (switcher, "notify::show-tabs",
 738                       G_CALLBACK (gdl_switcher_notify_cb), switcher);
 739 }
 740
 741 GtkWidget *
 742 gdl_switcher_new (void)
 743 {
 744     GdlSwitcher *switcher = g_object_new (gdl_switcher_get_type (), NULL);
 745     return GTK_WIDGET (switcher);
 746 }
 747
 748 void
 749 gdl_switcher_add_button (GdlSwitcher *switcher, const gchar *label,
 750                          const gchar *tooltips, const gchar *stock_id,
 751                          const GdkPixbuf *pixbuf_icon, gint switcher_id)
 752 {
 753     GtkWidget *button_widget;
 754     GtkWidget *hbox;
 755     GtkWidget *icon_widget;
 756     GtkWidget *label_widget;
 757     GtkWidget *arrow;
 758     GtkTooltips *button_tooltips;
 759
 760     button_widget = gtk_toggle_button_new ();
 761     if (switcher->priv->show)
 762         gtk_widget_show (button_widget);
 763     g_signal_connect (button_widget, "toggled",
 764                       G_CALLBACK (button_toggled_callback),
 765                       switcher);
 766     hbox = gtk_hbox_new (FALSE, 3);
 767     gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
 768     gtk_container_add (GTK_CONTAINER (button_widget), hbox);
 769     gtk_widget_show (hbox);
 770
 771     if (stock_id)
 772         icon_widget = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
 773     else if (pixbuf_icon)
 774         icon_widget = gtk_image_new_from_pixbuf (pixbuf_icon);
 775     else
 776         icon_widget = gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_BUTTON);
 777
 778     gtk_widget_show (icon_widget);
 779
 780     if (!label) {
 781         gchar *text = g_strdup_printf ("Item %d", switcher_id);
 782         label_widget = gtk_label_new (text);
 783         g_free (text);
 784     } else {
 785         label_widget = gtk_label_new (label);
 786     }
 787     gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
 788     gtk_widget_show (label_widget);
 789     button_tooltips = gtk_tooltips_new();
 790     gtk_tooltips_set_tip (GTK_TOOLTIPS (button_tooltips), button_widget,
 791                           tooltips, NULL);
 792
 793     switch (INTERNAL_MODE (switcher)) {
 794     case GDL_SWITCHER_STYLE_TEXT:
 795         gtk_box_pack_start (GTK_BOX (hbox), label_widget, TRUE, TRUE, 0);
 796         gtk_tooltips_disable (button_tooltips);
 797         break;
 798     case GDL_SWITCHER_STYLE_ICON:
 799         gtk_box_pack_start (GTK_BOX (hbox), icon_widget, TRUE, TRUE, 0);
 800         gtk_tooltips_enable (button_tooltips);
 801         break;
 802     case GDL_SWITCHER_STYLE_BOTH:
 803     default:
 804         gtk_box_pack_start (GTK_BOX (hbox), icon_widget, FALSE, TRUE, 0);
 805         gtk_box_pack_start (GTK_BOX (hbox), label_widget, TRUE, TRUE, 0);
 806         gtk_tooltips_disable (button_tooltips);
 807         break;
 808     }
 809     arrow = gtk_arrow_new (GTK_ARROW_UP, GTK_SHADOW_NONE);
 810     gtk_widget_show (arrow);
 811     gtk_box_pack_start (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
 812
 813     switcher->priv->buttons =
 814         g_slist_append (switcher->priv->buttons,
 815                         button_new (button_widget, label_widget,
 816                                     icon_widget, button_tooltips,
 817                                     arrow, hbox, switcher_id));
 818     gtk_widget_set_parent (button_widget, GTK_WIDGET (switcher));
 819
 820     gtk_widget_queue_resize (GTK_WIDGET (switcher));
 821 }
 822
 823 static void
 824 gdl_switcher_remove_button (GdlSwitcher *switcher, gint switcher_id)
 825 {
 826     GSList *p;
 827
 828     for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 829         Button *button = p->data;
 830
 831         if (button->id == switcher_id)
 832         {
 833             gtk_container_remove (GTK_CONTAINER (switcher),
 834                                   button->button_widget);
 835             break;
 836         }
 837     }
 838     gtk_widget_queue_resize (GTK_WIDGET (switcher));
 839 }
 840
 841 static void
 842 gdl_switcher_select_button (GdlSwitcher *switcher, gint switcher_id)
 843 {
 844     update_buttons (switcher, switcher_id);
 845
 846     /* Select the notebook page associated with this button */
 847     gdl_switcher_select_page (switcher, switcher_id);
 848 }
 849
 850 gint
 851 gdl_switcher_insert_page (GdlSwitcher *switcher, GtkWidget *page,
 852                           GtkWidget *tab_widget, const gchar *label,
 853                           const gchar *tooltips, const gchar *stock_id,
 854                           const GdkPixbuf *pixbuf_icon, gint position)
 855 {
 856     gint ret_position;
 857     gint switcher_id;
 858     g_signal_handlers_block_by_func (switcher,
 859                                      gdl_switcher_page_added_cb,
 860                                      switcher);
 861
 862     if (!tab_widget) {
 863         tab_widget = gtk_label_new (label);
 864         gtk_widget_show (tab_widget);
 865     }
 866     switcher_id = gdl_switcher_get_page_id (page);
 867     gdl_switcher_add_button (switcher, label, tooltips, stock_id, pixbuf_icon, switcher_id);
 868     ret_position = gtk_notebook_insert_page (GTK_NOTEBOOK (switcher), page,
 869                                              tab_widget, position);
 870     g_signal_handlers_unblock_by_func (switcher,
 871                                        gdl_switcher_page_added_cb,
 872                                        switcher);
 873     return ret_position;
 874 }
 875
 876 static void
 877 set_switcher_style_internal (GdlSwitcher *switcher,
 878                              GdlSwitcherStyle switcher_style )
 879 {
 880     GSList *p;
 881
 882     if (switcher_style == GDL_SWITCHER_STYLE_TABS &&
 883         switcher->priv->show == FALSE)
 884         return;
 885
 886     if (switcher_style == GDL_SWITCHER_STYLE_TABS)
 887     {
 888         gtk_notebook_set_show_tabs (GTK_NOTEBOOK (switcher), TRUE);
 889         return;
 890     }
 891
 892     gtk_notebook_set_show_tabs (GTK_NOTEBOOK (switcher), FALSE);
 893
 894     if (switcher_style == INTERNAL_MODE (switcher))
 895         return;
 896
 897     for (p = switcher->priv->buttons; p != NULL; p = p->next) {
 898         Button *button = p->data;
 899
 900         gtk_container_remove (GTK_CONTAINER (button->hbox), button->arrow);
 901         switch (switcher_style) {
 902         case GDL_SWITCHER_STYLE_TEXT:
 903             gtk_container_remove (GTK_CONTAINER (button->hbox), button->icon);
 904             if (INTERNAL_MODE (switcher)
 905                 == GDL_SWITCHER_STYLE_ICON) {
 906                 gtk_box_pack_start (GTK_BOX (button->hbox), button->label,
 907                                     TRUE, TRUE, 0);
 908                 gtk_widget_show (button->label);
 909                 gtk_tooltips_disable (button->tooltips);
 910             }
 911             break;
 912         case GDL_SWITCHER_STYLE_ICON:
 913             gtk_container_remove(GTK_CONTAINER (button->hbox), button->label);
 914             if (INTERNAL_MODE (switcher)
 915                 == GDL_SWITCHER_STYLE_TEXT) {
 916                 gtk_box_pack_start (GTK_BOX (button->hbox), button->icon,
 917                                     TRUE, TRUE, 0);
 918                 gtk_widget_show (button->icon);
 919             } else
 920                 gtk_container_child_set (GTK_CONTAINER (button->hbox),
 921                                          button->icon, "expand", TRUE, NULL);
 922             gtk_tooltips_enable (button->tooltips);
 923             break;
 924         case GDL_SWITCHER_STYLE_BOTH:
 925             if (INTERNAL_MODE (switcher)
 926                 == GDL_SWITCHER_STYLE_TEXT) {
 927                 gtk_container_remove (GTK_CONTAINER (button->hbox),
 928                                       button->label);
 929                 gtk_box_pack_start (GTK_BOX (button->hbox), button->icon,
 930                                     FALSE, TRUE, 0);
 931                 gtk_widget_show (button->icon);
 932             } else {
 933                 gtk_container_child_set (GTK_CONTAINER (button->hbox),
 934                                          button->icon, "expand", FALSE, NULL);
 935             }
 936
 937             gtk_tooltips_disable (button->tooltips);
 938             gtk_box_pack_start (GTK_BOX (button->hbox), button->label, TRUE,
 939                                 TRUE, 0);
 940             gtk_widget_show (button->label);
 941             break;
 942         default:
 943             break;
 944         }
 945         gtk_box_pack_start (GTK_BOX (button->hbox), button->arrow, FALSE,
 946                             FALSE, 0);
 947     }
 948 }
 949
 950 #if HAVE_GNOME
 951 static GConfEnumStringPair toolbar_styles[] = {
 952     { GDL_SWITCHER_STYLE_TEXT, "text" },
 953     { GDL_SWITCHER_STYLE_ICON, "icons" },
 954     { GDL_SWITCHER_STYLE_BOTH, "both" },
 955     { GDL_SWITCHER_STYLE_BOTH, "both-horiz" },
 956     { GDL_SWITCHER_STYLE_BOTH, "both_horiz" },
 957     { -1, NULL }
 958 };
 959
 960 static void
 961 style_changed_notify (GConfClient *gconf, guint id, GConfEntry *entry,
 962                       void *data)
 963 {
 964     GdlSwitcher *switcher = data;
 965     char *val;
 966     int switcher_style;
 967
 968     val = gconf_client_get_string (gconf,
 969                                    "/desktop/gnome/interface/toolbar_style",
 970                                    NULL);
 971     if (val == NULL || !gconf_string_to_enum (toolbar_styles, val,
 972                                               &switcher_style))
 973         switcher_style = GDL_SWITCHER_STYLE_BOTH;
 974     g_free(val);
 975
 976     set_switcher_style_internal (GDL_SWITCHER (switcher), switcher_style);
 977     switcher->priv->toolbar_style = switcher_style;
 978
 979     gtk_widget_queue_resize (GTK_WIDGET (switcher));
 980 }
 981
 982 static void
 983 gdl_switcher_set_style (GdlSwitcher *switcher, GdlSwitcherStyle switcher_style)
 984 {
 985     GConfClient *gconf_client = gconf_client_get_default ();
 986
 987     if (switcher_style == GDL_SWITCHER_STYLE_TABS &&
 988         switcher->priv->show == FALSE)
 989         return;
 990
 991     if (switcher->priv->switcher_style == switcher_style &&
 992         switcher->priv->show == TRUE)
 993         return;
 994
 995     if (switcher->priv->switcher_style == GDL_SWITCHER_STYLE_TOOLBAR) {
 996         if (switcher->priv->style_changed_id) {
 997             gconf_client_notify_remove (gconf_client,
 998                                 switcher->priv->style_changed_id);
 999             switcher->priv->style_changed_id = 0;
1000         }
1001     }
1002
1003     if (switcher_style != GDL_SWITCHER_STYLE_TOOLBAR) {
1004         set_switcher_style_internal (switcher, switcher_style);
1005
1006         gtk_widget_queue_resize (GTK_WIDGET (switcher));
1007     } else {
1008         /* This is a little bit tricky, toolbar style is more
1009          * of a meta-style where the actual style is dictated by
1010          * the gnome toolbar setting, so that is why we have
1011          * the is_toolbar_style bool - it tracks the toolbar
1012          * style while the switcher_style member is the actual look and
1013          * feel */
1014         switcher->priv->style_changed_id =
1015             gconf_client_notify_add (gconf_client,
1016                                      "/desktop/gnome/interface/toolbar_style",
1017                                      style_changed_notify, switcher,
1018                                      NULL, NULL);
1019         style_changed_notify (gconf_client, 0, NULL, switcher);
1020     }
1021
1022     g_object_unref (gconf_client);
1023
1024     if (switcher_style != GDL_SWITCHER_STYLE_TABS)
1025         switcher->priv->switcher_style = switcher_style;
1026 }
1027
1028 #else /* HAVE_GNOME */
1029
1030 static void
1031 gdl_switcher_set_style (GdlSwitcher *switcher, GdlSwitcherStyle switcher_style)
1032 {
1033     if (switcher_style == GDL_SWITCHER_STYLE_TABS &&
1034         switcher->priv->show == FALSE)
1035         return;
1036
1037     if (switcher->priv->switcher_style == switcher_style &&
1038         switcher->priv->show == TRUE)
1039         return;
1040
1041     set_switcher_style_internal (switcher,
1042                                  ((switcher_style ==
1043                                    GDL_SWITCHER_STYLE_TOOLBAR)?
1044                                   GDL_SWITCHER_STYLE_BOTH : switcher_style));
1045     gtk_widget_queue_resize (GTK_WIDGET (switcher));
1046
1047     if (switcher_style != GDL_SWITCHER_STYLE_TABS)
1048         switcher->priv->switcher_style = switcher_style;
1049 }
1050
1051 #endif /* HAVE_GNOME */
1052
1053 static void
1054 gdl_switcher_set_show_buttons (GdlSwitcher *switcher, gboolean show)
1055 {
1056     GSList *p;
1057
1058     if (switcher->priv->show == show)
1059         return;
1060
1061     for (p = switcher->priv->buttons; p != NULL; p = p->next) {
1062         Button *button = p->data;
1063
1064         if (show)
1065             gtk_widget_show (button->button_widget);
1066         else
1067             gtk_widget_hide (button->button_widget);
1068     }
1069
1070     switcher->priv->show = show;
1071
1072     gtk_widget_queue_resize (GTK_WIDGET (switcher));
1073 }
1074
1075 static GdlSwitcherStyle
1076 gdl_switcher_get_style (GdlSwitcher *switcher)
1077 {
1078     if (!switcher->priv->show)
1079         return GDL_SWITCHER_STYLE_TABS;
1080     return switcher->priv->switcher_style;
1081 }