/* GtkToolPalette -- A tool palette with categories and DnD support

 * Copyright (C) 2008  Openismus GmbH

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *

 * Authors:

 *      Mathias Hasselmann

 */

#include "config.h"

#include <string.h>

#include <gtk/gtk.h>

#include "gtktoolpaletteprivate.h"

#include "gtkmarshalers.h"

#include "gtkprivate.h"

#include "gtkintl.h"

#include "gtkalias.h"

#define DEFAULT_ICON_SIZE       GTK_ICON_SIZE_SMALL_TOOLBAR

#define DEFAULT_ORIENTATION     GTK_ORIENTATION_VERTICAL

#define DEFAULT_TOOLBAR_STYLE   GTK_TOOLBAR_ICONS

#define DEFAULT_CHILD_EXCLUSIVE FALSE

#define DEFAULT_CHILD_EXPAND    FALSE

/**

 * SECTION:gtktoolpalette

 * @Short_description: A tool palette with categories

 * @Title: GtkToolPalette

 *

 * A #GtkToolPalette allows you to add #GtkToolItems to a palette-like

 * container with different categories and drag and drop support.

 *

 * A #GtkToolPalette is created with a call to gtk_tool_palette_new().

 *

 * #GtkToolItems cannot be added directly to a #GtkToolPalette - 

 * instead they are added to a #GtkToolItemGroup which can than be added

 * to a #GtkToolPalette. To add a #GtkToolItemGroup to a #GtkToolPalette,

 * use gtk_container_add().

 *

 * |[

 * GtkWidget *palette, *group;

 * GtkToolItem *item;

 *

 * palette = gtk_tool_palette_new ();

 * group = gtk_tool_item_group_new (_("Test Category"));

 * gtk_container_add (GTK_CONTAINER (palette), group);

 *

 * item = gtk_tool_button_new_from_stock (GTK_STOCK_OK);

 * gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);

 * ]|

 *

 * The easiest way to use drag and drop with #GtkToolPalette is to call

 * gtk_tool_palette_add_drag_dest() with the desired drag source @palette

 * and the desired drag target @widget. Then gtk_tool_palette_get_drag_item()

 * can be used to get the dragged item in the #GtkWidget::drag-data-received

 * signal handler of the drag target.

 *

 * |[

 * static void

 * passive_canvas_drag_data_received (GtkWidget        *widget,

 *                                    GdkDragContext   *context,

 *                                    gint              x,

 *                                    gint              y,

 *                                    GtkSelectionData *selection,

 *                                    guint             info,

 *                                    guint             time,

 *                                    gpointer          data)

 * {

 *   GtkWidget *palette;

 *   GtkWidget *item;

 *

 *   /* Get the dragged item */

 *   palette = gtk_widget_get_ancestor (gtk_drag_get_source_widget (context),

 *                                      GTK_TYPE_TOOL_PALETTE);

 *   if (palette != NULL)

 *     item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (palette),

 *                                            selection);

 *

 *   /* Do something with item */

 * }

 *

 * GtkWidget *target, palette;

 *

 * palette = gtk_tool_palette_new ();

 * target = gtk_drawing_area_new ();

 *

 * g_signal_connect (G_OBJECT (target), "drag-data-received",

 *                   G_CALLBACK (passive_canvas_drag_data_received), NULL);

 * gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette), target,

 *                                 GTK_DEST_DEFAULT_ALL,

 *                                 GTK_TOOL_PALETTE_DRAG_ITEMS,

 *                                 GDK_ACTION_COPY);

 * ]|

 *

 * Since: 2.20

 */

typedef struct _GtkToolItemGroupInfo   GtkToolItemGroupInfo;

typedef struct _GtkToolPaletteDragData GtkToolPaletteDragData;

enum

{

  PROP_NONE,

  PROP_ICON_SIZE,

  PROP_ICON_SIZE_SET,

  PROP_ORIENTATION,

  PROP_TOOLBAR_STYLE,

};

enum

{

  CHILD_PROP_NONE,

  CHILD_PROP_EXCLUSIVE,

  CHILD_PROP_EXPAND,

};

struct _GtkToolItemGroupInfo

