/* GTK - The GIMP Toolkit

 * Copyright (C) 2000 Red Hat, Inc.

 *               2008 Johan Dahlin

 * 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 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.

 */

#include "config.h"

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include "gtkiconfactory.h"

#include "gtkiconcache.h"

#include "gtkdebug.h"

#include "gtkicontheme.h"

#include "gtksettings.h"

#include "gtkstock.h"

#include "gtkwidget.h"

#include "gtkintl.h"

#include "gtkbuildable.h"

#include "gtkbuilderprivate.h"

#include "gtkalias.h"

static GSList *all_icon_factories = NULL;

typedef enum {

  GTK_ICON_SOURCE_EMPTY,

  GTK_ICON_SOURCE_ICON_NAME,

  GTK_ICON_SOURCE_STATIC_ICON_NAME,

  GTK_ICON_SOURCE_FILENAME,

  GTK_ICON_SOURCE_PIXBUF

} GtkIconSourceType;

struct _GtkIconSource

{

  GtkIconSourceType type;

  union {

    gchar *icon_name;

    gchar *filename;

    GdkPixbuf *pixbuf;

  } source;

  GdkPixbuf *filename_pixbuf;

  GtkTextDirection direction;

  GtkStateType state;

  GtkIconSize size;

  /* If TRUE, then the parameter is wildcarded, and the above

   * fields should be ignored. If FALSE, the parameter is

   * specified, and the above fields should be valid.

   */

  guint any_direction : 1;

  guint any_state : 1;

  guint any_size : 1;

#if defined (G_OS_WIN32) && !defined (_WIN64)

  /* System codepage version of filename, for DLL ABI backward

   * compatibility functions.

   */

  gchar *cp_filename;

#endif

};

static void

gtk_icon_factory_buildable_init  (GtkBuildableIface      *iface);

static gboolean gtk_icon_factory_buildable_custom_tag_start (GtkBuildable     *buildable,

							     GtkBuilder       *builder,

							     GObject          *child,

							     const gchar      *tagname,

							     GMarkupParser    *parser,

							     gpointer         *data);

static void gtk_icon_factory_buildable_custom_tag_end (GtkBuildable *buildable,

						       GtkBuilder   *builder,

						       GObject      *child,

						       const gchar  *tagname,

						       gpointer     *user_data);

static void gtk_icon_factory_finalize   (GObject             *object);

static void get_default_icons           (GtkIconFactory      *icon_factory);

static void icon_source_clear           (GtkIconSource       *source);

static GtkIconSize icon_size_register_intern (const gchar *name,

					      gint         width,

					      gint         height);

#define GTK_ICON_SOURCE_INIT(any_direction, any_state, any_size)	\

  { GTK_ICON_SOURCE_EMPTY, { NULL }, NULL,				\

   0, 0, 0,								\

   any_direction, any_state, any_size }

G_DEFINE_TYPE_WITH_CODE (GtkIconFactory, gtk_icon_factory, G_TYPE_OBJECT,

			 G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,

						gtk_icon_factory_buildable_init))

static void

gtk_icon_factory_init (GtkIconFactory *factory)

{

  factory->icons = g_hash_table_new (g_str_hash, g_str_equal);

  all_icon_factories = g_slist_prepend (all_icon_factories, factory);

}

static void

gtk_icon_factory_class_init (GtkIconFactoryClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->finalize = gtk_icon_factory_finalize;

}

static void

gtk_icon_factory_buildable_init (GtkBuildableIface *iface)

{

  iface->custom_tag_start = gtk_icon_factory_buildable_custom_tag_start;

  iface->custom_tag_end = gtk_icon_factory_buildable_custom_tag_end;

}

static void

free_icon_set (gpointer key, gpointer value, gpointer data)

{

  g_free (key);

  gtk_icon_set_unref (value);

}

static void

gtk_icon_factory_finalize (GObject *object)

{

  GtkIconFactory *factory = GTK_ICON_FACTORY (object);

  all_icon_factories = g_slist_remove (all_icon_factories, factory);

  g_hash_table_foreach (factory->icons, free_icon_set, NULL);

  g_hash_table_destroy (factory->icons);

  G_OBJECT_CLASS (gtk_icon_factory_parent_class)->finalize (object);

}

