/*

 * glade-palette.c

 *

 * Copyright (C) 2006 The GNOME Foundation.

 * Copyright (C) 2001-2005 Ximian, Inc.

 *

 * Authors:

 *   Chema Celorio

 *   Joaquin Cuenca Abela <e98cuenc@yahoo.com>

 *   Vincent Geddes <vgeddes@metroweb.co.za>

 *

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

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

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

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

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

 *

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/**

 * SECTION:glade-palette

 * @Short_Description: A widget to select a #GladeWidgetClass for addition.

 *

 * #GladePalette is responsible for displaying the list of available

 * #GladeWidgetClass types and publishing the currently selected class

 * to the Glade core.

 */

#include "glade.h"

#include "gladeui-enum-types.h"

#include "glade-app.h"

#include "glade-palette.h"

#include "glade-catalog.h"

#include "glade-project.h"

#include "glade-widget.h"

#include "glade-widget-adaptor.h"

#include "glade-popup.h"

#include "glade-design-private.h"

#include "glade-dnd.h"

#include <glib/gi18n-lib.h>

#include <gdk/gdk.h>

struct _GladePalettePrivate

{

  const GList *catalogs;        /* List of widget catalogs */

  GladeProject *project;

  GtkWidget *selector_hbox;

  GtkWidget *selector_button;

  GtkWidget *toolpalette;

  GladeItemAppearance item_appearance;

  gboolean            use_small_item_icons;

  GladeWidgetAdaptor *local_selection;

  GHashTable         *button_table;

};

enum

{

  REFRESH,

  LAST_SIGNAL

};

enum

{

  PROP_0,

  PROP_ITEM_APPEARANCE,

  PROP_USE_SMALL_ITEM_ICONS,

  PROP_SHOW_SELECTOR_BUTTON,

  PROP_PROJECT,

  N_PROPERTIES

};

static GParamSpec *properties[N_PROPERTIES];

static guint glade_palette_signals[LAST_SIGNAL] = { 0 };

static void glade_palette_append_item_group (GladePalette        *palette,

                                             GladeWidgetGroup    *group);

static void palette_item_toggled_cb         (GtkToggleToolButton *button, 

					     GladePalette        *palette);

G_DEFINE_TYPE_WITH_PRIVATE (GladePalette, glade_palette, GTK_TYPE_BOX)

/*******************************************************

 *                   Project Signals                   *

 *******************************************************/

static void

palette_item_refresh_cb (GladePalette *palette,

			 GtkWidget    *item)

{

  GladeProject       *project;

  GladeSupportMask    support;

  GladeWidgetAdaptor *adaptor;

  gchar              *warning, *text;

  adaptor = g_object_get_data (G_OBJECT (item), "glade-widget-adaptor");

  g_assert (adaptor);

  if ((project = palette->priv->project) &&

      (warning = glade_project_verify_widget_adaptor (project, adaptor,

						      &support)) != NULL)

    {

      /* set sensitivity */

      gtk_widget_set_sensitive (GTK_WIDGET (item),

                                !(support & GLADE_SUPPORT_MISMATCH));

      gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item),

				     glade_widget_adaptor_get_icon_name (adaptor));

      /* prepend widget title */

      text = g_strdup_printf ("%s: %s", glade_widget_adaptor_get_title (adaptor), warning);

      gtk_widget_set_tooltip_text (item, text);

      g_free (text);

      g_free (warning);

    }

  else

    {

      gtk_widget_set_tooltip_text (GTK_WIDGET (item), 

				   glade_widget_adaptor_get_title (adaptor));

      gtk_widget_set_sensitive (GTK_WIDGET (item), TRUE);

      gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item),

                                     glade_widget_adaptor_get_icon_name (adaptor));

    }

}

static void

glade_palette_refresh (GladePalette *palette)

{

  g_return_if_fail (GLADE_IS_PALETTE (palette));

  g_signal_emit (G_OBJECT (palette), glade_palette_signals[REFRESH], 0);

}

static void