{

  GtkToolItemGroup *widget;

  guint             notify_collapsed;

  guint             pos;

  guint             exclusive : 1;

  guint             expand : 1;

};

struct _GtkToolPalettePrivate

{

  GPtrArray* groups;

  GtkAdjustment        *hadjustment;

  GtkAdjustment        *vadjustment;

  GtkIconSize           icon_size;

  gboolean              icon_size_set;

  GtkOrientation        orientation;

  GtkToolbarStyle       style;

  gboolean              style_set;

  GtkWidget            *expanding_child;

  GtkSizeGroup         *text_size_group;

  GtkSettings       *settings;

  gulong             settings_connection;

  guint                 drag_source : 2;

};

struct _GtkToolPaletteDragData

{

  GtkToolPalette *palette;

  GtkWidget      *item;

};

static GdkAtom dnd_target_atom_item = GDK_NONE;

static GdkAtom dnd_target_atom_group = GDK_NONE;

static const GtkTargetEntry dnd_targets[] =

{

  { "application/x-gtk-tool-palette-item", GTK_TARGET_SAME_APP, 0 },

  { "application/x-gtk-tool-palette-group", GTK_TARGET_SAME_APP, 0 },

};

G_DEFINE_TYPE_WITH_CODE (GtkToolPalette,

               gtk_tool_palette,

               GTK_TYPE_CONTAINER,

               G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));

static void

gtk_tool_palette_init (GtkToolPalette *palette)

{

  palette->priv = G_TYPE_INSTANCE_GET_PRIVATE (palette,

                                               GTK_TYPE_TOOL_PALETTE,

                                               GtkToolPalettePrivate);

  palette->priv->groups = g_ptr_array_sized_new (4);

  g_ptr_array_set_free_func (palette->priv->groups, g_free);

  palette->priv->icon_size = DEFAULT_ICON_SIZE;

  palette->priv->icon_size_set = FALSE;

  palette->priv->orientation = DEFAULT_ORIENTATION;

  palette->priv->style = DEFAULT_TOOLBAR_STYLE;

  palette->priv->style_set = FALSE;

  palette->priv->text_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);

}

static void

gtk_tool_palette_reconfigured (GtkToolPalette *palette)

{

  guint i;

  for (i = 0; i < palette->priv->groups->len; ++i)

    {

      GtkToolItemGroupInfo *info = g_ptr_array_index (palette->priv->groups, i);

      if (info->widget)

        _gtk_tool_item_group_palette_reconfigured (info->widget);

    }

  gtk_widget_queue_resize_no_redraw (GTK_WIDGET (palette));

}

static void

