/* GtkIconTheme - a loader for icon themes

 * gtk-icon-theme.c Copyright (C) 2002, 2003 Red Hat, Inc.

 *

 * 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.

 */

#include "config.h"

#include <sys/types.h>

#include <sys/stat.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <glib.h>

#include <glib/gstdio.h>

#ifdef G_OS_WIN32

#ifndef S_ISDIR

#define S_ISDIR(mode) ((mode)&_S_IFDIR)

#endif

#define WIN32_MEAN_AND_LEAN

#include <windows.h>

#include "win32/gdkwin32.h"

#endif /* G_OS_WIN32 */

#include "gtkicontheme.h"

#include "gtkiconfactory.h"

#include "gtkiconcache.h"

#include "gtkbuiltincache.h"

#include "gtkintl.h"

#include "gtkmain.h"

#include "gtksettings.h"

#include "gtkprivate.h"

#include "gtkalias.h"

#define DEFAULT_THEME_NAME "hicolor"

typedef enum

{

  ICON_THEME_DIR_FIXED,  

  ICON_THEME_DIR_SCALABLE,  

  ICON_THEME_DIR_THRESHOLD,

  ICON_THEME_DIR_UNTHEMED

} IconThemeDirType;

/* In reverse search order: */

typedef enum

{

  ICON_SUFFIX_NONE = 0,

  ICON_SUFFIX_XPM = 1 << 0,

  ICON_SUFFIX_SVG = 1 << 1,

  ICON_SUFFIX_PNG = 1 << 2,

  HAS_ICON_FILE = 1 << 3

} IconSuffix;

struct _GtkIconThemePrivate

{

  guint custom_theme        : 1;

  guint is_screen_singleton : 1;

  guint pixbuf_supports_svg : 1;

  guint themes_valid        : 1;

  guint check_reload        : 1;

  guint loading_themes      : 1;

  char *current_theme;

  char *fallback_theme;

  char **search_path;

  int search_path_len;

  /* A list of all the themes needed to look up icons.

   * In search order, without duplicates

   */

  GList *themes;

  GHashTable *unthemed_icons;

  /* Note: The keys of this hashtable are owned by the

   * themedir and unthemed hashtables.

   */

  GHashTable *all_icons;

  /* GdkScreen for the icon theme (may be NULL)

   */

  GdkScreen *screen;

  /* time when we last stat:ed for theme changes */

  long last_stat_time;

  GList *dir_mtimes;

  gulong reset_styles_idle;

};

struct _GtkIconInfo

{

  /* Information about the source

   */

  gchar *filename;

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

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

   * compatibility functions.

   */

  gchar *cp_filename;

#endif

  GLoadableIcon *loadable;

  GSList *emblem_infos;

  /* Cache pixbuf (if there is any) */

  GdkPixbuf *cache_pixbuf;

  GtkIconData *data;

  /* Information about the directory where

   * the source was found

   */

  IconThemeDirType dir_type;

  gint dir_size;

  gint threshold;

  /* Parameters influencing the scaled icon

   */

  gint desired_size;

  guint raw_coordinates : 1;

  guint forced_size     : 1;

  /* Cached information if we go ahead and try to load

   * the icon.

   */

  GdkPixbuf *pixbuf;

  GError *load_error;

  gdouble scale;

  gboolean emblems_applied;

  guint ref_count;

};

typedef struct

{

  char *name;

  char *display_name;

  char *comment;

  char *example;

  /* In search order */

  GList *dirs;

} IconTheme;

typedef struct

{

  IconThemeDirType type;

  GQuark context;

  int size;

  int min_size;

  int max_size;

  int threshold;

  char *dir;

  char *subdir;

  int subdir_index;

  GtkIconCache *cache;

  GHashTable *icons;

  GHashTable *icon_data;

} IconThemeDir;

typedef struct

{

  char *svg_filename;

  char *no_svg_filename;

} UnthemedIcon;

typedef struct

{

  gint size;

  GdkPixbuf *pixbuf;

} BuiltinIcon;

typedef struct 

{

  char *dir;

  time_t mtime; /* 0 == not existing or not a dir */

  gboolean exists;

  GtkIconCache *cache;

} IconThemeDirMtime;