project_add_item_changed_cb (GladeProject *project,

			     GParamSpec   *pspec,

			     GladePalette *palette)

{

  GtkToggleToolButton *selection = NULL;

  GladePalettePrivate *priv = palette->priv;

  if (priv->local_selection)

    {

      selection = g_hash_table_lookup (priv->button_table, 

				       glade_widget_adaptor_get_name (priv->local_selection));

      g_signal_handlers_block_by_func (selection, palette_item_toggled_cb, palette);

      gtk_toggle_tool_button_set_active (selection, FALSE);

      g_signal_handlers_unblock_by_func (selection, palette_item_toggled_cb, palette);

      glade_project_set_pointer_mode (priv->project, GLADE_POINTER_SELECT);

    }

  priv->local_selection = glade_project_get_add_item (priv->project);

  if (priv->local_selection)

    {

      selection = g_hash_table_lookup (priv->button_table, 

				       glade_widget_adaptor_get_name (priv->local_selection));

      g_signal_handlers_block_by_func (selection, palette_item_toggled_cb, palette);

      gtk_toggle_tool_button_set_active (selection, TRUE);

      g_signal_handlers_unblock_by_func (selection, palette_item_toggled_cb, palette);

      glade_project_set_pointer_mode (priv->project, GLADE_POINTER_ADD_WIDGET);

    }

}

/*******************************************************

 *                    Local Signals                    *

 *******************************************************/

static void

selector_button_toggled_cb (GtkToggleButton *button,

			    GladePalette    *palette)

{

  GladePalettePrivate *priv = palette->priv;

  if (!priv->project)

    return;

  if (gtk_toggle_button_get_active (button))

    {

      g_signal_handlers_block_by_func (priv->project, project_add_item_changed_cb, palette);

      glade_project_set_add_item (priv->project, NULL);

      g_signal_handlers_unblock_by_func (priv->project, project_add_item_changed_cb, palette);

    }

  else if (glade_project_get_add_item (priv->project) == NULL)

    gtk_toggle_button_set_active (button, TRUE);

}

static void

palette_item_toggled_cb (GtkToggleToolButton *button, GladePalette *palette)

{

  GladePalettePrivate *priv = palette->priv;

  GladeWidgetAdaptor  *adaptor;

  GtkToggleToolButton *selection = NULL;

  if (!priv->project)

    return;

  adaptor = g_object_get_data (G_OBJECT (button), "glade-widget-adaptor");

  if (!adaptor)

    return;

  /* Start by unselecting the currently selected item if any */

  if (priv->local_selection)

    {

      selection = g_hash_table_lookup (priv->button_table, 

				       glade_widget_adaptor_get_name (priv->local_selection));

      g_signal_handlers_block_by_func (selection, palette_item_toggled_cb, palette);

      gtk_toggle_tool_button_set_active (selection, FALSE);

      g_signal_handlers_unblock_by_func (selection, palette_item_toggled_cb, palette);

      priv->local_selection = NULL;

      g_signal_handlers_block_by_func (priv->project, project_add_item_changed_cb, palette);

      glade_project_set_add_item (priv->project, NULL);

      g_signal_handlers_unblock_by_func (priv->project, project_add_item_changed_cb, palette);

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selector_button), TRUE);

      glade_project_set_pointer_mode (priv->project, GLADE_POINTER_SELECT);

    }

  if (!gtk_toggle_tool_button_get_active (button))

    return;

  /* Auto-create toplevel types */

  if (GWA_IS_TOPLEVEL (adaptor))

    {

      glade_command_create (adaptor, NULL, NULL, priv->project);

      g_signal_handlers_block_by_func (button, palette_item_toggled_cb, palette);

      gtk_toggle_tool_button_set_active (button, FALSE);

      g_signal_handlers_unblock_by_func (button, palette_item_toggled_cb, palette);

    }

  else

    {

      g_signal_handlers_block_by_func (priv->project, project_add_item_changed_cb, palette);

      glade_project_set_add_item (priv->project, adaptor);

      g_signal_handlers_unblock_by_func (priv->project, project_add_item_changed_cb, palette);

      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selector_button), FALSE);

      priv->local_selection = adaptor;

      glade_project_set_pointer_mode (priv->project, GLADE_POINTER_ADD_WIDGET);

    }

}