gtk_tool_palette_set_property (GObject      *object,

                               guint         prop_id,

                               const GValue *value,

                               GParamSpec   *pspec)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (object);

  switch (prop_id)

    {

      case PROP_ICON_SIZE:

        if ((guint) g_value_get_enum (value) != palette->priv->icon_size)

          {

            palette->priv->icon_size = g_value_get_enum (value);

            gtk_tool_palette_reconfigured (palette);

          }

        break;

      case PROP_ICON_SIZE_SET:

        if ((guint) g_value_get_enum (value) != palette->priv->icon_size)

          {

            palette->priv->icon_size_set = g_value_get_enum (value);

            gtk_tool_palette_reconfigured (palette);

          }

        break;

      case PROP_ORIENTATION:

        if ((guint) g_value_get_enum (value) != palette->priv->orientation)

          {

            palette->priv->orientation = g_value_get_enum (value);

            gtk_tool_palette_reconfigured (palette);

          }

        break;

      case PROP_TOOLBAR_STYLE:

        if ((guint) g_value_get_enum (value) != palette->priv->style)

          {

            palette->priv->style = g_value_get_enum (value);

            gtk_tool_palette_reconfigured (palette);

          }

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

gtk_tool_palette_get_property (GObject    *object,

                               guint       prop_id,

                               GValue     *value,

                               GParamSpec *pspec)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (object);

  switch (prop_id)

    {

      case PROP_ICON_SIZE:

        g_value_set_enum (value, gtk_tool_palette_get_icon_size (palette));

        break;

      case PROP_ICON_SIZE_SET:

        g_value_set_boolean (value, palette->priv->icon_size_set);

        break;

      case PROP_ORIENTATION:

        g_value_set_enum (value, palette->priv->orientation);

        break;

      case PROP_TOOLBAR_STYLE:

        g_value_set_enum (value, gtk_tool_palette_get_style (palette));

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

gtk_tool_palette_dispose (GObject *object)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (object);

  guint i;

  if (palette->priv->hadjustment)

    {

      g_object_unref (palette->priv->hadjustment);

      palette->priv->hadjustment = NULL;

    }

  if (palette->priv->vadjustment)

    {

      g_object_unref (palette->priv->vadjustment);

      palette->priv->vadjustment = NULL;

    }

  for (i = 0; i < palette->priv->groups->len; ++i)

    {

      GtkToolItemGroupInfo *group = g_ptr_array_index (palette->priv->groups, i);

      if (group->notify_collapsed)

        {

          g_signal_handler_disconnect (group->widget, group->notify_collapsed);

          group->notify_collapsed = 0;

        }

    }

  if (palette->priv->text_size_group)

    {

      g_object_unref (palette->priv->text_size_group);

      palette->priv->text_size_group = NULL;

    }

  G_OBJECT_CLASS (gtk_tool_palette_parent_class)->dispose (object);

}

static void

gtk_tool_palette_finalize (GObject *object)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (object);

  g_ptr_array_free (palette->priv->groups, TRUE);

  G_OBJECT_CLASS (gtk_tool_palette_parent_class)->finalize (object);

}

static void

gtk_tool_palette_size_request (GtkWidget      *widget,

                               GtkRequisition *requisition)

{

  const gint border_width = GTK_CONTAINER (widget)->border_width;

  GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);

  GtkRequisition child_requisition;

  guint i;

  requisition->width = 0;

  requisition->height = 0;

  for (i = 0; i < palette->priv->groups->len; ++i)

    {

      GtkToolItemGroupInfo *group = g_ptr_array_index (palette->priv->groups, i);

      if (!group->widget)

        continue;

      gtk_widget_size_request (GTK_WIDGET (group->widget), &child_requisition);

      if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

        {

          requisition->width = MAX (requisition->width, child_requisition.width);

          requisition->height += child_requisition.height;

        }

      else

        {

          requisition->width += child_requisition.width;

          requisition->height = MAX (requisition->height, child_requisition.height);

        }

    }

  requisition->width += border_width * 2;

  requisition->height += border_width * 2;

}

static void

gtk_tool_palette_size_allocate (GtkWidget     *widget,

                                GtkAllocation *allocation)