static void  gtk_icon_theme_finalize   (GObject              *object);

static void  theme_dir_destroy         (IconThemeDir         *dir);

static void         theme_destroy     (IconTheme        *theme);

static GtkIconInfo *theme_lookup_icon (IconTheme        *theme,

				       const char       *icon_name,

				       int               size,

				       gboolean          allow_svg,

				       gboolean          use_default_icons);

static void         theme_list_icons  (IconTheme        *theme,

				       GHashTable       *icons,

				       GQuark            context);

static void         theme_list_contexts  (IconTheme        *theme,

					  GHashTable       *contexts);

static void         theme_subdir_load (GtkIconTheme     *icon_theme,

				       IconTheme        *theme,

				       GKeyFile         *theme_file,

				       char             *subdir);

static void         do_theme_change   (GtkIconTheme     *icon_theme);

static void     blow_themes               (GtkIconTheme    *icon_themes);

static gboolean rescan_themes             (GtkIconTheme    *icon_themes);

static void  icon_data_free            (GtkIconData     *icon_data);

static void load_icon_data             (IconThemeDir    *dir,

			                const char      *path,

			                const char      *name);

static IconSuffix theme_dir_get_icon_suffix (IconThemeDir *dir,

					     const gchar  *icon_name,

					     gboolean     *has_icon_file);

static GtkIconInfo *icon_info_new             (void);

static GtkIconInfo *icon_info_new_builtin     (BuiltinIcon *icon);

static IconSuffix suffix_from_name (const char *name);

static BuiltinIcon *find_builtin_icon (const gchar *icon_name,

				       gint        size,

				       gint        *min_difference_p,

				       gboolean    *has_larger_p);

static guint signal_changed = 0;

static GHashTable *icon_theme_builtin_icons;

/* also used in gtkiconfactory.c */

GtkIconCache *_builtin_cache = NULL;

static GList *builtin_dirs = NULL;

G_DEFINE_TYPE (GtkIconTheme, gtk_icon_theme, G_TYPE_OBJECT)

/**

 * gtk_icon_theme_new:

 * 

 * Creates a new icon theme object. Icon theme objects are used

 * to lookup up an icon by name in a particular icon theme.

 * Usually, you'll want to use gtk_icon_theme_get_default()

 * or gtk_icon_theme_get_for_screen() rather than creating

 * a new icon theme object for scratch.

 * 

 * Return value: the newly created #GtkIconTheme object.

 *

 * Since: 2.4

 **/

GtkIconTheme *

gtk_icon_theme_new (void)

{

  return g_object_new (GTK_TYPE_ICON_THEME, NULL);

}

/**

 * gtk_icon_theme_get_default:

 * 

 * Gets the icon theme for the default screen. See

 * gtk_icon_theme_get_for_screen().

 *

 * Return value: (transfer none): A unique #GtkIconTheme associated with

 *  the default screen. This icon theme is associated with

 *  the screen and can be used as long as the screen

 *  is open. Do not ref or unref it.

 *

 * Since: 2.4

 **/

GtkIconTheme *

gtk_icon_theme_get_default (void)

{

  return gtk_icon_theme_get_for_screen (gdk_screen_get_default ());

}

/**

 * gtk_icon_theme_get_for_screen:

 * @screen: a #GdkScreen

 * 

 * Gets the icon theme object associated with @screen; if this

 * function has not previously been called for the given

 * screen, a new icon theme object will be created and

 * associated with the screen. Icon theme objects are

 * fairly expensive to create, so using this function

 * is usually a better choice than calling than gtk_icon_theme_new()

 * and setting the screen yourself; by using this function

 * a single icon theme object will be shared between users.

 *

 * Return value: (transfer none): A unique #GtkIconTheme associated with

 *  the given screen. This icon theme is associated with

 *  the screen and can be used as long as the screen

 *  is open. Do not ref or unref it.

 *

 * Since: 2.4

 **/

GtkIconTheme *

gtk_icon_theme_get_for_screen (GdkScreen *screen)