static void

glade_palette_drag_begin (GtkWidget *widget,

                          GdkDragContext *context,

                          GladeWidgetAdaptor *adaptor)

{

  _glade_dnd_set_icon_widget (context,

                              glade_widget_adaptor_get_icon_name (adaptor),

                              glade_widget_adaptor_get_name (adaptor));

}

static void

glade_palette_drag_data_get (GtkWidget          *widget,

                             GdkDragContext     *context,

                             GtkSelectionData   *data,

                             guint               info,

                             guint               time,

                             GladeWidgetAdaptor *adaptor)

{

  _glade_dnd_set_data (data, G_OBJECT (adaptor));

}

static gint

palette_item_button_press_cb (GtkWidget      *button,

			      GdkEventButton *event, 

			      GtkToolItem    *item)

{

  GladePalette *palette = g_object_get_data (G_OBJECT (item), "glade-palette");

  GladeWidgetAdaptor *adaptor = g_object_get_data (G_OBJECT (item), "glade-widget-adaptor");

  if (glade_popup_is_popup_event (event))

    {

      glade_popup_palette_pop (palette, adaptor, event);

      return TRUE;

    }

  return FALSE;

}

/*******************************************************

 *          Building Widgets/Populating catalog        *

 *******************************************************/

static GtkWidget *

glade_palette_new_item (GladePalette *palette, GladeWidgetAdaptor *adaptor)

{

  GtkWidget *item, *button, *label, *box;

  item = (GtkWidget *) gtk_toggle_tool_button_new ();

  g_object_set_data (G_OBJECT (item), "glade-widget-adaptor", adaptor);

  g_object_set_data (G_OBJECT (item), "glade-palette", palette);

  button = gtk_bin_get_child (GTK_BIN (item));

  g_assert (GTK_IS_BUTTON (button));

  /* Add a box to avoid the ellipsize on the items */

  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

  label = gtk_label_new (glade_widget_adaptor_get_title (adaptor));

  gtk_widget_set_halign (label, GTK_ALIGN_START);

  gtk_widget_show (label);

  gtk_widget_show (box);

  gtk_container_add (GTK_CONTAINER (box), label);

  gtk_tool_button_set_label_widget (GTK_TOOL_BUTTON (item), box);

  palette_item_refresh_cb (palette, item);

  /* Update selection when the item is pushed */

  g_signal_connect (G_OBJECT (item), "toggled",

                    G_CALLBACK (palette_item_toggled_cb), palette);

  /* Update palette item when active project state changes */

  g_signal_connect (G_OBJECT (palette), "refresh",

		    G_CALLBACK (palette_item_refresh_cb), item);

  /* Fire Glade palette popup menus */

  g_signal_connect (G_OBJECT (button), "button-press-event",

                    G_CALLBACK (palette_item_button_press_cb), item);

  g_signal_connect_object (button, "drag-begin",

                           G_CALLBACK (glade_palette_drag_begin), adaptor, 0);

  g_signal_connect_object (button, "drag-data-get",

                           G_CALLBACK (glade_palette_drag_data_get), adaptor, 0);

  gtk_drag_source_set (button, GDK_BUTTON1_MASK, _glade_dnd_get_target (), 1, 0);

  gtk_widget_show (item);

  g_hash_table_insert (palette->priv->button_table, 

		       (gchar *)glade_widget_adaptor_get_name (adaptor),

		       item);

  return item;

}

static GtkWidget *

glade_palette_new_item_group (GladePalette *palette, GladeWidgetGroup *group)