/**

 * gtk_icon_factory_new:

 *

 * Creates a new #GtkIconFactory. An icon factory manages a collection

 * of #GtkIconSets; a #GtkIconSet manages a set of variants of a

 * particular icon (i.e. a #GtkIconSet contains variants for different

 * sizes and widget states). Icons in an icon factory are named by a

 * stock ID, which is a simple string identifying the icon. Each

 * #GtkStyle has a list of #GtkIconFactorys derived from the current

 * theme; those icon factories are consulted first when searching for

 * an icon. If the theme doesn't set a particular icon, GTK+ looks for

 * the icon in a list of default icon factories, maintained by

 * gtk_icon_factory_add_default() and

 * gtk_icon_factory_remove_default(). Applications with icons should

 * add a default icon factory with their icons, which will allow

 * themes to override the icons for the application.

 *

 * Return value: a new #GtkIconFactory

 */

GtkIconFactory*

gtk_icon_factory_new (void)

{

  return g_object_new (GTK_TYPE_ICON_FACTORY, NULL);

}

/**

 * gtk_icon_factory_add:

 * @factory: a #GtkIconFactory

 * @stock_id: icon name

 * @icon_set: icon set

 *

 * Adds the given @icon_set to the icon factory, under the name

 * @stock_id.  @stock_id should be namespaced for your application,

 * e.g. "myapp-whatever-icon".  Normally applications create a

 * #GtkIconFactory, then add it to the list of default factories with

 * gtk_icon_factory_add_default(). Then they pass the @stock_id to

 * widgets such as #GtkImage to display the icon. Themes can provide

 * an icon with the same name (such as "myapp-whatever-icon") to

 * override your application's default icons. If an icon already

 * existed in @factory for @stock_id, it is unreferenced and replaced

 * with the new @icon_set.

 */

void

gtk_icon_factory_add (GtkIconFactory *factory,

                      const gchar    *stock_id,

                      GtkIconSet     *icon_set)

{

  gpointer old_key = NULL;

  gpointer old_value = NULL;

  g_return_if_fail (GTK_IS_ICON_FACTORY (factory));

  g_return_if_fail (stock_id != NULL);

  g_return_if_fail (icon_set != NULL);

  g_hash_table_lookup_extended (factory->icons, stock_id,

                                &old_key, &old_value);

  if (old_value == icon_set)

    return;

  gtk_icon_set_ref (icon_set);

  /* GHashTable key memory management is so fantastically broken. */

  if (old_key)

    g_hash_table_insert (factory->icons, old_key, icon_set);

  else

    g_hash_table_insert (factory->icons, g_strdup (stock_id), icon_set);

  if (old_value)

    gtk_icon_set_unref (old_value);

}

/**

 * gtk_icon_factory_lookup:

 * @factory: a #GtkIconFactory

 * @stock_id: an icon name

 *

 * Looks up @stock_id in the icon factory, returning an icon set

 * if found, otherwise %NULL. For display to the user, you should

 * use gtk_style_lookup_icon_set() on the #GtkStyle for the

 * widget that will display the icon, instead of using this

 * function directly, so that themes are taken into account.

 *

 * Return value: (transfer none): icon set of @stock_id.

 */

GtkIconSet *

gtk_icon_factory_lookup (GtkIconFactory *factory,

                         const gchar    *stock_id)

{

  g_return_val_if_fail (GTK_IS_ICON_FACTORY (factory), NULL);

  g_return_val_if_fail (stock_id != NULL, NULL);

  return g_hash_table_lookup (factory->icons, stock_id);

}

static GtkIconFactory *gtk_default_icons = NULL;

static GSList *default_factories = NULL;

/**

 * gtk_icon_factory_add_default:

 * @factory: a #GtkIconFactory

 *

 * Adds an icon factory to the list of icon factories searched by

 * gtk_style_lookup_icon_set(). This means that, for example,

 * gtk_image_new_from_stock() will be able to find icons in @factory.

 * There will normally be an icon factory added for each library or

 * application that comes with icons. The default icon factories

 * can be overridden by themes.

 */

void

gtk_icon_factory_add_default (GtkIconFactory *factory)

{

  g_return_if_fail (GTK_IS_ICON_FACTORY (factory));

  g_object_ref (factory);

  default_factories = g_slist_prepend (default_factories, factory);

}