{

  GtkIconTheme *icon_theme;

  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);

  g_return_val_if_fail (!screen->closed, NULL);

  icon_theme = g_object_get_data (G_OBJECT (screen), "gtk-icon-theme");

  if (!icon_theme)

    {

      GtkIconThemePrivate *priv;

      icon_theme = gtk_icon_theme_new ();

      gtk_icon_theme_set_screen (icon_theme, screen);

      priv = icon_theme->priv;

      priv->is_screen_singleton = TRUE;

      g_object_set_data (G_OBJECT (screen), I_("gtk-icon-theme"), icon_theme);

    }

  return icon_theme;

}

static void

gtk_icon_theme_class_init (GtkIconThemeClass *klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->finalize = gtk_icon_theme_finalize;

/**

 * GtkIconTheme::changed

 * @icon_theme: the icon theme

 * 

 * Emitted when the current icon theme is switched or GTK+ detects

 * that a change has occurred in the contents of the current

 * icon theme.

 **/

  signal_changed = g_signal_new (I_("changed"),

				 G_TYPE_FROM_CLASS (klass),

				 G_SIGNAL_RUN_LAST,

				 G_STRUCT_OFFSET (GtkIconThemeClass, changed),

				 NULL, NULL,

				 g_cclosure_marshal_VOID__VOID,

				 G_TYPE_NONE, 0);

  g_type_class_add_private (klass, sizeof (GtkIconThemePrivate));

}

/* Callback when the display that the icon theme is attached to

 * is closed; unset the screen, and if it's the unique theme

 * for the screen, drop the reference

 */

static void

display_closed (GdkDisplay   *display,

		gboolean      is_error,

		GtkIconTheme *icon_theme)

{

  GtkIconThemePrivate *priv = icon_theme->priv;

  GdkScreen *screen = priv->screen;

  gboolean was_screen_singleton = priv->is_screen_singleton;

  if (was_screen_singleton)

    {

      g_object_set_data (G_OBJECT (screen), I_("gtk-icon-theme"), NULL);

      priv->is_screen_singleton = FALSE;

    }

  gtk_icon_theme_set_screen (icon_theme, NULL);

  if (was_screen_singleton)

    {

      g_object_unref (icon_theme);

    }

}

static void

update_current_theme (GtkIconTheme *icon_theme)

{

#define theme_changed(_old, _new) \

  ((_old && !_new) || (!_old && _new) || \

   (_old && _new && strcmp (_old, _new) != 0))

  GtkIconThemePrivate *priv = icon_theme->priv;

  if (!priv->custom_theme)

    {

      gchar *theme = NULL;

      gchar *fallback_theme = NULL;

      gboolean changed = FALSE;

      if (priv->screen)

	{

	  GtkSettings *settings = gtk_settings_get_for_screen (priv->screen);

	  g_object_get (settings, 

			"gtk-icon-theme-name", &theme, 

			"gtk-fallback-icon-theme", &fallback_theme, NULL);

	}

      /* ensure that the current theme (even when just the default)

       * is searched before any fallback theme

       */

      if (!theme && fallback_theme)

	theme = g_strdup (DEFAULT_THEME_NAME);

      if (theme_changed (priv->current_theme, theme))

	{

	  g_free (priv->current_theme);

	  priv->current_theme = theme;

	  changed = TRUE;

	}

      else

	g_free (theme);

      if (theme_changed (priv->fallback_theme, fallback_theme))

	{

	  g_free (priv->fallback_theme);

	  priv->fallback_theme = fallback_theme;

	  changed = TRUE;

	}

      else

	g_free (fallback_theme);

      if (changed)

	do_theme_change (icon_theme);

    }

#undef theme_changed

}

/* Callback when the icon theme GtkSetting changes

 */

static void

theme_changed (GtkSettings  *settings,

	       GParamSpec   *pspec,

	       GtkIconTheme *icon_theme)

{

  update_current_theme (icon_theme);

}

static void

unset_screen (GtkIconTheme *icon_theme)

{

  GtkIconThemePrivate *priv = icon_theme->priv;

  GtkSettings *settings;

  GdkDisplay *display;

  if (priv->screen)

    {

      settings = gtk_settings_get_for_screen (priv->screen);

      display = gdk_screen_get_display (priv->screen);

      g_signal_handlers_disconnect_by_func (display,

					    (gpointer) display_closed,

					    icon_theme);

      g_signal_handlers_disconnect_by_func (settings,

					    (gpointer) theme_changed,

					    icon_theme);

      priv->screen = NULL;

    }

}