{

  GtkWidget *item_group, *item, *label;

  GList *l;

  /* Give the item group a left aligned label */

  label = gtk_label_new (glade_widget_group_get_title (group));

  gtk_widget_set_halign (label, GTK_ALIGN_START);

  gtk_widget_show (label);

  item_group = gtk_tool_item_group_new ("");

  gtk_tool_item_group_set_label_widget (GTK_TOOL_ITEM_GROUP (item_group),

                                        label);

  /* Tell the item group to ellipsize our custom label for us */

  gtk_tool_item_group_set_ellipsize (GTK_TOOL_ITEM_GROUP (item_group),

                                     PANGO_ELLIPSIZE_END);

  gtk_widget_set_tooltip_text (item_group,

                               glade_widget_group_get_title (group));

  /* Go through all the widget classes in this catalog. */

  for (l = (GList *) glade_widget_group_get_adaptors (group); l; l = l->next)

    {

      GladeWidgetAdaptor *adaptor = GLADE_WIDGET_ADAPTOR (l->data);

      /* Create/append new item */

      item = glade_palette_new_item (palette, adaptor);

      gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (item_group),

                                  GTK_TOOL_ITEM (item), -1);

    }

  /* set default expanded state */

  gtk_tool_item_group_set_collapsed (GTK_TOOL_ITEM_GROUP (item_group),

                                     glade_widget_group_get_expanded (group) == FALSE);

  gtk_widget_show (item_group);

  return item_group;

}

static void

glade_palette_append_item_group (GladePalette *palette, GladeWidgetGroup *group)

{

  GladePalettePrivate *priv = palette->priv;

  GtkWidget *item_group;

  if ((item_group = glade_palette_new_item_group (palette, group)) != NULL)

    gtk_container_add (GTK_CONTAINER (priv->toolpalette), item_group);

}

static void

glade_palette_populate (GladePalette *palette)

{

  GList *l;

  g_return_if_fail (GLADE_IS_PALETTE (palette));

  for (l = (GList *) glade_app_get_catalogs (); l; l = l->next)

    {

      GList *groups = glade_catalog_get_widget_groups (GLADE_CATALOG (l->data));

      for (; groups; groups = groups->next)

        {

          GladeWidgetGroup *group = GLADE_WIDGET_GROUP (groups->data);

          if (glade_widget_group_get_adaptors (group))

            glade_palette_append_item_group (palette, group);

        }

    }

}

static GtkWidget *

glade_palette_create_selector_button (GladePalette *palette)

{

  GtkWidget *selector;

  GtkWidget *image;

  gchar *path;

  /* create selector button */

  selector = gtk_toggle_button_new ();

  gtk_container_set_border_width (GTK_CONTAINER (selector), 0);

  path = g_build_filename (glade_app_get_pixmaps_dir (), "selector.png", NULL);

  image = gtk_image_new_from_file (path);

  gtk_widget_show (image);

  gtk_container_add (GTK_CONTAINER (selector), image);

  gtk_button_set_relief (GTK_BUTTON (selector), GTK_RELIEF_NONE);

  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (selector), TRUE);

  g_signal_connect (G_OBJECT (selector), "toggled",

                    G_CALLBACK (selector_button_toggled_cb), palette);

  g_free (path);

  return selector;

}

/*******************************************************

 *                    Class & methods                  *

 *******************************************************/

/* override GtkWidget::show_all since we have internal widgets we wish to keep

 * hidden unless we decide otherwise, like the hidden selector button.

 */

static void

glade_palette_show_all (GtkWidget *widget)

{

  gtk_widget_show (widget);

}

static void

glade_palette_set_property (GObject      *object,

                            guint         prop_id,

                            const GValue *value,

                            GParamSpec   *pspec)