/**

 * gtk_icon_factory_remove_default:

 * @factory: a #GtkIconFactory previously added with gtk_icon_factory_add_default()

 *

 * Removes an icon factory from the list of default icon

 * factories. Not normally used; you might use it for a library that

 * can be unloaded or shut down.

 */

void

gtk_icon_factory_remove_default (GtkIconFactory  *factory)

{

  g_return_if_fail (GTK_IS_ICON_FACTORY (factory));

  default_factories = g_slist_remove (default_factories, factory);

  g_object_unref (factory);

}

void

_gtk_icon_factory_ensure_default_icons (void)

{

  if (gtk_default_icons == NULL)

    {

      gtk_default_icons = gtk_icon_factory_new ();

      get_default_icons (gtk_default_icons);

    }

}

/**

 * gtk_icon_factory_lookup_default:

 * @stock_id: an icon name

 *

 * Looks for an icon in the list of default icon factories.  For

 * display to the user, you should use gtk_style_lookup_icon_set() on

 * the #GtkStyle for the widget that will display the icon, instead of

 * using this function directly, so that themes are taken into

 * account.

 *

 * Return value: (transfer none): a #GtkIconSet, or %NULL

 */

GtkIconSet *

gtk_icon_factory_lookup_default (const gchar *stock_id)

{

  GSList *tmp_list;

  g_return_val_if_fail (stock_id != NULL, NULL);

  tmp_list = default_factories;

  while (tmp_list != NULL)

    {

      GtkIconSet *icon_set =

        gtk_icon_factory_lookup (GTK_ICON_FACTORY (tmp_list->data),

                                 stock_id);

      if (icon_set)

        return icon_set;

      tmp_list = g_slist_next (tmp_list);

    }

  _gtk_icon_factory_ensure_default_icons ();

  return gtk_icon_factory_lookup (gtk_default_icons, stock_id);

}

static void

register_stock_icon (GtkIconFactory *factory,

		     const gchar    *stock_id,

                     const gchar    *icon_name)

{

  GtkIconSet *set = gtk_icon_set_new ();

  GtkIconSource source = GTK_ICON_SOURCE_INIT (TRUE, TRUE, TRUE);

  source.type = GTK_ICON_SOURCE_STATIC_ICON_NAME;

  source.source.icon_name = (gchar *)icon_name;

  source.direction = GTK_TEXT_DIR_NONE;

  gtk_icon_set_add_source (set, &source);

  gtk_icon_factory_add (factory, stock_id, set);

  gtk_icon_set_unref (set);

}

static void

register_bidi_stock_icon (GtkIconFactory *factory,

			  const gchar    *stock_id,

                          const gchar    *icon_name)

{

  GtkIconSet *set = gtk_icon_set_new ();

  GtkIconSource source = GTK_ICON_SOURCE_INIT (FALSE, TRUE, TRUE);

  source.type = GTK_ICON_SOURCE_STATIC_ICON_NAME;

  source.source.icon_name = (gchar *)icon_name;

  source.direction = GTK_TEXT_DIR_LTR;

  gtk_icon_set_add_source (set, &source);

  source.type = GTK_ICON_SOURCE_STATIC_ICON_NAME;

  source.source.icon_name = (gchar *)icon_name;

  source.direction = GTK_TEXT_DIR_RTL;

  gtk_icon_set_add_source (set, &source);

  gtk_icon_factory_add (factory, stock_id, set);

  gtk_icon_set_unref (set);

}

static void

get_default_icons (GtkIconFactory *factory)