/**

 * gtk_icon_theme_set_screen:

 * @icon_theme: a #GtkIconTheme

 * @screen: a #GdkScreen

 * 

 * Sets the screen for an icon theme; the screen is used

 * to track the user's currently configured icon theme,

 * which might be different for different screens.

 *

 * Since: 2.4

 **/

void

gtk_icon_theme_set_screen (GtkIconTheme *icon_theme,

			   GdkScreen    *screen)

{

  GtkIconThemePrivate *priv;

  GtkSettings *settings;

  GdkDisplay *display;

  g_return_if_fail (GTK_ICON_THEME (icon_theme));

  g_return_if_fail (screen == NULL || GDK_IS_SCREEN (screen));

  priv = icon_theme->priv;

  unset_screen (icon_theme);

  if (screen)

    {

      display = gdk_screen_get_display (screen);

      settings = gtk_settings_get_for_screen (screen);

      priv->screen = screen;

      g_signal_connect (display, "closed",

			G_CALLBACK (display_closed), icon_theme);

      g_signal_connect (settings, "notify::gtk-icon-theme-name",

			G_CALLBACK (theme_changed), icon_theme);

      g_signal_connect (settings, "notify::gtk-fallback-icon-theme-name",

			G_CALLBACK (theme_changed), icon_theme);

    }

  update_current_theme (icon_theme);

}

/* Checks whether a loader for SVG files has been registered

 * with GdkPixbuf.

 */

static gboolean

pixbuf_supports_svg (void)

{

  GSList *formats;

  GSList *tmp_list;

  static gint found_svg = -1;

  if (found_svg != -1)

    return found_svg;

  formats = gdk_pixbuf_get_formats ();

  found_svg = FALSE; 

  for (tmp_list = formats; tmp_list && !found_svg; tmp_list = tmp_list->next)

    {

      gchar **mime_types = gdk_pixbuf_format_get_mime_types (tmp_list->data);

      gchar **mime_type;

      for (mime_type = mime_types; *mime_type && !found_svg; mime_type++)

	{

	  if (strcmp (*mime_type, "image/svg") == 0)

	    found_svg = TRUE;

	}

      g_strfreev (mime_types);

    }

  g_slist_free (formats);

  return found_svg;

}

static void

gtk_icon_theme_init (GtkIconTheme *icon_theme)

{

  GtkIconThemePrivate *priv;

  const gchar * const *xdg_data_dirs;

  int i, j;

  priv = g_type_instance_get_private ((GTypeInstance *)icon_theme,

				      GTK_TYPE_ICON_THEME);

  icon_theme->priv = priv;

  priv->custom_theme = FALSE;

  xdg_data_dirs = g_get_system_data_dirs ();

  for (i = 0; xdg_data_dirs[i]; i++) ;

  priv->search_path_len = 2 * i + 2;

  priv->search_path = g_new (char *, priv->search_path_len);

  i = 0;

  priv->search_path[i++] = g_build_filename (g_get_home_dir (), ".icons", NULL);

  priv->search_path[i++] = g_build_filename (g_get_user_data_dir (), "icons", NULL);

  for (j = 0; xdg_data_dirs[j]; j++) 

    priv->search_path[i++] = g_build_filename (xdg_data_dirs[j], "icons", NULL);

  for (j = 0; xdg_data_dirs[j]; j++) 

    priv->search_path[i++] = g_build_filename (xdg_data_dirs[j], "pixmaps", NULL);

  priv->themes_valid = FALSE;

  priv->themes = NULL;

  priv->unthemed_icons = NULL;

  priv->pixbuf_supports_svg = pixbuf_supports_svg ();

}

static void

free_dir_mtime (IconThemeDirMtime *dir_mtime)

{

  if (dir_mtime->cache)

    _gtk_icon_cache_unref (dir_mtime->cache);

  g_free (dir_mtime->dir);

  g_slice_free (IconThemeDirMtime, dir_mtime);

}

static gboolean

reset_styles_idle (gpointer user_data)