{

  const gint border_width = GTK_CONTAINER (widget)->border_width;

  GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);

  GtkAdjustment *adjustment = NULL;

  GtkAllocation child_allocation;

  gint n_expand_groups = 0;

  gint remaining_space = 0;

  gint expand_space = 0;

  gint page_start, page_size = 0;

  gint offset = 0;

  guint i;

  gint min_offset = -1, max_offset = -1;

  gint x;

  gint *group_sizes = g_newa (gint, palette->priv->groups->len);

  GtkTextDirection direction = gtk_widget_get_direction (widget);

  GTK_WIDGET_CLASS (gtk_tool_palette_parent_class)->size_allocate (widget, allocation);

  if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

    {

      adjustment = palette->priv->vadjustment;

      page_size = allocation->height;

    }

  else

    {

      adjustment = palette->priv->hadjustment;

      page_size = allocation->width;

    }

  if (adjustment)

    offset = gtk_adjustment_get_value (adjustment);

  if (GTK_ORIENTATION_HORIZONTAL == palette->priv->orientation &&

      GTK_TEXT_DIR_RTL == direction)

    offset = -offset;

  if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

    child_allocation.width = allocation->width - border_width * 2;

  else

    child_allocation.height = allocation->height - border_width * 2;

  if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

    remaining_space = allocation->height;

  else

    remaining_space = allocation->width;

  /* figure out the required size of all groups to be able to distribute the

   * remaining space on allocation

   */

  for (i = 0; i < palette->priv->groups->len; ++i)

    {

      GtkToolItemGroupInfo *group = g_ptr_array_index (palette->priv->groups, i);

      gint size;

      if (!group->widget)

        continue;

      widget = GTK_WIDGET (group->widget);

      if (gtk_tool_item_group_get_n_items (group->widget))

        {

          if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

            size = _gtk_tool_item_group_get_height_for_width (group->widget, child_allocation.width);

          else

            size = _gtk_tool_item_group_get_width_for_height (group->widget, child_allocation.height);

          if (group->expand && !gtk_tool_item_group_get_collapsed (group->widget))

            n_expand_groups += 1;

        }

      else

        size = 0;

      remaining_space -= size;

      group_sizes[i] = size;

      /* if the widget is currently expanding an offset which allows to

       * display as much of the widget as possible is calculated

       */

      if (widget == palette->priv->expanding_child)

        {

          gint limit =

            GTK_ORIENTATION_VERTICAL == palette->priv->orientation ?

            child_allocation.width : child_allocation.height;

          gint real_size;

          guint j;

          min_offset = 0;

          for (j = 0; j < i; ++j)

            min_offset += group_sizes[j];

          max_offset = min_offset + group_sizes[i];

          real_size = _gtk_tool_item_group_get_size_for_limit

            (GTK_TOOL_ITEM_GROUP (widget), limit,

             GTK_ORIENTATION_VERTICAL == palette->priv->orientation,

             FALSE);

          if (size == real_size)

            palette->priv->expanding_child = NULL;

        }

    }

  if (n_expand_groups > 0)

    {

      remaining_space = MAX (0, remaining_space);

      expand_space = remaining_space / n_expand_groups;

    }

  if (max_offset != -1)

    {

      gint limit =

        GTK_ORIENTATION_VERTICAL == palette->priv->orientation ?

        allocation->height : allocation->width;

      offset = MIN (MAX (offset, max_offset - limit), min_offset);

    }

  if (remaining_space > 0)

    offset = 0;

  x = border_width;

  child_allocation.y = border_width;

  if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

    child_allocation.y -= offset;

  else

    x -= offset;

  /* allocate all groups at the calculated positions */

  for (i = 0; i < palette->priv->groups->len; ++i)

    {

      GtkToolItemGroupInfo *group = g_ptr_array_index (palette->priv->groups, i);

      GtkWidget *widget;

      if (!group->widget)

        continue;

      widget = GTK_WIDGET (group->widget);

      if (gtk_tool_item_group_get_n_items (group->widget))

        {

          gint size = group_sizes[i];

          if (group->expand && !gtk_tool_item_group_get_collapsed (group->widget))

            {

              size += MIN (expand_space, remaining_space);

              remaining_space -= expand_space;

            }

          if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

            child_allocation.height = size;

          else

            child_allocation.width = size;

          if (GTK_ORIENTATION_HORIZONTAL == palette->priv->orientation &&

              GTK_TEXT_DIR_RTL == direction)

            child_allocation.x = allocation->width - x - child_allocation.width;

          else

            child_allocation.x = x;

          gtk_widget_size_allocate (widget, &child_allocation);

          gtk_widget_show (widget);

          if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

            child_allocation.y += child_allocation.height;

          else

            x += child_allocation.width;

        }

      else

        gtk_widget_hide (widget);

    }

  if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)

    {

      child_allocation.y += border_width;

      child_allocation.y += offset;

      page_start = child_allocation.y;

    }

  else

    {

      x += border_width;

      x += offset;

      page_start = x;

    }

  /* update the scrollbar to match the displayed adjustment */

  if (adjustment)

    {

      gdouble value;

      adjustment->page_increment = page_size * 0.9;

      adjustment->step_increment = page_size * 0.1;

      adjustment->page_size = page_size;

      if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation ||

          GTK_TEXT_DIR_LTR == direction)

        {

          adjustment->lower = 0;

          adjustment->upper = MAX (0, page_start);

          value = MIN (offset, adjustment->upper - adjustment->page_size);

          gtk_adjustment_clamp_page (adjustment, value, offset + page_size);

        }

      else

        {

          adjustment->lower = page_size - MAX (0, page_start);

          adjustment->upper = page_size;

          offset = -offset;

          value = MAX (offset, adjustment->lower);

          gtk_adjustment_clamp_page (adjustment, offset, value + page_size);

        }

      gtk_adjustment_changed (adjustment);

    }

}