{

  /* KEEP IN SYNC with gtkstock.c */

  register_stock_icon (factory, GTK_STOCK_DIALOG_AUTHENTICATION, "dialog-password");

  register_stock_icon (factory, GTK_STOCK_DIALOG_ERROR, "dialog-error");

  register_stock_icon (factory, GTK_STOCK_DIALOG_INFO, "dialog-information");

  register_stock_icon (factory, GTK_STOCK_DIALOG_QUESTION, "dialog-question");

  register_stock_icon (factory, GTK_STOCK_DIALOG_WARNING, "dialog-warning");

  register_stock_icon (factory, GTK_STOCK_DND, GTK_STOCK_DND);

  register_stock_icon (factory, GTK_STOCK_DND_MULTIPLE, GTK_STOCK_DND_MULTIPLE);

  register_stock_icon (factory, GTK_STOCK_APPLY, GTK_STOCK_APPLY);

  register_stock_icon (factory, GTK_STOCK_CANCEL, GTK_STOCK_CANCEL);

  register_stock_icon (factory, GTK_STOCK_NO, GTK_STOCK_NO);

  register_stock_icon (factory, GTK_STOCK_OK, GTK_STOCK_OK);

  register_stock_icon (factory, GTK_STOCK_YES, GTK_STOCK_YES);

  register_stock_icon (factory, GTK_STOCK_CLOSE, "window-close");

  register_stock_icon (factory, GTK_STOCK_ADD, "list-add");

  register_stock_icon (factory, GTK_STOCK_JUSTIFY_CENTER, "format-justify-center");

  register_stock_icon (factory, GTK_STOCK_JUSTIFY_FILL, "format-justify-fill");

  register_stock_icon (factory, GTK_STOCK_JUSTIFY_LEFT, "format-justify-left");

  register_stock_icon (factory, GTK_STOCK_JUSTIFY_RIGHT, "format-justify-right");

  register_stock_icon (factory, GTK_STOCK_GOTO_BOTTOM, "go-bottom");

  register_stock_icon (factory, GTK_STOCK_CDROM, "media-optical");

  register_stock_icon (factory, GTK_STOCK_CONVERT, GTK_STOCK_CONVERT);

  register_stock_icon (factory, GTK_STOCK_COPY, "edit-copy");

  register_stock_icon (factory, GTK_STOCK_CUT, "edit-cut");

  register_stock_icon (factory, GTK_STOCK_GO_DOWN, "go-down");

  register_stock_icon (factory, GTK_STOCK_EXECUTE, "system-run");

  register_stock_icon (factory, GTK_STOCK_QUIT, "application-exit");

  register_bidi_stock_icon (factory, GTK_STOCK_GOTO_FIRST, "go-first");

  register_stock_icon (factory, GTK_STOCK_SELECT_FONT, GTK_STOCK_SELECT_FONT);

  register_stock_icon (factory, GTK_STOCK_FULLSCREEN, "view-fullscreen");

  register_stock_icon (factory, GTK_STOCK_LEAVE_FULLSCREEN, "view-restore");

  register_stock_icon (factory, GTK_STOCK_HARDDISK, "drive-harddisk");

  register_stock_icon (factory, GTK_STOCK_HELP, "help-contents");

  register_stock_icon (factory, GTK_STOCK_HOME, "go-home");

  register_stock_icon (factory, GTK_STOCK_INFO, "dialog-information");

  register_bidi_stock_icon (factory, GTK_STOCK_JUMP_TO, "go-jump");

  register_bidi_stock_icon (factory, GTK_STOCK_GOTO_LAST, "go-last");

  register_bidi_stock_icon (factory, GTK_STOCK_GO_BACK, "go-previous");

  register_stock_icon (factory, GTK_STOCK_MISSING_IMAGE, "image-missing");

  register_stock_icon (factory, GTK_STOCK_NETWORK, "network-idle");

  register_stock_icon (factory, GTK_STOCK_NEW, "document-new");

  register_stock_icon (factory, GTK_STOCK_OPEN, "document-open");

  register_stock_icon (factory, GTK_STOCK_ORIENTATION_PORTRAIT, GTK_STOCK_ORIENTATION_PORTRAIT);

  register_stock_icon (factory, GTK_STOCK_ORIENTATION_LANDSCAPE, GTK_STOCK_ORIENTATION_LANDSCAPE);

  register_stock_icon (factory, GTK_STOCK_ORIENTATION_REVERSE_PORTRAIT, GTK_STOCK_ORIENTATION_REVERSE_PORTRAIT);

  register_stock_icon (factory, GTK_STOCK_ORIENTATION_REVERSE_LANDSCAPE, GTK_STOCK_ORIENTATION_REVERSE_LANDSCAPE);

  register_stock_icon (factory, GTK_STOCK_PAGE_SETUP, GTK_STOCK_PAGE_SETUP);

  register_stock_icon (factory, GTK_STOCK_PASTE, "edit-paste");

  register_stock_icon (factory, GTK_STOCK_PREFERENCES, GTK_STOCK_PREFERENCES);

  register_stock_icon (factory, GTK_STOCK_PRINT, "document-print");

  register_stock_icon (factory, GTK_STOCK_PRINT_ERROR, "printer-error");

  register_stock_icon (factory, GTK_STOCK_PRINT_PAUSED, "printer-paused");

  register_stock_icon (factory, GTK_STOCK_PRINT_PREVIEW, "document-print-preview");

  register_stock_icon (factory, GTK_STOCK_PRINT_REPORT, "printer-info");

  register_stock_icon (factory, GTK_STOCK_PRINT_WARNING, "printer-warning");

  register_stock_icon (factory, GTK_STOCK_PROPERTIES, "document-properties");

  register_bidi_stock_icon (factory, GTK_STOCK_REDO, "edit-redo");

  register_stock_icon (factory, GTK_STOCK_REMOVE, "list-remove");

  register_stock_icon (factory, GTK_STOCK_REFRESH, "view-refresh");

  register_bidi_stock_icon (factory, GTK_STOCK_REVERT_TO_SAVED, "document-revert");

  register_bidi_stock_icon (factory, GTK_STOCK_GO_FORWARD, "go-next");

  register_stock_icon (factory, GTK_STOCK_SAVE, "document-save");

  register_stock_icon (factory, GTK_STOCK_FLOPPY, "media-floppy");

  register_stock_icon (factory, GTK_STOCK_SAVE_AS, "document-save-as");

  register_stock_icon (factory, GTK_STOCK_FIND, "edit-find");

  register_stock_icon (factory, GTK_STOCK_FIND_AND_REPLACE, "edit-find-replace");

  register_stock_icon (factory, GTK_STOCK_SORT_DESCENDING, "view-sort-descending");

  register_stock_icon (factory, GTK_STOCK_SORT_ASCENDING, "view-sort-ascending");

  register_stock_icon (factory, GTK_STOCK_SPELL_CHECK, "tools-check-spelling");

  register_stock_icon (factory, GTK_STOCK_STOP, "process-stop");

  register_stock_icon (factory, GTK_STOCK_BOLD, "format-text-bold");

  register_stock_icon (factory, GTK_STOCK_ITALIC, "format-text-italic");

  register_stock_icon (factory, GTK_STOCK_STRIKETHROUGH, "format-text-strikethrough");

  register_stock_icon (factory, GTK_STOCK_UNDERLINE, "format-text-underline");

  register_bidi_stock_icon (factory, GTK_STOCK_INDENT, "format-indent-more");

  register_bidi_stock_icon (factory, GTK_STOCK_UNINDENT, "format-indent-less");

  register_stock_icon (factory, GTK_STOCK_GOTO_TOP, "go-top");

  register_stock_icon (factory, GTK_STOCK_DELETE, "edit-delete");

  register_bidi_stock_icon (factory, GTK_STOCK_UNDELETE, GTK_STOCK_UNDELETE);

  register_bidi_stock_icon (factory, GTK_STOCK_UNDO, "edit-undo");

  register_stock_icon (factory, GTK_STOCK_GO_UP, "go-up");

  register_stock_icon (factory, GTK_STOCK_FILE, "text-x-generic");

  register_stock_icon (factory, GTK_STOCK_DIRECTORY, "folder");

  register_stock_icon (factory, GTK_STOCK_ABOUT, "help-about");

  register_stock_icon (factory, GTK_STOCK_CONNECT, GTK_STOCK_CONNECT);

  register_stock_icon (factory, GTK_STOCK_DISCONNECT, GTK_STOCK_DISCONNECT);

  register_stock_icon (factory, GTK_STOCK_EDIT, GTK_STOCK_EDIT);

  register_stock_icon (factory, GTK_STOCK_CAPS_LOCK_WARNING, GTK_STOCK_CAPS_LOCK_WARNING);

  register_bidi_stock_icon (factory, GTK_STOCK_MEDIA_FORWARD, "media-seek-forward");

  register_bidi_stock_icon (factory, GTK_STOCK_MEDIA_NEXT, "media-skip-forward");

  register_stock_icon (factory, GTK_STOCK_MEDIA_PAUSE, "media-playback-pause");

  register_bidi_stock_icon (factory, GTK_STOCK_MEDIA_PLAY, "media-playback-start");

  register_bidi_stock_icon (factory, GTK_STOCK_MEDIA_PREVIOUS, "media-skip-backward");

  register_stock_icon (factory, GTK_STOCK_MEDIA_RECORD, "media-record");

  register_bidi_stock_icon (factory, GTK_STOCK_MEDIA_REWIND, "media-seek-backward");

  register_stock_icon (factory, GTK_STOCK_MEDIA_STOP, "media-playback-stop");

  register_stock_icon (factory, GTK_STOCK_INDEX, GTK_STOCK_INDEX);

  register_stock_icon (factory, GTK_STOCK_ZOOM_100, "zoom-original");

  register_stock_icon (factory, GTK_STOCK_ZOOM_IN, "zoom-in");

  register_stock_icon (factory, GTK_STOCK_ZOOM_OUT, "zoom-out");

  register_stock_icon (factory, GTK_STOCK_ZOOM_FIT, "zoom-fit-best");

  register_stock_icon (factory, GTK_STOCK_SELECT_ALL, "edit-select-all");

  register_stock_icon (factory, GTK_STOCK_CLEAR, "edit-clear");

  register_stock_icon (factory, GTK_STOCK_SELECT_COLOR, GTK_STOCK_SELECT_COLOR);

  register_stock_icon (factory, GTK_STOCK_COLOR_PICKER, GTK_STOCK_COLOR_PICKER);

}

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

 *                    Icon size handling                    *

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