{

  GtkIconTheme *icon_theme;

  GtkIconThemePrivate *priv;

  icon_theme = GTK_ICON_THEME (user_data);

  priv = icon_theme->priv;

  if (priv->screen && priv->is_screen_singleton)

    {

      GtkSettings *settings = gtk_settings_get_for_screen (priv->screen);

      gtk_rc_reset_styles (settings);

    }

  priv->reset_styles_idle = 0;

  return FALSE;

}

static void

do_theme_change (GtkIconTheme *icon_theme)

{

  GtkIconThemePrivate *priv = icon_theme->priv;

  if (!priv->themes_valid)

    return;

  GTK_NOTE (ICONTHEME, 

	    g_print ("change to icon theme \"%s\"\n", priv->current_theme));

  blow_themes (icon_theme);

  g_signal_emit (icon_theme, signal_changed, 0);

  if (!priv->reset_styles_idle)

    priv->reset_styles_idle = 

      gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, 

		       reset_styles_idle, icon_theme, NULL);

}

static void

blow_themes (GtkIconTheme *icon_theme)

{

  GtkIconThemePrivate *priv = icon_theme->priv;

  if (priv->themes_valid)

    {

      g_hash_table_destroy (priv->all_icons);

      g_list_foreach (priv->themes, (GFunc)theme_destroy, NULL);

      g_list_free (priv->themes);

      g_list_foreach (priv->dir_mtimes, (GFunc)free_dir_mtime, NULL);

      g_list_free (priv->dir_mtimes);

      g_hash_table_destroy (priv->unthemed_icons);

    }

  priv->themes = NULL;

  priv->unthemed_icons = NULL;

  priv->dir_mtimes = NULL;

  priv->all_icons = NULL;

  priv->themes_valid = FALSE;

}

static void

gtk_icon_theme_finalize (GObject *object)

{

  GtkIconTheme *icon_theme;

  GtkIconThemePrivate *priv;

  int i;

  icon_theme = GTK_ICON_THEME (object);

  priv = icon_theme->priv;

  if (priv->reset_styles_idle)

    {

      g_source_remove (priv->reset_styles_idle);

      priv->reset_styles_idle = 0;

    }

  unset_screen (icon_theme);

  g_free (priv->current_theme);

  priv->current_theme = NULL;

  for (i = 0; i < priv->search_path_len; i++)

    g_free (priv->search_path[i]);

  g_free (priv->search_path);

  priv->search_path = NULL;

  blow_themes (icon_theme);

  G_OBJECT_CLASS (gtk_icon_theme_parent_class)->finalize (object);  

}

/**

 * gtk_icon_theme_set_search_path:

 * @icon_theme: a #GtkIconTheme

 * @path: (array length=n_elements) (element-type filename): array of

 *     directories that are searched for icon themes

 * @n_elements: number of elements in @path.

 * 

 * Sets the search path for the icon theme object. When looking

 * for an icon theme, GTK+ will search for a subdirectory of

 * one or more of the directories in @path with the same name

 * as the icon theme. (Themes from multiple of the path elements

 * are combined to allow themes to be extended by adding icons

 * in the user's home directory.)

 *

 * In addition if an icon found isn't found either in the current

 * icon theme or the default icon theme, and an image file with

 * the right name is found directly in one of the elements of

 * @path, then that image will be used for the icon name.

 * (This is legacy feature, and new icons should be put

 * into the default icon theme, which is called DEFAULT_THEME_NAME,

 * rather than directly on the icon path.)

 *

 * Since: 2.4

 **/

void

gtk_icon_theme_set_search_path (GtkIconTheme *icon_theme,

				const gchar  *path[],

				gint          n_elements)

{

  GtkIconThemePrivate *priv;

  gint i;

  g_return_if_fail (GTK_IS_ICON_THEME (icon_theme));

  priv = icon_theme->priv;

  for (i = 0; i < priv->search_path_len; i++)

    g_free (priv->search_path[i]);

  g_free (priv->search_path);

  priv->search_path = g_new (gchar *, n_elements);

  priv->search_path_len = n_elements;

  for (i = 0; i < priv->search_path_len; i++)

    priv->search_path[i] = g_strdup (path[i]);

  do_theme_change (icon_theme);

}