{

  GladePalette *palette = GLADE_PALETTE (object);

  switch (prop_id)

    {

    case PROP_PROJECT:

      glade_palette_set_project (palette, (GladeProject *)g_value_get_object (value));

      break;

    case PROP_USE_SMALL_ITEM_ICONS:

      glade_palette_set_use_small_item_icons (palette,

					      g_value_get_boolean (value));

      break;

    case PROP_ITEM_APPEARANCE:

      glade_palette_set_item_appearance (palette, g_value_get_enum (value));

      break;

    case PROP_SHOW_SELECTOR_BUTTON:

      glade_palette_set_show_selector_button (palette,

					      g_value_get_boolean (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

glade_palette_get_property (GObject    *object,

                            guint       prop_id,

                            GValue     *value, 

                            GParamSpec *pspec)

{

  GladePalette *palette = GLADE_PALETTE (object);

  GladePalettePrivate *priv = palette->priv;

  switch (prop_id)

    {

    case PROP_PROJECT:

      g_value_set_object (value, priv->project);

      break;

    case PROP_USE_SMALL_ITEM_ICONS:

      g_value_set_boolean (value, priv->use_small_item_icons);

      break;

    case PROP_SHOW_SELECTOR_BUTTON:

      g_value_set_boolean (value,

			   gtk_widget_get_visible (priv->selector_button));

      break;

    case PROP_ITEM_APPEARANCE:

      g_value_set_enum (value, priv->item_appearance);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

glade_palette_dispose (GObject *object)

{

  GladePalettePrivate *priv;

  priv = GLADE_PALETTE (object)->priv;

  priv->catalogs = NULL;

  glade_palette_set_project (GLADE_PALETTE (object), NULL);

  G_OBJECT_CLASS (glade_palette_parent_class)->dispose (object);

}

static void

glade_palette_finalize (GObject *object)

{

  GladePalettePrivate *priv;

  priv = GLADE_PALETTE (object)->priv;

  g_hash_table_destroy (priv->button_table);

  G_OBJECT_CLASS (glade_palette_parent_class)->finalize (object);

}

static void

glade_palette_class_init (GladePaletteClass *klass)

{

  GObjectClass *object_class;

  GtkWidgetClass *widget_class;

  object_class = G_OBJECT_CLASS (klass);

  widget_class = GTK_WIDGET_CLASS (klass);

  object_class->get_property = glade_palette_get_property;

  object_class->set_property = glade_palette_set_property;

  object_class->dispose = glade_palette_dispose;

  object_class->finalize = glade_palette_finalize;

  widget_class->show_all = glade_palette_show_all;

  glade_palette_signals[REFRESH] =

      g_signal_new ("refresh",

                    G_TYPE_FROM_CLASS (object_class),

                    G_SIGNAL_RUN_LAST,

                    G_STRUCT_OFFSET (GladePaletteClass, refresh),

                    NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);

  properties[PROP_PROJECT] =

    g_param_spec_object ("project",

                         "Project",

                         "This palette's current project",

                         GLADE_TYPE_PROJECT,

                         G_PARAM_READWRITE);

  properties[PROP_ITEM_APPEARANCE] =

    g_param_spec_enum ("item-appearance",

                       "Item Appearance",

                       "The appearance of the palette items",

                       GLADE_TYPE_ITEM_APPEARANCE,

                       GLADE_ITEM_ICON_ONLY,

                       G_PARAM_READWRITE);

  properties[PROP_USE_SMALL_ITEM_ICONS] =

    g_param_spec_boolean ("use-small-item-icons",

                          "Use Small Item Icons",

                          "Whether to use small icons to represent items",

                          FALSE,

                          G_PARAM_READWRITE);

  properties[PROP_SHOW_SELECTOR_BUTTON] =

    g_param_spec_boolean ("show-selector-button",

                          "Show Selector Button",

                          "Whether to show the internal selector button",

                          TRUE,

                          G_PARAM_READWRITE);

  /* Install all properties */

  g_object_class_install_properties (object_class, N_PROPERTIES, properties);

}

static void

glade_palette_init (GladePalette *palette)

{

  GladePalettePrivate *priv;

  GtkWidget           *sw;

  gtk_orientable_set_orientation (GTK_ORIENTABLE (palette),

				  GTK_ORIENTATION_VERTICAL);

  priv = palette->priv = glade_palette_get_instance_private (palette);

  priv->button_table = g_hash_table_new (g_str_hash, g_str_equal);

  priv->item_appearance      = GLADE_ITEM_ICON_ONLY;

  priv->use_small_item_icons = FALSE;

  /* create selector button */

  priv->selector_button = glade_palette_create_selector_button (palette);

  priv->selector_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

  gtk_box_pack_start (GTK_BOX (priv->selector_hbox), priv->selector_button,

                      FALSE, FALSE, 0);

  gtk_box_pack_start (GTK_BOX (palette), priv->selector_hbox, FALSE, FALSE, 0);

  gtk_widget_show (priv->selector_button);

  gtk_widget_show (priv->selector_hbox);

  gtk_widget_set_tooltip_text (priv->selector_button, _("Widget selector"));

  /* The GtkToolPalette */

  priv->toolpalette = gtk_tool_palette_new ();

  gtk_tool_palette_set_style (GTK_TOOL_PALETTE (priv->toolpalette),

                              GTK_TOOLBAR_ICONS);

  gtk_tool_palette_set_icon_size (GTK_TOOL_PALETTE (priv->toolpalette),

                                  GTK_ICON_SIZE_LARGE_TOOLBAR);

  sw = gtk_scrolled_window_new (NULL, NULL);

  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),

                                  GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),

                                       GTK_SHADOW_NONE);

  gtk_container_add (GTK_CONTAINER (sw), priv->toolpalette);

  gtk_box_pack_start (GTK_BOX (palette), sw, TRUE, TRUE, 0);

  gtk_widget_show (sw);

  gtk_widget_show (priv->toolpalette);

  gtk_widget_set_no_show_all (GTK_WIDGET (palette), TRUE);

  glade_palette_populate (palette);

}

/*******************************************************

 *                         API                         *

 *******************************************************/

/**

 * glade_palette_new:

 *

 * Creates a new #GladePalette widget

 *

 * Returns: a new #GladePalette

 */

GtkWidget *

glade_palette_new (void)

{

  GladePalette *palette;

  palette = g_object_new (GLADE_TYPE_PALETTE,

                          "spacing", 2,

                          "item-appearance", GLADE_ITEM_ICON_ONLY,

                          NULL);

  return GTK_WIDGET (palette);

}

GladeProject *

glade_palette_get_project (GladePalette *palette)

{

  g_return_val_if_fail (GLADE_IS_PALETTE (palette), NULL);

  return palette->priv->project;

}

void

glade_palette_set_project (GladePalette *palette, GladeProject *project)

{

  g_return_if_fail (GLADE_IS_PALETTE (palette));

  if (palette->priv->project != project)

    {

      if (palette->priv->project)

	{

	  g_signal_handlers_disconnect_by_func (G_OBJECT (palette->priv->project),

						G_CALLBACK (glade_palette_refresh),

						palette);

	  g_signal_handlers_disconnect_by_func (G_OBJECT (palette->priv->project),

						G_CALLBACK (project_add_item_changed_cb),

						palette);

	  g_object_unref (palette->priv->project);

	}

      palette->priv->project = project;

      if (palette->priv->project)

	{

	  g_signal_connect_swapped (G_OBJECT (palette->priv->project), "targets-changed",

				    G_CALLBACK (glade_palette_refresh), palette);

	  g_signal_connect_swapped (G_OBJECT (palette->priv->project), "parse-finished",

				    G_CALLBACK (glade_palette_refresh), palette);

	  g_signal_connect (G_OBJECT (palette->priv->project), "notify::add-item",

			    G_CALLBACK (project_add_item_changed_cb), palette);

	  g_object_ref (palette->priv->project);

	  project_add_item_changed_cb (project, NULL, palette);

	}

      glade_palette_refresh (palette);

      g_object_notify_by_pspec (G_OBJECT (palette), properties[PROP_PROJECT]);

    }

}

/**

 * glade_palette_set_item_appearance:

 * @palette: a #GladePalette

 * @item_appearance: the item appearance

 *

 * Sets the appearance of the palette items.

 */

void

glade_palette_set_item_appearance (GladePalette       *palette,

                                   GladeItemAppearance item_appearance)

{

  GladePalettePrivate *priv;

  g_return_if_fail (GLADE_IS_PALETTE (palette));

  priv = palette->priv;

  if (priv->item_appearance != item_appearance)

    {

      GtkToolbarStyle style;

      priv->item_appearance = item_appearance;

      switch (item_appearance)

        {

          case GLADE_ITEM_ICON_AND_LABEL:

            style = GTK_TOOLBAR_BOTH_HORIZ;

            break;

          case GLADE_ITEM_ICON_ONLY:

            style = GTK_TOOLBAR_ICONS;

            break;

          case GLADE_ITEM_LABEL_ONLY:

            style = GTK_TOOLBAR_TEXT;

            break;

          default:

            g_assert_not_reached ();

            break;

        }

      gtk_tool_palette_set_style (GTK_TOOL_PALETTE (priv->toolpalette), style);

      g_object_notify_by_pspec (G_OBJECT (palette), properties[PROP_ITEM_APPEARANCE]);

    }

}

/**

 * glade_palette_set_use_small_item_icons:

 * @palette: a #GladePalette

 * @use_small_item_icons: Whether to use small item icons

 *

 * Sets whether to use small item icons.

 */

void

glade_palette_set_use_small_item_icons (GladePalette *palette,

                                        gboolean      use_small_item_icons)

{

  GladePalettePrivate *priv;

  g_return_if_fail (GLADE_IS_PALETTE (palette));

  priv = palette->priv;

  if (priv->use_small_item_icons != use_small_item_icons)

    {

      priv->use_small_item_icons = use_small_item_icons;

      gtk_tool_palette_set_icon_size (GTK_TOOL_PALETTE (priv->toolpalette),

                                      (use_small_item_icons) ?

                                        GTK_ICON_SIZE_SMALL_TOOLBAR :

                                        GTK_ICON_SIZE_LARGE_TOOLBAR);

      g_object_notify_by_pspec (G_OBJECT (palette), properties[PROP_USE_SMALL_ITEM_ICONS]);

    }

}

/**

 * glade_palette_set_show_selector_button:

 * @palette: a #GladePalette

 * @show_selector_button: whether to show selector button

 *

 * Sets whether to show the internal widget selector button

 */

void

glade_palette_set_show_selector_button (GladePalette *palette,

                                        gboolean      show_selector_button)

{

  GladePalettePrivate *priv;

  g_return_if_fail (GLADE_IS_PALETTE (palette));

  priv = palette->priv;

  if (gtk_widget_get_visible (priv->selector_hbox) != show_selector_button)

    {

      if (show_selector_button)

        gtk_widget_show (priv->selector_hbox);

      else

        gtk_widget_hide (priv->selector_hbox);

      g_object_notify_by_pspec (G_OBJECT (palette), properties[PROP_SHOW_SELECTOR_BUTTON]);

    }

}

/**

 * glade_palette_get_item_appearance:

 * @palette: a #GladePalette

 *

 * Returns: The appearance of the palette items

 */

GladeItemAppearance

glade_palette_get_item_appearance (GladePalette *palette)

{;

  g_return_val_if_fail (GLADE_IS_PALETTE (palette), GLADE_ITEM_ICON_ONLY);

  return palette->priv->item_appearance;

}

/**

 * glade_palette_get_use_small_item_icons:

 * @palette: a #GladePalette

 *

 * Returns: Whether small item icons are used

 */

gboolean

glade_palette_get_use_small_item_icons (GladePalette *palette)

{

  g_return_val_if_fail (GLADE_IS_PALETTE (palette), FALSE);

  return palette->priv->use_small_item_icons;

}

/**

 * glade_palette_get_show_selector_button:

 * @palette: a #GladePalette

 *

 * Returns: Whether the selector button is visible

 */

gboolean

glade_palette_get_show_selector_button (GladePalette *palette)

{

  g_return_val_if_fail (GLADE_IS_PALETTE (palette), FALSE);

  return gtk_widget_get_visible (palette->priv->selector_hbox);