typedef struct _IconSize IconSize;

struct _IconSize

{

  gint size;

  gchar *name;

  gint width;

  gint height;

};

typedef struct _IconAlias IconAlias;

struct _IconAlias

{

  gchar *name;

  gint   target;

};

typedef struct _SettingsIconSize SettingsIconSize;

struct _SettingsIconSize

{

  gint width;

  gint height;

};

static GHashTable *icon_aliases = NULL;

static IconSize *icon_sizes = NULL;

static gint      icon_sizes_allocated = 0;

static gint      icon_sizes_used = 0;

static void

init_icon_sizes (void)

{

  if (icon_sizes == NULL)

    {

#define NUM_BUILTIN_SIZES 7

      gint i;

      icon_aliases = g_hash_table_new (g_str_hash, g_str_equal);

      icon_sizes = g_new (IconSize, NUM_BUILTIN_SIZES);

      icon_sizes_allocated = NUM_BUILTIN_SIZES;

      icon_sizes_used = NUM_BUILTIN_SIZES;

      icon_sizes[GTK_ICON_SIZE_INVALID].size = 0;

      icon_sizes[GTK_ICON_SIZE_INVALID].name = NULL;

      icon_sizes[GTK_ICON_SIZE_INVALID].width = 0;

      icon_sizes[GTK_ICON_SIZE_INVALID].height = 0;

      /* the name strings aren't copied since we don't ever remove

       * icon sizes, so we don't need to know whether they're static.

       * Even if we did I suppose removing the builtin sizes would be

       * disallowed.

       */

      icon_sizes[GTK_ICON_SIZE_MENU].size = GTK_ICON_SIZE_MENU;

      icon_sizes[GTK_ICON_SIZE_MENU].name = "gtk-menu";

      icon_sizes[GTK_ICON_SIZE_MENU].width = 16;

      icon_sizes[GTK_ICON_SIZE_MENU].height = 16;

      icon_sizes[GTK_ICON_SIZE_BUTTON].size = GTK_ICON_SIZE_BUTTON;

      icon_sizes[GTK_ICON_SIZE_BUTTON].name = "gtk-button";

      icon_sizes[GTK_ICON_SIZE_BUTTON].width = 20;

      icon_sizes[GTK_ICON_SIZE_BUTTON].height = 20;

      icon_sizes[GTK_ICON_SIZE_SMALL_TOOLBAR].size = GTK_ICON_SIZE_SMALL_TOOLBAR;

      icon_sizes[GTK_ICON_SIZE_SMALL_TOOLBAR].name = "gtk-small-toolbar";

      icon_sizes[GTK_ICON_SIZE_SMALL_TOOLBAR].width = 18;

      icon_sizes[GTK_ICON_SIZE_SMALL_TOOLBAR].height = 18;

      icon_sizes[GTK_ICON_SIZE_LARGE_TOOLBAR].size = GTK_ICON_SIZE_LARGE_TOOLBAR;

      icon_sizes[GTK_ICON_SIZE_LARGE_TOOLBAR].name = "gtk-large-toolbar";

      icon_sizes[GTK_ICON_SIZE_LARGE_TOOLBAR].width = 24;

      icon_sizes[GTK_ICON_SIZE_LARGE_TOOLBAR].height = 24;

      icon_sizes[GTK_ICON_SIZE_DND].size = GTK_ICON_SIZE_DND;

      icon_sizes[GTK_ICON_SIZE_DND].name = "gtk-dnd";

      icon_sizes[GTK_ICON_SIZE_DND].width = 32;

      icon_sizes[GTK_ICON_SIZE_DND].height = 32;

      icon_sizes[GTK_ICON_SIZE_DIALOG].size = GTK_ICON_SIZE_DIALOG;

      icon_sizes[GTK_ICON_SIZE_DIALOG].name = "gtk-dialog";

      icon_sizes[GTK_ICON_SIZE_DIALOG].width = 48;

      icon_sizes[GTK_ICON_SIZE_DIALOG].height = 48;

      g_assert ((GTK_ICON_SIZE_DIALOG + 1) == NUM_BUILTIN_SIZES);

      /* Alias everything to itself. */

      i = 1; /* skip invalid size */

      while (i < NUM_BUILTIN_SIZES)

        {

          gtk_icon_size_register_alias (icon_sizes[i].name, icon_sizes[i].size);

          ++i;

        }

#undef NUM_BUILTIN_SIZES

    }

}