/**

 * gtk_icon_theme_get_search_path:

 * @icon_theme: a #GtkIconTheme

 * @path: (allow-none): (array length=n_elements) (out): location to store a list of icon theme path directories or %NULL

 *        The stored value should be freed with g_strfreev().

 * @n_elements: location to store number of elements

 *              in @path, or %NULL

 * 

 * Gets the current search path. See gtk_icon_theme_set_search_path().

 *

 * Since: 2.4

 **/

void

gtk_icon_theme_get_search_path (GtkIconTheme      *icon_theme,

				gchar            **path[],

				gint              *n_elements)

{

  GtkIconThemePrivate *priv;

  int i;

  g_return_if_fail (GTK_IS_ICON_THEME (icon_theme));

  priv = icon_theme->priv;

  if (n_elements)

    *n_elements = priv->search_path_len;

  if (path)

    {

      *path = g_new (gchar *, priv->search_path_len + 1);

      for (i = 0; i < priv->search_path_len; i++)

	(*path)[i] = g_strdup (priv->search_path[i]);

      (*path)[i] = NULL;

    }

}

/**

 * gtk_icon_theme_append_search_path:

 * @icon_theme: a #GtkIconTheme

 * @path: directory name to append to the icon path

 * 

 * Appends a directory to the search path. 

 * See gtk_icon_theme_set_search_path(). 

 *

 * Since: 2.4

 **/

void

gtk_icon_theme_append_search_path (GtkIconTheme *icon_theme,

				   const gchar  *path)

{

  GtkIconThemePrivate *priv;

  g_return_if_fail (GTK_IS_ICON_THEME (icon_theme));

  g_return_if_fail (path != NULL);

  priv = icon_theme->priv;

  priv->search_path_len++;

  priv->search_path = g_renew (gchar *, priv->search_path, priv->search_path_len);

  priv->search_path[priv->search_path_len-1] = g_strdup (path);

  do_theme_change (icon_theme);

}

/**

 * gtk_icon_theme_prepend_search_path:

 * @icon_theme: a #GtkIconTheme

 * @path: directory name to prepend to the icon path

 * 

 * Prepends a directory to the search path. 

 * See gtk_icon_theme_set_search_path().

 *

 * Since: 2.4

 **/

void

gtk_icon_theme_prepend_search_path (GtkIconTheme *icon_theme,

				    const gchar  *path)

{

  GtkIconThemePrivate *priv;

  int i;

  g_return_if_fail (GTK_IS_ICON_THEME (icon_theme));

  g_return_if_fail (path != NULL);

  priv = icon_theme->priv;

  priv->search_path_len++;

  priv->search_path = g_renew (gchar *, priv->search_path, priv->search_path_len);

  for (i = priv->search_path_len - 1; i > 0; i--)

    priv->search_path[i] = priv->search_path[i - 1];

  priv->search_path[0] = g_strdup (path);

  do_theme_change (icon_theme);

}

/**

 * gtk_icon_theme_set_custom_theme:

 * @icon_theme: a #GtkIconTheme

 * @theme_name: name of icon theme to use instead of configured theme,

 *   or %NULL to unset a previously set custom theme

 * 

 * Sets the name of the icon theme that the #GtkIconTheme object uses

 * overriding system configuration. This function cannot be called

 * on the icon theme objects returned from gtk_icon_theme_get_default()

 * and gtk_icon_theme_get_for_screen().

 *

 * Since: 2.4

 **/

void

gtk_icon_theme_set_custom_theme (GtkIconTheme *icon_theme,

				 const gchar  *theme_name)

{

  GtkIconThemePrivate *priv;

  g_return_if_fail (GTK_IS_ICON_THEME (icon_theme));

  priv = icon_theme->priv;

  g_return_if_fail (!priv->is_screen_singleton);

  if (theme_name != NULL)

    {

      priv->custom_theme = TRUE;

      if (!priv->current_theme || strcmp (theme_name, priv->current_theme) != 0)

	{

	  g_free (priv->current_theme);

	  priv->current_theme = g_strdup (theme_name);

	  do_theme_change (icon_theme);

	}

    }