Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 978 insertions, 0 deletions

diff --git a/libgimpwidgets/gimpintcombobox.c b/libgimpwidgets/gimpintcombobox.c
new file mode 100644
index 0000000..6cd8909
--- /dev/null
+++ b/libgimpwidgets/gimpintcombobox.c
@@ -0,0 +1,978 @@
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
+ *
+ * gimpintcombobox.c
+ * Copyright (C) 2004  Sven Neumann <sven@gimp.org>
+ *
+ * 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 3 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, see
+ * <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <libintl.h>
+
+#include <gtk/gtk.h>
+
+#include "gimpwidgetstypes.h"
+
+#include "gimpintcombobox.h"
+#include "gimpintstore.h"
+
+
+/**
+ * SECTION: gimpintcombobox
+ * @title: GimpIntComboBox
+ * @short_description: A widget providing a popup menu of integer
+ *                     values (e.g. enums).
+ *
+ * A widget providing a popup menu of integer values (e.g. enums).
+ **/
+
+
+enum
+{
+  PROP_0,
+  PROP_ELLIPSIZE,
+  PROP_LABEL,
+  PROP_LAYOUT
+};
+
+
+typedef struct
+{
+  GtkCellRenderer        *pixbuf_renderer;
+  GtkCellRenderer        *text_renderer;
+
+  GtkCellRenderer        *menu_pixbuf_renderer;
+  GtkCellRenderer        *menu_text_renderer;
+
+  PangoEllipsizeMode      ellipsize;
+  gchar                  *label;
+  GtkCellRenderer        *label_renderer;
+  GimpIntComboBoxLayout   layout;
+
+  GimpIntSensitivityFunc  sensitivity_func;
+  gpointer                sensitivity_data;
+  GDestroyNotify          sensitivity_destroy;
+} GimpIntComboBoxPrivate;
+
+#define GIMP_INT_COMBO_BOX_GET_PRIVATE(obj) \
+  ((GimpIntComboBoxPrivate *) ((GimpIntComboBox *) (obj))->priv)
+
+
+static void  gimp_int_combo_box_finalize     (GObject         *object);
+static void  gimp_int_combo_box_set_property (GObject         *object,
+                                              guint            property_id,
+                                              const GValue    *value,
+                                              GParamSpec      *pspec);
+static void  gimp_int_combo_box_get_property (GObject         *object,
+                                              guint            property_id,
+                                              GValue          *value,
+                                              GParamSpec      *pspec);
+
+static void  gimp_int_combo_box_create_cells (GimpIntComboBox *combo_box);
+static void  gimp_int_combo_box_data_func    (GtkCellLayout   *layout,
+                                              GtkCellRenderer *cell,
+                                              GtkTreeModel    *model,
+                                              GtkTreeIter     *iter,
+                                              gpointer         data);
+
+
+G_DEFINE_TYPE_WITH_PRIVATE (GimpIntComboBox, gimp_int_combo_box,
+                            GTK_TYPE_COMBO_BOX)
+
+#define parent_class gimp_int_combo_box_parent_class
+
+
+static void
+gimp_int_combo_box_class_init (GimpIntComboBoxClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize     = gimp_int_combo_box_finalize;
+  object_class->set_property = gimp_int_combo_box_set_property;
+  object_class->get_property = gimp_int_combo_box_get_property;
+
+  /**
+   * GimpIntComboBox:ellipsize:
+   *
+   * Specifies the preferred place to ellipsize text in the combo-box,
+   * if the cell renderer does not have enough room to display the
+   * entire string.
+   *
+   * Since: 2.4
+   */
+  g_object_class_install_property (object_class, PROP_ELLIPSIZE,
+                                   g_param_spec_enum ("ellipsize",
+                                                      "Ellipsize",
+                                                      "Ellipsize mode for the used text cell renderer",
+                                                      PANGO_TYPE_ELLIPSIZE_MODE,
+                                                      PANGO_ELLIPSIZE_NONE,
+                                                      GIMP_PARAM_READWRITE));
+
+  /**
+   * GimpIntComboBox:label:
+   *
+   * Sets a label on the combo-box, see gimp_int_combo_box_set_label().
+   *
+   * Since: 2.10
+   */
+  g_object_class_install_property (object_class, PROP_LABEL,
+                                   g_param_spec_string ("label",
+                                                        "Label",
+                                                        "An optional label to be displayed",
+                                                        NULL,
+                                                        GIMP_PARAM_READWRITE));
+
+  /**
+   * GimpIntComboBox:layout:
+   *
+   * Specifies the combo box layout.
+   *
+   * Since: 2.10
+   */
+  g_object_class_install_property (object_class, PROP_LAYOUT,
+                                   g_param_spec_enum ("layout",
+                                                      "Layout",
+                                                      "Combo box layout",
+                                                      GIMP_TYPE_INT_COMBO_BOX_LAYOUT,
+                                                      GIMP_INT_COMBO_BOX_LAYOUT_ABBREVIATED,
+                                                      GIMP_PARAM_READWRITE));
+}
+
+static void
+gimp_int_combo_box_init (GimpIntComboBox *combo_box)
+{
+  GimpIntComboBoxPrivate *priv;
+  GtkListStore           *store;
+
+  combo_box->priv = priv = gimp_int_combo_box_get_instance_private (combo_box);
+
+  store = gimp_int_store_new ();
+  gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store));
+  g_object_unref (store);
+
+  priv->layout = GIMP_INT_COMBO_BOX_LAYOUT_ABBREVIATED;
+
+  gimp_int_combo_box_create_cells (GIMP_INT_COMBO_BOX (combo_box));
+}
+
+static void
+gimp_int_combo_box_finalize (GObject *object)
+{
+  GimpIntComboBoxPrivate *priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (object);
+
+  g_clear_pointer (&priv->label, g_free);
+
+  if (priv->sensitivity_destroy)
+    {
+      GDestroyNotify d = priv->sensitivity_destroy;
+
+      priv->sensitivity_destroy = NULL;
+      d (priv->sensitivity_data);
+    }
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_int_combo_box_set_property (GObject      *object,
+                                 guint         property_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+  GimpIntComboBoxPrivate *priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (object);
+
+  switch (property_id)
+    {
+    case PROP_ELLIPSIZE:
+      priv->ellipsize = g_value_get_enum (value);
+      if (priv->text_renderer)
+        {
+          g_object_set_property (G_OBJECT (priv->text_renderer),
+                                 pspec->name, value);
+        }
+      break;
+    case PROP_LABEL:
+      gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (object),
+                                    g_value_get_string (value));
+      break;
+    case PROP_LAYOUT:
+      gimp_int_combo_box_set_layout (GIMP_INT_COMBO_BOX (object),
+                                     g_value_get_enum (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_int_combo_box_get_property (GObject    *object,
+                                 guint       property_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+  GimpIntComboBoxPrivate *priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (object);
+
+  switch (property_id)
+    {
+    case PROP_ELLIPSIZE:
+      g_value_set_enum (value, priv->ellipsize);
+      break;
+    case PROP_LABEL:
+      g_value_set_string (value, priv->label);
+      break;
+    case PROP_LAYOUT:
+      g_value_set_enum (value, priv->layout);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+
+/**
+ * gimp_int_combo_box_new:
+ * @first_label: the label of the first item
+ * @first_value: the value of the first item
+ * @...: a %NULL terminated list of more label, value pairs
+ *
+ * Creates a GtkComboBox that has integer values associated with each
+ * item. The items to fill the combo box with are specified as a %NULL
+ * terminated list of label/value pairs.
+ *
+ * If you need to construct an empty #GimpIntComboBox, it's best to use
+ * g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL).
+ *
+ * Return value: a new #GimpIntComboBox.
+ *
+ * Since: 2.2
+ **/
+GtkWidget *
+gimp_int_combo_box_new (const gchar *first_label,
+                        gint         first_value,
+                        ...)
+{
+  GtkWidget *combo_box;
+  va_list    args;
+
+  va_start (args, first_value);
+
+  combo_box = gimp_int_combo_box_new_valist (first_label, first_value, args);
+
+  va_end (args);
+
+  return combo_box;
+}
+
+/**
+ * gimp_int_combo_box_new_valist:
+ * @first_label: the label of the first item
+ * @first_value: the value of the first item
+ * @values: a va_list with more values
+ *
+ * A variant of gimp_int_combo_box_new() that takes a va_list of
+ * label/value pairs. Probably only useful for language bindings.
+ *
+ * Return value: a new #GimpIntComboBox.
+ *
+ * Since: 2.2
+ **/
+GtkWidget *
+gimp_int_combo_box_new_valist (const gchar *first_label,
+                               gint         first_value,
+                               va_list      values)
+{
+  GtkWidget    *combo_box;
+  GtkListStore *store;
+  const gchar  *label;
+  gint          value;
+
+  combo_box = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL);
+
+  store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)));
+
+  for (label = first_label, value = first_value;
+       label;
+       label = va_arg (values, const gchar *), value = va_arg (values, gint))
+    {
+      GtkTreeIter  iter = { 0, };
+
+      gtk_list_store_append (store, &iter);
+      gtk_list_store_set (store, &iter,
+                          GIMP_INT_STORE_VALUE, value,
+                          GIMP_INT_STORE_LABEL, label,
+                          -1);
+    }
+
+  return combo_box;
+}
+
+/**
+ * gimp_int_combo_box_new_array:
+ * @n_values: the number of values
+ * @labels:   an array of labels (array length must be @n_values)
+ *
+ * A variant of gimp_int_combo_box_new() that takes an array of labels.
+ * The array indices are used as values.
+ *
+ * Return value: a new #GimpIntComboBox.
+ *
+ * Since: 2.2
+ **/
+GtkWidget *
+gimp_int_combo_box_new_array (gint         n_values,
+                              const gchar *labels[])
+{
+  GtkWidget    *combo_box;
+  GtkListStore *store;
+  gint          i;
+
+  g_return_val_if_fail (n_values >= 0, NULL);
+  g_return_val_if_fail (labels != NULL || n_values == 0, NULL);
+
+  combo_box = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL);
+
+  store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)));
+
+  for (i = 0; i < n_values; i++)
+    {
+      GtkTreeIter  iter;
+
+      if (labels[i])
+        {
+          gtk_list_store_append (store, &iter);
+          gtk_list_store_set (store, &iter,
+                              GIMP_INT_STORE_VALUE, i,
+                              GIMP_INT_STORE_LABEL, gettext (labels[i]),
+                              -1);
+        }
+    }
+
+  return combo_box;
+}
+
+/**
+ * gimp_int_combo_box_prepend:
+ * @combo_box: a #GimpIntComboBox
+ * @...:       pairs of column number and value, terminated with -1
+ *
+ * This function provides a convenient way to prepend items to a
+ * #GimpIntComboBox. It prepends a row to the @combo_box's list store
+ * and calls gtk_list_store_set() for you.
+ *
+ * The column number must be taken from the enum #GimpIntStoreColumns.
+ *
+ * Since: 2.2
+ **/
+void
+gimp_int_combo_box_prepend (GimpIntComboBox *combo_box,
+                            ...)
+{
+  GtkListStore *store;
+  GtkTreeIter   iter;
+  va_list       args;
+
+  g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box));
+
+  store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)));
+
+  va_start (args, combo_box);
+
+  gtk_list_store_prepend (store, &iter);
+  gtk_list_store_set_valist (store, &iter, args);
+
+  va_end (args);
+}
+
+/**
+ * gimp_int_combo_box_append:
+ * @combo_box: a #GimpIntComboBox
+ * @...:       pairs of column number and value, terminated with -1
+ *
+ * This function provides a convenient way to append items to a
+ * #GimpIntComboBox. It appends a row to the @combo_box's list store
+ * and calls gtk_list_store_set() for you.
+ *
+ * The column number must be taken from the enum #GimpIntStoreColumns.
+ *
+ * Since: 2.2
+ **/
+void
+gimp_int_combo_box_append (GimpIntComboBox *combo_box,
+                           ...)
+{
+  GtkListStore *store;
+  GtkTreeIter   iter;
+  va_list       args;
+
+  g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box));
+
+  store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)));
+
+  va_start (args, combo_box);
+
+  gtk_list_store_append (store, &iter);
+  gtk_list_store_set_valist (store, &iter, args);
+
+  va_end (args);
+}
+
+/**
+ * gimp_int_combo_box_set_active:
+ * @combo_box: a #GimpIntComboBox
+ * @value:     an integer value
+ *
+ * Looks up the item that belongs to the given @value and makes it the
+ * selected item in the @combo_box.
+ *
+ * Return value: %TRUE on success or %FALSE if there was no item for
+ *               this value.
+ *
+ * Since: 2.2
+ **/
+gboolean
+gimp_int_combo_box_set_active (GimpIntComboBox *combo_box,
+                               gint             value)
+{
+  GtkTreeModel *model;
+  GtkTreeIter   iter;
+
+  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), FALSE);
+
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));
+
+  if (gimp_int_store_lookup_by_value (model, value, &iter))
+    {
+      gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box), &iter);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+/**
+ * gimp_int_combo_box_get_active:
+ * @combo_box: a #GimpIntComboBox
+ * @value:     return location for the integer value
+ *
+ * Retrieves the value of the selected (active) item in the @combo_box.
+ *
+ * Return value: %TRUE if @value has been set or %FALSE if no item was
+ *               active.
+ *
+ * Since: 2.2
+ **/
+gboolean
+gimp_int_combo_box_get_active (GimpIntComboBox *combo_box,
+                               gint            *value)
+{
+  GtkTreeIter  iter;
+
+  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), FALSE);
+  g_return_val_if_fail (value != NULL, FALSE);
+
+  if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo_box), &iter))
+    {
+      gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)),
+                          &iter,
+                          GIMP_INT_STORE_VALUE, value,
+                          -1);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+/**
+ * gimp_int_combo_box_set_active_by_user_data:
+ * @combo_box: a #GimpIntComboBox
+ * @user_data: an integer value
+ *
+ * Looks up the item that has the given @user_data and makes it the
+ * selected item in the @combo_box.
+ *
+ * Return value: %TRUE on success or %FALSE if there was no item for
+ *               this user-data.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_int_combo_box_set_active_by_user_data (GimpIntComboBox *combo_box,
+                                            gpointer         user_data)
+{
+  GtkTreeModel *model;
+  GtkTreeIter   iter;
+
+  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), FALSE);
+
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));
+
+  if (gimp_int_store_lookup_by_user_data (model, user_data, &iter))
+    {
+      gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box), &iter);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+/**
+ * gimp_int_combo_box_get_active_user_data:
+ * @combo_box: a #GimpIntComboBox
+ * @user_data: return location for the gpointer value
+ *
+ * Retrieves the user-data of the selected (active) item in the @combo_box.
+ *
+ * Return value: %TRUE if @user_data has been set or %FALSE if no item was
+ *               active.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_int_combo_box_get_active_user_data (GimpIntComboBox *combo_box,
+                                         gpointer        *user_data)
+{
+  GtkTreeIter  iter;
+
+  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), FALSE);
+  g_return_val_if_fail (user_data != NULL, FALSE);
+
+  if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo_box), &iter))
+    {
+      gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)),
+                          &iter,
+                          GIMP_INT_STORE_USER_DATA, user_data,
+                          -1);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+/**
+ * gimp_int_combo_box_connect:
+ * @combo_box: a #GimpIntComboBox
+ * @value:     the value to set
+ * @callback:  a callback to connect to the @combo_box's "changed" signal
+ * @data:      a pointer passed as data to g_signal_connect()
+ *
+ * A convenience function that sets the initial @value of a
+ * #GimpIntComboBox and connects @callback to the "changed"
+ * signal.
+ *
+ * This function also calls the @callback once after setting the
+ * initial @value. This is often convenient when working with combo
+ * boxes that select a default active item, like for example
+ * gimp_drawable_combo_box_new(). If you pass an invalid initial
+ * @value, the @callback will be called with the default item active.
+ *
+ * Return value: the signal handler ID as returned by g_signal_connect()
+ *
+ * Since: 2.2
+ **/
+gulong
+gimp_int_combo_box_connect (GimpIntComboBox *combo_box,
+                            gint             value,
+                            GCallback        callback,
+                            gpointer         data)
+{
+  gulong handler = 0;
+
+  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), 0);
+
+  if (callback)
+    handler = g_signal_connect (combo_box, "changed", callback, data);
+
+  if (! gimp_int_combo_box_set_active (combo_box, value))
+    g_signal_emit_by_name (combo_box, "changed", NULL);
+
+  return handler;
+}
+
+/**
+ * gimp_int_combo_box_set_label:
+ * @combo_box: a #GimpIntComboBox
+ * @label:     a string to be shown as label
+ *
+ * Sets a caption on the @combo_box that will be displayed
+ * left-aligned inside the box. When a label is set, the remaining
+ * contents of the box will be right-aligned. This is useful for
+ * places where screen estate is rare, like in tool options.
+ *
+ * Since: 2.10
+ **/
+void
+gimp_int_combo_box_set_label (GimpIntComboBox *combo_box,
+                              const gchar     *label)
+{
+  GimpIntComboBoxPrivate *priv;
+
+  g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box));
+
+  priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box);
+
+  if (label == priv->label)
+    return;
+
+  g_free (priv->label);
+
+  priv->label = g_strdup (label);
+
+  gimp_int_combo_box_create_cells (combo_box);
+
+  g_object_notify (G_OBJECT (combo_box), "label");
+}
+
+/**
+ * gimp_int_combo_box_get_label:
+ * @combo_box: a #GimpIntComboBox
+ *
+ * Returns the label previously set with gimp_int_combo_box_set_label(),
+ * or %NULL,
+ *
+ * Return value: the @combo_box' label.
+ *
+ * Since: 2.10
+ **/
+const gchar *
+gimp_int_combo_box_get_label (GimpIntComboBox *combo_box)
+{
+  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box), NULL);
+
+  return GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box)->label;
+}
+
+/**
+ * gimp_int_combo_box_set_layout:
+ * @combo_box: a #GimpIntComboBox
+ * @layout:    the combo box layout
+ *
+ * Sets the layout of @combo_box to @layout.
+ *
+ * Since: 2.10
+ **/
+void
+gimp_int_combo_box_set_layout (GimpIntComboBox       *combo_box,
+                               GimpIntComboBoxLayout  layout)
+{
+  GimpIntComboBoxPrivate *priv;
+
+  g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box));
+
+  priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box);
+
+  if (layout == priv->layout)
+    return;
+
+  priv->layout = layout;
+
+  gimp_int_combo_box_create_cells (combo_box);
+
+  g_object_notify (G_OBJECT (combo_box), "layout");
+}
+
+/**
+ * gimp_int_combo_box_get_layout:
+ * @combo_box: a #GimpIntComboBox
+ *
+ * Returns the layout of @combo_box
+ *
+ * Return value: the @combo_box's layout.
+ *
+ * Since: 2.10
+ **/
+GimpIntComboBoxLayout
+gimp_int_combo_box_get_layout (GimpIntComboBox *combo_box)
+{
+  g_return_val_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box),
+                        GIMP_INT_COMBO_BOX_LAYOUT_ABBREVIATED);
+
+  return GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box)->layout;
+}
+
+/**
+ * gimp_int_combo_box_set_sensitivity:
+ * @combo_box: a #GimpIntComboBox
+ * @func: a function that returns a boolean value, or %NULL to unset
+ * @data: data to pass to @func
+ * @destroy: destroy notification for @data
+ *
+ * Sets a function that is used to decide about the sensitivity of
+ * rows in the @combo_box. Use this if you want to set certain rows
+ * insensitive.
+ *
+ * Calling gtk_widget_queue_draw() on the @combo_box will cause the
+ * sensitivity to be updated.
+ *
+ * Since: 2.4
+ **/
+void
+gimp_int_combo_box_set_sensitivity (GimpIntComboBox        *combo_box,
+                                    GimpIntSensitivityFunc  func,
+                                    gpointer                data,
+                                    GDestroyNotify          destroy)
+{
+  GimpIntComboBoxPrivate *priv;
+
+  g_return_if_fail (GIMP_IS_INT_COMBO_BOX (combo_box));
+
+  priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box);
+
+  if (priv->sensitivity_destroy)
+    {
+      GDestroyNotify d = priv->sensitivity_destroy;
+
+      priv->sensitivity_destroy = NULL;
+      d (priv->sensitivity_data);
+    }
+
+  priv->sensitivity_func    = func;
+  priv->sensitivity_data    = data;
+  priv->sensitivity_destroy = destroy;
+
+  gimp_int_combo_box_create_cells (combo_box);
+}
+
+
+/*  private functions  */
+
+static void
+queue_resize_cell_view (GtkContainer *container)
+{
+  GList *children = gtk_container_get_children (container);
+  GList *list;
+
+  for (list = children; list; list = g_list_next (list))
+    {
+      if (GTK_IS_CELL_VIEW (list->data))
+        {
+          gtk_widget_queue_resize (list->data);
+          break;
+        }
+      else if (GTK_IS_CONTAINER (list->data))
+        {
+          queue_resize_cell_view (list->data);
+        }
+    }
+
+  g_list_free (children);
+}
+
+static void
+gimp_int_combo_box_create_cells (GimpIntComboBox *combo_box)
+{
+  GimpIntComboBoxPrivate *priv = GIMP_INT_COMBO_BOX_GET_PRIVATE (combo_box);
+  GtkCellLayout          *layout;
+
+  /*  menu layout  */
+
+  layout = GTK_CELL_LAYOUT (combo_box);
+
+  gtk_cell_layout_clear (layout);
+
+  priv->menu_pixbuf_renderer = gtk_cell_renderer_pixbuf_new ();
+  g_object_set (priv->menu_pixbuf_renderer,
+                "xpad", 2,
+                NULL);
+
+  priv->menu_text_renderer = gtk_cell_renderer_text_new ();
+
+  gtk_cell_layout_pack_start (layout,
+                              priv->menu_pixbuf_renderer, FALSE);
+  gtk_cell_layout_pack_start (layout,
+                              priv->menu_text_renderer, TRUE);
+
+  gtk_cell_layout_set_attributes (layout,
+                                  priv->menu_pixbuf_renderer,
+                                  "icon-name", GIMP_INT_STORE_ICON_NAME,
+                                  "pixbuf",    GIMP_INT_STORE_PIXBUF,
+                                  NULL);
+  gtk_cell_layout_set_attributes (layout,
+                                  priv->menu_text_renderer,
+                                  "text", GIMP_INT_STORE_LABEL,
+                                  NULL);
+
+  if (priv->sensitivity_func)
+    {
+      gtk_cell_layout_set_cell_data_func (layout,
+                                          priv->menu_pixbuf_renderer,
+                                          gimp_int_combo_box_data_func,
+                                          priv, NULL);
+
+      gtk_cell_layout_set_cell_data_func (layout,
+                                          priv->menu_text_renderer,
+                                          gimp_int_combo_box_data_func,
+                                          priv, NULL);
+    }
+
+  /*  combo box layout  */
+
+  layout = GTK_CELL_LAYOUT (gtk_bin_get_child (GTK_BIN (combo_box)));
+
+  gtk_cell_layout_clear (layout);
+
+  if (priv->layout != GIMP_INT_COMBO_BOX_LAYOUT_ICON_ONLY)
+    {
+      priv->text_renderer = gtk_cell_renderer_text_new ();
+      g_object_set (priv->text_renderer,
+                    "ellipsize", priv->ellipsize,
+                    NULL);
+    }
+  else
+    {
+      priv->text_renderer = NULL;
+    }
+
+  priv->pixbuf_renderer = gtk_cell_renderer_pixbuf_new ();
+
+  if (priv->text_renderer)
+    {
+      g_object_set (priv->pixbuf_renderer,
+                    "xpad", 2,
+                    NULL);
+    }
+
+  if (priv->label)
+    {
+      priv->label_renderer = gtk_cell_renderer_text_new ();
+      g_object_set (priv->label_renderer,
+                    "text", priv->label,
+                    NULL);
+
+      gtk_cell_layout_pack_start (layout,
+                                  priv->label_renderer, FALSE);
+
+      gtk_cell_layout_pack_end (layout,
+                                priv->pixbuf_renderer, FALSE);
+
+      if (priv->text_renderer)
+        {
+          gtk_cell_layout_pack_end (layout,
+                                    priv->text_renderer, TRUE);
+
+          g_object_set (priv->text_renderer,
+                        "xalign", 1.0,
+                        NULL);
+        }
+    }
+  else
+    {
+      gtk_cell_layout_pack_start (layout,
+                                  priv->pixbuf_renderer, FALSE);
+
+      if (priv->text_renderer)
+        {
+          gtk_cell_layout_pack_start (layout,
+                                      priv->text_renderer, TRUE);
+        }
+    }
+
+  gtk_cell_layout_set_attributes (layout,
+                                  priv->pixbuf_renderer,
+                                  "icon-name", GIMP_INT_STORE_ICON_NAME,
+                                  NULL);
+
+  if (priv->text_renderer)
+    {
+      gtk_cell_layout_set_attributes (layout,
+                                      priv->text_renderer,
+                                      "text", GIMP_INT_STORE_LABEL,
+                                      NULL);
+    }
+
+  if (priv->layout == GIMP_INT_COMBO_BOX_LAYOUT_ABBREVIATED ||
+      priv->sensitivity_func)
+    {
+      gtk_cell_layout_set_cell_data_func (layout,
+                                          priv->pixbuf_renderer,
+                                          gimp_int_combo_box_data_func,
+                                          priv, NULL);
+
+      if (priv->text_renderer)
+        {
+          gtk_cell_layout_set_cell_data_func (layout,
+                                              priv->text_renderer,
+                                              gimp_int_combo_box_data_func,
+                                              priv, NULL);
+        }
+    }
+
+  /* HACK: GtkCellView doesn't invalidate itself when stuff is
+   * added/removed, work around this bug until GTK+ 2.24.19
+   */
+  if (gtk_check_version (2, 24, 19))
+    {
+      GList *attached_menus;
+
+      queue_resize_cell_view (GTK_CONTAINER (combo_box));
+
+      /* HACK HACK HACK OMG */
+      attached_menus = g_object_get_data (G_OBJECT (combo_box),
+                                          "gtk-attached-menus");
+
+      for (; attached_menus; attached_menus = g_list_next (attached_menus))
+        queue_resize_cell_view (attached_menus->data);
+    }
+}
+
+static void
+gimp_int_combo_box_data_func (GtkCellLayout   *layout,
+                              GtkCellRenderer *cell,
+                              GtkTreeModel    *model,
+                              GtkTreeIter     *iter,
+                              gpointer         data)
+{
+  GimpIntComboBoxPrivate *priv = data;
+
+  if (priv->layout == GIMP_INT_COMBO_BOX_LAYOUT_ABBREVIATED &&
+      cell == priv->text_renderer)
+    {
+      gchar *abbrev;
+
+      gtk_tree_model_get (model, iter,
+                          GIMP_INT_STORE_ABBREV, &abbrev,
+                          -1);
+
+      if (abbrev)
+        {
+          g_object_set (cell,
+                        "text", abbrev,
+                        NULL);
+
+          g_free (abbrev);
+        }
+    }
+
+  if (priv->sensitivity_func)
+    {
+      gint      value;
+      gboolean  sensitive;
+
+      gtk_tree_model_get (model, iter,
+                          GIMP_INT_STORE_VALUE, &value,
+                          -1);
+
+      sensitive = priv->sensitivity_func (value, priv->sensitivity_data);
+
+      g_object_set (cell,
+                    "sensitive", sensitive,
+                    NULL);
+    }
+}