static void

free_settings_sizes (gpointer data)

{

  g_array_free (data, TRUE);

}

static GArray *

get_settings_sizes (GtkSettings *settings,

		    gboolean    *created)

{

  GArray *settings_sizes;

  static GQuark sizes_quark = 0;

  if (!sizes_quark)

    sizes_quark = g_quark_from_static_string ("gtk-icon-sizes");

  settings_sizes = g_object_get_qdata (G_OBJECT (settings), sizes_quark);

  if (!settings_sizes)

    {

      settings_sizes = g_array_new (FALSE, FALSE, sizeof (SettingsIconSize));

      g_object_set_qdata_full (G_OBJECT (settings), sizes_quark,

			       settings_sizes, free_settings_sizes);

      if (created)

	*created = TRUE;

    }

  return settings_sizes;

}

static void

icon_size_set_for_settings (GtkSettings *settings,

			    const gchar *size_name,

			    gint         width,

			    gint         height)

{

  GtkIconSize size;

  GArray *settings_sizes;

  SettingsIconSize *settings_size;

  g_return_if_fail (size_name != NULL);

  size = gtk_icon_size_from_name (size_name);

  if (size == GTK_ICON_SIZE_INVALID)

    /* Reserve a place */

    size = icon_size_register_intern (size_name, -1, -1);

  settings_sizes = get_settings_sizes (settings, NULL);

  if (size >= settings_sizes->len)

    {

      SettingsIconSize unset = { -1, -1 };

      gint i;

      for (i = settings_sizes->len; i <= size; i++)

	g_array_append_val (settings_sizes, unset);

    }

  settings_size = &g_array_index (settings_sizes, SettingsIconSize, size);

  settings_size->width = width;

  settings_size->height = height;

}