static gboolean

gtk_tool_palette_expose_event (GtkWidget      *widget,

                               GdkEventExpose *event)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);

  GdkDisplay *display;

  cairo_t *cr;

  guint i;

  display = gdk_window_get_display (widget->window);

  if (!gdk_display_supports_composite (display))

    return FALSE;

  cr = gdk_cairo_create (widget->window);

  gdk_cairo_region (cr, event->region);

  cairo_clip (cr);

  cairo_push_group (cr);

  for (i = 0; i < palette->priv->groups->len; ++i)

  {

    GtkToolItemGroupInfo *info = g_ptr_array_index (palette->priv->groups, i);

    if (info->widget)

      _gtk_tool_item_group_paint (info->widget, cr);

  }

  cairo_pop_group_to_source (cr);

  cairo_paint (cr);

  cairo_destroy (cr);

  return FALSE;

}

static void

gtk_tool_palette_realize (GtkWidget *widget)

{

  const gint border_width = GTK_CONTAINER (widget)->border_width;

  gint attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

  GdkWindowAttr attributes;

  attributes.window_type = GDK_WINDOW_CHILD;

  attributes.x = widget->allocation.x + border_width;

  attributes.y = widget->allocation.y + border_width;

  attributes.width = widget->allocation.width - border_width * 2;

  attributes.height = widget->allocation.height - border_width * 2;

  attributes.wclass = GDK_INPUT_OUTPUT;

  attributes.visual = gtk_widget_get_visual (widget);

  attributes.colormap = gtk_widget_get_colormap (widget);

  attributes.event_mask = gtk_widget_get_events (widget)

                         | GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK

                         | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK

                         | GDK_BUTTON_MOTION_MASK;

  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),

                                   &attributes, attributes_mask);

  gdk_window_set_user_data (widget->window, widget);

  widget->style = gtk_style_attach (widget->style, widget->window);

  gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);

  gtk_widget_set_realized (widget, TRUE);

  gtk_container_forall (GTK_CONTAINER (widget),

                        (GtkCallback) gtk_widget_set_parent_window,

                        widget->window);

  gtk_widget_queue_resize_no_redraw (widget);

}

static void

gtk_tool_palette_adjustment_value_changed (GtkAdjustment *adjustment,

                                           gpointer       data)

{

  GtkWidget *widget = GTK_WIDGET (data);

  gtk_tool_palette_size_allocate (widget, &widget->allocation);

}

static void

gtk_tool_palette_set_scroll_adjustments (GtkWidget     *widget,

                                         GtkAdjustment *hadjustment,

                                         GtkAdjustment *vadjustment)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);

  if (hadjustment)

    g_object_ref_sink (hadjustment);

  if (vadjustment)

    g_object_ref_sink (vadjustment);

  if (palette->priv->hadjustment)

    g_object_unref (palette->priv->hadjustment);

  if (palette->priv->vadjustment)

    g_object_unref (palette->priv->vadjustment);

  palette->priv->hadjustment = hadjustment;

  palette->priv->vadjustment = vadjustment;

  if (palette->priv->hadjustment)

    g_signal_connect (palette->priv->hadjustment, "value-changed",

                      G_CALLBACK (gtk_tool_palette_adjustment_value_changed),

                      palette);

  if (palette->priv->vadjustment)

    g_signal_connect (palette->priv->vadjustment, "value-changed",

                      G_CALLBACK (gtk_tool_palette_adjustment_value_changed),

                      palette);

}

static void

gtk_tool_palette_add (GtkContainer *container,

                      GtkWidget    *child)

{

  GtkToolPalette *palette;

  GtkToolItemGroupInfo *info = g_new0(GtkToolItemGroupInfo, 1);

  g_return_if_fail (GTK_IS_TOOL_PALETTE (container));

  g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (child));

  palette = GTK_TOOL_PALETTE (container);

  g_ptr_array_add (palette->priv->groups, info);

  info->pos = palette->priv->groups->len - 1;

  info->widget = g_object_ref_sink (child);

  gtk_widget_set_parent (child, GTK_WIDGET (palette));

}