/* Like pango_parse_word, but accept - as well

 */

static gboolean

scan_icon_size_name (const char **pos, GString *out)

{

  const char *p = *pos;

  while (g_ascii_isspace (*p))

    p++;

  if (!((*p >= 'A' && *p <= 'Z') ||

	(*p >= 'a' && *p <= 'z') ||

	*p == '_' || *p == '-'))

    return FALSE;

  g_string_truncate (out, 0);

  g_string_append_c (out, *p);

  p++;

  while ((*p >= 'A' && *p <= 'Z') ||

	 (*p >= 'a' && *p <= 'z') ||

	 (*p >= '0' && *p <= '9') ||

	 *p == '_' || *p == '-')

    {

      g_string_append_c (out, *p);

      p++;

    }

  *pos = p;

  return TRUE;

}

static void

icon_size_setting_parse (GtkSettings *settings,

			 const gchar *icon_size_string)

{

  GString *name_buf = g_string_new (NULL);

  const gchar *p = icon_size_string;

  while (pango_skip_space (&p))

    {

      gint width, height;

      if (!scan_icon_size_name (&p, name_buf))

	goto err;

      if (!pango_skip_space (&p))

	goto err;

      if (*p != '=')

	goto err;

      p++;

      if (!pango_scan_int (&p, &width))

	goto err;

      if (!pango_skip_space (&p))

	goto err;

      if (*p != ',')

	goto err;

      p++;

      if (!pango_scan_int (&p, &height))

	goto err;

      if (width > 0 && height > 0)

	{

	  icon_size_set_for_settings (settings, name_buf->str,

				      width, height);

	}

      else

	{

	  g_warning ("Invalid size in gtk-icon-sizes: %d,%d\n", width, height);

	}

      pango_skip_space (&p);

      if (*p == '\0')

	break;

      if (*p == ':')

	p++;

      else

	goto err;

    }

  g_string_free (name_buf, TRUE);

  return;

 err:

  g_warning ("Error parsing gtk-icon-sizes string:\n\t'%s'", icon_size_string);

  g_string_free (name_buf, TRUE);

}

static void

icon_size_set_all_from_settings (GtkSettings *settings)

{

  GArray *settings_sizes;

  gchar *icon_size_string;

  /* Reset old settings */

  settings_sizes = get_settings_sizes (settings, NULL);

  g_array_set_size (settings_sizes, 0);

  g_object_get (settings,

		"gtk-icon-sizes", &icon_size_string,

		NULL);

  if (icon_size_string)

    {

      icon_size_setting_parse (settings, icon_size_string);

      g_free (icon_size_string);

    }

}

static void

icon_size_settings_changed (GtkSettings  *settings,

			    GParamSpec   *pspec)

{

  icon_size_set_all_from_settings (settings);

  gtk_rc_reset_styles (settings);

}

static void

icon_sizes_init_for_settings (GtkSettings *settings)

{

  g_signal_connect (settings,

		    "notify::gtk-icon-sizes",

		    G_CALLBACK (icon_size_settings_changed),

		    NULL);

  icon_size_set_all_from_settings (settings);

}

static gboolean

icon_size_lookup_intern (GtkSettings *settings,

			 GtkIconSize  size,

			 gint        *widthp,

			 gint        *heightp)

{

  GArray *settings_sizes;

  gint width_for_settings = -1;

  gint height_for_settings = -1;

  init_icon_sizes ();

  if (size == (GtkIconSize)-1)

    return FALSE;

  if (size >= icon_sizes_used)

    return FALSE;

  if (size == GTK_ICON_SIZE_INVALID)

    return FALSE;

  if (settings)

    {

      gboolean initial = FALSE;

      settings_sizes = get_settings_sizes (settings, &initial);

      if (initial)

	icon_sizes_init_for_settings (settings);

      if (size < settings_sizes->len)

	{

	  SettingsIconSize *settings_size;

	  settings_size = &g_array_index (settings_sizes, SettingsIconSize, size);

	  width_for_settings = settings_size->width;

	  height_for_settings = settings_size->height;

	}

    }

  if (widthp)

    *widthp = width_for_settings >= 0 ? width_for_settings : icon_sizes[size].width;

  if (heightp)

    *heightp = height_for_settings >= 0 ? height_for_settings : icon_sizes[size].height;

  return TRUE;

}

/**

 * gtk_icon_size_lookup_for_settings:

 * @settings: a #GtkSettings object, used to determine

 *   which set of user preferences to used.

 * @size: (type int): an icon size

 * @width: (out): location to store icon width

 * @height: (out): location to store icon height

 *

 * Obtains the pixel size of a semantic icon size, possibly

 * modified by user preferences for a particular

 * #GtkSettings. Normally @size would be

 * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc.  This function

 * isn't normally needed, gtk_widget_render_icon() is the usual

 * way to get an icon for rendering, then just look at the size of

 * the rendered pixbuf. The rendered pixbuf may not even correspond to

 * the width/height returned by gtk_icon_size_lookup(), because themes

 * are free to render the pixbuf however they like, including changing

 * the usual size.

 *

 * Return value: %TRUE if @size was a valid size

 *

 * Since: 2.2

 */

gboolean

gtk_icon_size_lookup_for_settings (GtkSettings *settings,

				   GtkIconSize  size,

				   gint        *width,

				   gint        *height)

{

  g_return_val_if_fail (GTK_IS_SETTINGS (settings), FALSE);