static void

gtk_tool_palette_remove (GtkContainer *container,

                         GtkWidget    *child)

{

  GtkToolPalette *palette;

  guint i;

  g_return_if_fail (GTK_IS_TOOL_PALETTE (container));

  palette = GTK_TOOL_PALETTE (container);

  for (i = 0; i < palette->priv->groups->len; ++i)

    {

      GtkToolItemGroupInfo *info = g_ptr_array_index (palette->priv->groups, i);

      if (GTK_WIDGET(info->widget) == child)

        {

          g_object_unref (child);

          gtk_widget_unparent (child);

          g_ptr_array_remove_index (palette->priv->groups, i);

        }

    }

}

static void

gtk_tool_palette_forall (GtkContainer *container,

                         gboolean      internals,

                         GtkCallback   callback,

                         gpointer      callback_data)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (container);

  guint i;

  for (i = 0; i < palette->priv->groups->len; ++i)

    {

      GtkToolItemGroupInfo *info = g_ptr_array_index (palette->priv->groups, i);

      if (info->widget)

        callback (GTK_WIDGET (info->widget),

                  callback_data);

    }

}

static GType

gtk_tool_palette_child_type (GtkContainer *container)

{

  return GTK_TYPE_TOOL_ITEM_GROUP;

}

static void

gtk_tool_palette_set_child_property (GtkContainer *container,

                                     GtkWidget    *child,

                                     guint         prop_id,

                                     const GValue *value,

                                     GParamSpec   *pspec)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (container);

  switch (prop_id)

    {

      case CHILD_PROP_EXCLUSIVE:

        gtk_tool_palette_set_exclusive (palette, GTK_TOOL_ITEM_GROUP (child), 

          g_value_get_boolean (value));

        break;

      case CHILD_PROP_EXPAND:

        gtk_tool_palette_set_expand (palette, GTK_TOOL_ITEM_GROUP (child), 

          g_value_get_boolean (value));

        break;

      default:

        GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, prop_id, pspec);

        break;

    }

}

static void

gtk_tool_palette_get_child_property (GtkContainer *container,

                                     GtkWidget    *child,

                                     guint         prop_id,

                                     GValue       *value,

                                     GParamSpec   *pspec)

{

  GtkToolPalette *palette = GTK_TOOL_PALETTE (container);

  switch (prop_id)

    {

      case CHILD_PROP_EXCLUSIVE:

        g_value_set_boolean (value, 

          gtk_tool_palette_get_exclusive (palette, GTK_TOOL_ITEM_GROUP (child)));

        break;

      case CHILD_PROP_EXPAND:

        g_value_set_boolean (value, 

          gtk_tool_palette_get_expand (palette, GTK_TOOL_ITEM_GROUP (child)));

        break;

      default:

        GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, prop_id, pspec);

        break;

    }

}

static void

style_change_notify (GtkToolPalette *palette)

{

  GtkToolPalettePrivate* priv = palette->priv;

  if (!priv->style_set)

    {

      /* pretend it was set, then unset, thus reverting to new default */

      priv->style_set = TRUE;

      gtk_tool_palette_unset_style (palette);

    }

}

static void

icon_size_change_notify (GtkToolPalette *palette)

{

  GtkToolPalettePrivate* priv = palette->priv;

  if (!priv->icon_size_set)

    {

      /* pretend it was set, then unset, thus reverting to new default */

      priv->icon_size_set = TRUE;

      gtk_tool_palette_unset_icon_size (palette);

    }

}

static void

gtk_tool_palette_settings_change_notify (GtkSettings      *settings,

                                         const GParamSpec *pspec,

                                         GtkToolPalette   *palette)

{

  if (strcmp (pspec->name, "gtk-toolbar-style") == 0)

    style_change_notify (palette);

  else if (strcmp (pspec->name, "gtk-toolbar-icon-size") == 0)

    icon_size_change_notify (palette);

}