Adding upstream version 2.10.36.upstream/2.10.36

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

1 files changed, 859 insertions, 0 deletions

diff --git a/libgimpconfig/gimpconfig-iface.c b/libgimpconfig/gimpconfig-iface.c
new file mode 100644
index 0000000..6604aca
--- /dev/null
+++ b/libgimpconfig/gimpconfig-iface.c
@@ -0,0 +1,859 @@
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
+ *
+ * Config file serialization and deserialization interface
+ * Copyright (C) 2001-2002  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
+ * Library 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 <string.h>
+
+#include <gio/gio.h>
+
+#include "libgimpbase/gimpbase.h"
+
+#include "gimpconfigtypes.h"
+
+#include "gimpconfigwriter.h"
+#include "gimpconfig-iface.h"
+#include "gimpconfig-deserialize.h"
+#include "gimpconfig-serialize.h"
+#include "gimpconfig-params.h"
+#include "gimpconfig-utils.h"
+#include "gimpscanner.h"
+
+#include "libgimp/libgimp-intl.h"
+
+
+/**
+ * SECTION: gimpconfig-iface
+ * @title: GimpConfig-iface
+ * @short_description: High-level API for libgimpconfig.
+ *
+ * High-level API for libgimpconfig.
+ **/
+
+
+/*
+ * The GimpConfig serialization and deserialization interface.
+ */
+
+
+/*  local function prototypes  */
+
+static void         gimp_config_iface_default_init (GimpConfigInterface *iface);
+static void         gimp_config_iface_base_init    (GimpConfigInterface *iface);
+
+static gboolean     gimp_config_iface_serialize    (GimpConfig          *config,
+                                                    GimpConfigWriter    *writer,
+                                                    gpointer             data);
+static gboolean     gimp_config_iface_deserialize  (GimpConfig          *config,
+                                                    GScanner            *scanner,
+                                                    gint                 nest_level,
+                                                    gpointer             data);
+static GimpConfig * gimp_config_iface_duplicate    (GimpConfig          *config);
+static gboolean     gimp_config_iface_equal        (GimpConfig          *a,
+                                                    GimpConfig          *b);
+static void         gimp_config_iface_reset        (GimpConfig          *config);
+static gboolean     gimp_config_iface_copy         (GimpConfig          *src,
+                                                    GimpConfig          *dest,
+                                                    GParamFlags          flags);
+
+
+/*  private functions  */
+
+
+GType
+gimp_config_get_type (void)
+{
+  static GType config_iface_type = 0;
+
+  if (! config_iface_type)
+    {
+      const GTypeInfo config_iface_info =
+      {
+        sizeof (GimpConfigInterface),
+        (GBaseInitFunc)      gimp_config_iface_base_init,
+        (GBaseFinalizeFunc)  NULL,
+        (GClassInitFunc)     gimp_config_iface_default_init,
+        (GClassFinalizeFunc) NULL,
+      };
+
+      config_iface_type = g_type_register_static (G_TYPE_INTERFACE,
+                                                  "GimpConfigInterface",
+                                                  &config_iface_info,
+                                                  0);
+
+      g_type_interface_add_prerequisite (config_iface_type, G_TYPE_OBJECT);
+    }
+
+  return config_iface_type;
+}
+
+GType
+gimp_config_interface_get_type (void)
+{
+  return gimp_config_get_type ();
+}
+
+static void
+gimp_config_iface_default_init (GimpConfigInterface *iface)
+{
+  iface->serialize   = gimp_config_iface_serialize;
+  iface->deserialize = gimp_config_iface_deserialize;
+  iface->duplicate   = gimp_config_iface_duplicate;
+  iface->equal       = gimp_config_iface_equal;
+  iface->reset       = gimp_config_iface_reset;
+  iface->copy        = gimp_config_iface_copy;
+}
+
+static void
+gimp_config_iface_base_init (GimpConfigInterface *iface)
+{
+  /*  always set these to NULL since we don't want to inherit them
+   *  from parent classes
+   */
+  iface->serialize_property   = NULL;
+  iface->deserialize_property = NULL;
+}
+
+static gboolean
+gimp_config_iface_serialize (GimpConfig       *config,
+                             GimpConfigWriter *writer,
+                             gpointer          data)
+{
+  return gimp_config_serialize_properties (config, writer);
+}
+
+static gboolean
+gimp_config_iface_deserialize (GimpConfig *config,
+                               GScanner   *scanner,
+                               gint        nest_level,
+                               gpointer    data)
+{
+  return gimp_config_deserialize_properties (config, scanner, nest_level);
+}
+
+static GimpConfig *
+gimp_config_iface_duplicate (GimpConfig *config)
+{
+  GObject       *object = G_OBJECT (config);
+  GObjectClass  *klass  = G_OBJECT_GET_CLASS (object);
+  GParamSpec   **property_specs;
+  guint          n_property_specs;
+  gint           n_construct_properties = 0;
+  const gchar  **construct_names        = NULL;
+  GValue        *construct_values       = NULL;
+  guint          i;
+  GObject       *dup;
+
+  property_specs = g_object_class_list_properties (klass, &n_property_specs);
+
+  construct_names  = g_new0 (const gchar *, n_property_specs);
+  construct_values = g_new0 (GValue,        n_property_specs);
+
+  for (i = 0; i < n_property_specs; i++)
+    {
+      GParamSpec *prop_spec = property_specs[i];
+
+      if ((prop_spec->flags & G_PARAM_READABLE) &&
+          (prop_spec->flags & G_PARAM_WRITABLE) &&
+          (prop_spec->flags & G_PARAM_CONSTRUCT_ONLY))
+        {
+          construct_names[n_construct_properties] = prop_spec->name;
+
+          g_value_init (&construct_values[n_construct_properties],
+                        prop_spec->value_type);
+          g_object_get_property (object, prop_spec->name,
+                                 &construct_values[n_construct_properties]);
+
+          n_construct_properties++;
+        }
+    }
+
+  g_free (property_specs);
+
+  dup = g_object_new_with_properties (G_TYPE_FROM_INSTANCE (object),
+                                      n_construct_properties,
+                                      (const gchar **) construct_names,
+                                      (const GValue *) construct_values);
+
+  for (i = 0; i < n_construct_properties; i++)
+    g_value_unset (&construct_values[i]);
+
+  g_free (construct_names);
+  g_free (construct_values);
+
+  gimp_config_copy (config, GIMP_CONFIG (dup), 0);
+
+  return GIMP_CONFIG (dup);
+}
+
+static gboolean
+gimp_config_iface_equal (GimpConfig *a,
+                         GimpConfig *b)
+{
+  GObjectClass  *klass;
+  GParamSpec   **property_specs;
+  guint          n_property_specs;
+  guint          i;
+  gboolean       equal = TRUE;
+
+  klass = G_OBJECT_GET_CLASS (a);
+
+  property_specs = g_object_class_list_properties (klass, &n_property_specs);
+
+  for (i = 0; equal && i < n_property_specs; i++)
+    {
+      GParamSpec  *prop_spec;
+      GValue       a_value = G_VALUE_INIT;
+      GValue       b_value = G_VALUE_INIT;
+
+      prop_spec = property_specs[i];
+
+      if (! (prop_spec->flags & G_PARAM_READABLE))
+        continue;
+
+      g_value_init (&a_value, prop_spec->value_type);
+      g_value_init (&b_value, prop_spec->value_type);
+      g_object_get_property (G_OBJECT (a), prop_spec->name, &a_value);
+      g_object_get_property (G_OBJECT (b), prop_spec->name, &b_value);
+
+      if (g_param_values_cmp (prop_spec, &a_value, &b_value))
+        {
+          if ((prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE) &&
+              G_IS_PARAM_SPEC_OBJECT (prop_spec)        &&
+              g_type_interface_peek (g_type_class_peek (prop_spec->value_type),
+                                     GIMP_TYPE_CONFIG))
+            {
+              if (! gimp_config_is_equal_to (g_value_get_object (&a_value),
+                                             g_value_get_object (&b_value)))
+                {
+                  equal = FALSE;
+                }
+            }
+          else
+            {
+              equal = FALSE;
+            }
+        }
+
+      g_value_unset (&a_value);
+      g_value_unset (&b_value);
+    }
+
+  g_free (property_specs);
+
+  return equal;
+}
+
+static void
+gimp_config_iface_reset (GimpConfig *config)
+{
+  gimp_config_reset_properties (G_OBJECT (config));
+}
+
+static gboolean
+gimp_config_iface_copy (GimpConfig  *src,
+                        GimpConfig  *dest,
+                        GParamFlags  flags)
+{
+  return gimp_config_sync (G_OBJECT (src), G_OBJECT (dest), flags);
+}
+
+
+/*  public functions  */
+
+
+/**
+ * gimp_config_serialize_to_file:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @filename: the name of the file to write the configuration to.
+ * @header: optional file header (must be ASCII only)
+ * @footer: optional file footer (must be ASCII only)
+ * @data: user data passed to the serialize implementation.
+ * @error: return location for a possible error
+ *
+ * Serializes the object properties of @config to the file specified
+ * by @filename. If a file with that name already exists, it is
+ * overwritten. Basically this function opens @filename for you and
+ * calls the serialize function of the @config's #GimpConfigInterface.
+ *
+ * Return value: %TRUE if serialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_config_serialize_to_file (GimpConfig   *config,
+                               const gchar  *filename,
+                               const gchar  *header,
+                               const gchar  *footer,
+                               gpointer      data,
+                               GError      **error)
+{
+  GimpConfigWriter *writer;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+  g_return_val_if_fail (filename != NULL, FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  writer = gimp_config_writer_new_file (filename, TRUE, header, error);
+  if (!writer)
+    return FALSE;
+
+  GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
+
+  return gimp_config_writer_finish (writer, footer, error);
+}
+
+/**
+ * gimp_config_serialize_to_gfile:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @file:   the #GFile to write the configuration to.
+ * @header: optional file header (must be ASCII only)
+ * @footer: optional file footer (must be ASCII only)
+ * @data: user data passed to the serialize implementation.
+ * @error: return location for a possible error
+ *
+ * Serializes the object properties of @config to the file specified
+ * by @file. If a file with that name already exists, it is
+ * overwritten. Basically this function opens @file for you and calls
+ * the serialize function of the @config's #GimpConfigInterface.
+ *
+ * Return value: %TRUE if serialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_config_serialize_to_gfile (GimpConfig   *config,
+                                GFile        *file,
+                                const gchar  *header,
+                                const gchar  *footer,
+                                gpointer      data,
+                                GError      **error)
+{
+  GimpConfigWriter *writer;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+  g_return_val_if_fail (G_IS_FILE (file), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  writer = gimp_config_writer_new_gfile (file, TRUE, header, error);
+  if (!writer)
+    return FALSE;
+
+  GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
+
+  return gimp_config_writer_finish (writer, footer, error);
+}
+
+/**
+ * gimp_config_serialize_to_stream:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @output: the #GOutputStream to write the configuration to.
+ * @header: optional file header (must be ASCII only)
+ * @footer: optional file footer (must be ASCII only)
+ * @data: user data passed to the serialize implementation.
+ * @error: return location for a possible error
+ *
+ * Serializes the object properties of @config to the stream specified
+ * by @output.
+ *
+ * Return value: %TRUE if serialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_config_serialize_to_stream (GimpConfig     *config,
+                                 GOutputStream  *output,
+                                 const gchar    *header,
+                                 const gchar    *footer,
+                                 gpointer        data,
+                                 GError        **error)
+{
+  GimpConfigWriter *writer;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+  g_return_val_if_fail (G_IS_OUTPUT_STREAM (output), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  writer = gimp_config_writer_new_stream (output, header, error);
+  if (!writer)
+    return FALSE;
+
+  GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
+
+  return gimp_config_writer_finish (writer, footer, error);
+}
+
+/**
+ * gimp_config_serialize_to_fd:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @fd: a file descriptor, opened for writing
+ * @data: user data passed to the serialize implementation.
+ *
+ * Serializes the object properties of @config to the given file
+ * descriptor.
+ *
+ * Return value: %TRUE if serialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_config_serialize_to_fd (GimpConfig *config,
+                             gint        fd,
+                             gpointer    data)
+{
+  GimpConfigWriter *writer;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+  g_return_val_if_fail (fd > 0, FALSE);
+
+  writer = gimp_config_writer_new_fd (fd);
+  if (!writer)
+    return FALSE;
+
+  GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
+
+  return gimp_config_writer_finish (writer, NULL, NULL);
+}
+
+/**
+ * gimp_config_serialize_to_string:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @data: user data passed to the serialize implementation.
+ *
+ * Serializes the object properties of @config to a string.
+ *
+ * Return value: a newly allocated NUL-terminated string.
+ *
+ * Since: 2.4
+ **/
+gchar *
+gimp_config_serialize_to_string (GimpConfig *config,
+                                 gpointer    data)
+{
+  GimpConfigWriter *writer;
+  GString          *str;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
+
+  str = g_string_new (NULL);
+  writer = gimp_config_writer_new_string (str);
+
+  GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
+
+  gimp_config_writer_finish (writer, NULL, NULL);
+
+  return g_string_free (str, FALSE);
+}
+
+/**
+ * gimp_config_deserialize_file:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @filename: the name of the file to read configuration from.
+ * @data: user data passed to the deserialize implementation.
+ * @error: return location for a possible error
+ *
+ * Opens the file specified by @filename, reads configuration data
+ * from it and configures @config accordingly. Basically this function
+ * creates a properly configured #GScanner for you and calls the
+ * deserialize function of the @config's #GimpConfigInterface.
+ *
+ * Return value: %TRUE if deserialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_config_deserialize_file (GimpConfig   *config,
+                              const gchar  *filename,
+                              gpointer      data,
+                              GError      **error)
+{
+  GScanner *scanner;
+  gboolean  success;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+  g_return_val_if_fail (filename != NULL, FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  scanner = gimp_scanner_new_file (filename, error);
+  if (! scanner)
+    return FALSE;
+
+  g_object_freeze_notify (G_OBJECT (config));
+
+  success = GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
+                                                             scanner, 0, data);
+
+  g_object_thaw_notify (G_OBJECT (config));
+
+  gimp_scanner_destroy (scanner);
+
+  if (! success)
+    g_assert (error == NULL || *error != NULL);
+
+  return success;
+}
+
+/**
+ * gimp_config_deserialize_gfile:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @file: the #GFile to read configuration from.
+ * @data: user data passed to the deserialize implementation.
+ * @error: return location for a possible error
+ *
+ * Opens the file specified by @file, reads configuration data from it
+ * and configures @config accordingly. Basically this function creates
+ * a properly configured #GScanner for you and calls the deserialize
+ * function of the @config's #GimpConfigInterface.
+ *
+ * Return value: %TRUE if deserialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_config_deserialize_gfile (GimpConfig  *config,
+                               GFile       *file,
+                               gpointer     data,
+                               GError     **error)
+{
+  GScanner *scanner;
+  gboolean  success;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+  g_return_val_if_fail (G_IS_FILE (file), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  scanner = gimp_scanner_new_gfile (file, error);
+  if (! scanner)
+    return FALSE;
+
+  g_object_freeze_notify (G_OBJECT (config));
+
+  success = GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
+                                                             scanner, 0, data);
+
+  g_object_thaw_notify (G_OBJECT (config));
+
+  gimp_scanner_destroy (scanner);
+
+  if (! success)
+    g_assert (error == NULL || *error != NULL);
+
+  return success;
+}
+
+/**
+ * gimp_config_deserialize_stream:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @input: the #GInputStream to read configuration from.
+ * @data: user data passed to the deserialize implementation.
+ * @error: return location for a possible error
+ *
+ * Reads configuration data from @input and configures @config
+ * accordingly. Basically this function creates a properly configured
+ * #GScanner for you and calls the deserialize function of the
+ * @config's #GimpConfigInterface.
+ *
+ * Return value: %TRUE if deserialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.10
+ **/
+gboolean
+gimp_config_deserialize_stream (GimpConfig    *config,
+                                GInputStream  *input,
+                                gpointer       data,
+                                GError       **error)
+{
+  GScanner *scanner;
+  gboolean  success;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+  g_return_val_if_fail (G_IS_INPUT_STREAM (input), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  scanner = gimp_scanner_new_stream (input, error);
+  if (! scanner)
+    return FALSE;
+
+  g_object_freeze_notify (G_OBJECT (config));
+
+  success = GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
+                                                             scanner, 0, data);
+
+  g_object_thaw_notify (G_OBJECT (config));
+
+  gimp_scanner_destroy (scanner);
+
+  if (! success)
+    g_assert (error == NULL || *error != NULL);
+
+  return success;
+}
+
+/**
+ * gimp_config_deserialize_string:
+ * @config:   a #GObject that implements the #GimpConfigInterface.
+ * @text:     string to deserialize (in UTF-8 encoding)
+ * @text_len: length of @text in bytes or -1
+ * @data:     client data
+ * @error:    return location for a possible error
+ *
+ * Configures @config from @text. Basically this function creates a
+ * properly configured #GScanner for you and calls the deserialize
+ * function of the @config's #GimpConfigInterface.
+ *
+ * Returns: %TRUE if deserialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_config_deserialize_string (GimpConfig      *config,
+                                const gchar  *text,
+                                gint          text_len,
+                                gpointer      data,
+                                GError      **error)
+{
+  GScanner *scanner;
+  gboolean  success;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+  g_return_val_if_fail (text != NULL || text_len == 0, FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  scanner = gimp_scanner_new_string (text, text_len, error);
+
+  g_object_freeze_notify (G_OBJECT (config));
+
+  success = GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
+                                                             scanner, 0, data);
+
+  g_object_thaw_notify (G_OBJECT (config));
+
+  gimp_scanner_destroy (scanner);
+
+  if (! success)
+    g_assert (error == NULL || *error != NULL);
+
+  return success;
+}
+
+/**
+ * gimp_config_deserialize_return:
+ * @scanner:        a #GScanner
+ * @expected_token: the expected token
+ * @nest_level:     the nest level
+ *
+ * Returns:
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_config_deserialize_return (GScanner     *scanner,
+                                GTokenType    expected_token,
+                                gint          nest_level)
+{
+  GTokenType next_token;
+
+  g_return_val_if_fail (scanner != NULL, FALSE);
+
+  next_token = g_scanner_peek_next_token (scanner);
+
+  if (expected_token != G_TOKEN_LEFT_PAREN)
+    {
+      g_scanner_get_next_token (scanner);
+      g_scanner_unexp_token (scanner, expected_token, NULL, NULL, NULL,
+                             _("fatal parse error"), TRUE);
+      return FALSE;
+    }
+  else
+    {
+      if (nest_level > 0 && next_token == G_TOKEN_RIGHT_PAREN)
+        {
+          return TRUE;
+        }
+      else if (next_token != G_TOKEN_EOF)
+        {
+          g_scanner_get_next_token (scanner);
+          g_scanner_unexp_token (scanner, expected_token, NULL, NULL, NULL,
+                                 _("fatal parse error"), TRUE);
+          return FALSE;
+        }
+    }
+
+  return TRUE;
+}
+
+
+/**
+ * gimp_config_serialize:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @writer: the #GimpConfigWriter to use.
+ * @data: client data
+ *
+ * Serialize the #GimpConfig object.
+ *
+ * Returns: %TRUE if serialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_config_serialize (GimpConfig       *config,
+                       GimpConfigWriter *writer,
+                       gpointer          data)
+{
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+
+  return GIMP_CONFIG_GET_INTERFACE (config)->serialize (config,
+                                                        writer,
+                                                        data);
+}
+
+/**
+ * gimp_config_deserialize:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ * @scanner: the #GScanner to use.
+ * @nest_level: the nest level.
+ * @data: client data.
+ *
+ * Deserialize the #GimpConfig object.
+ *
+ * Returns: %TRUE if deserialization succeeded, %FALSE otherwise.
+ *
+ * Since: 2.8
+ **/
+gboolean
+gimp_config_deserialize (GimpConfig *config,
+                         GScanner   *scanner,
+                         gint        nest_level,
+                         gpointer    data)
+{
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
+
+  return GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
+                                                          scanner,
+                                                          nest_level,
+                                                          data);
+}
+
+/**
+ * gimp_config_duplicate:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ *
+ * Creates a copy of the passed object by copying all object
+ * properties. The default implementation of the #GimpConfigInterface
+ * only works for objects that are completely defined by their
+ * properties.
+ *
+ * Return value: the duplicated #GimpConfig object
+ *
+ * Since: 2.4
+ **/
+gpointer
+gimp_config_duplicate (GimpConfig *config)
+{
+  g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
+
+  return GIMP_CONFIG_GET_INTERFACE (config)->duplicate (config);
+}
+
+/**
+ * gimp_config_is_equal_to:
+ * @a: a #GObject that implements the #GimpConfigInterface.
+ * @b: another #GObject of the same type as @a.
+ *
+ * Compares the two objects. The default implementation of the
+ * #GimpConfigInterface compares the object properties and thus only
+ * works for objects that are completely defined by their
+ * properties.
+ *
+ * Return value: %TRUE if the two objects are equal.
+ *
+ * Since: 2.4
+ **/
+gboolean
+gimp_config_is_equal_to (GimpConfig *a,
+                         GimpConfig *b)
+{
+  g_return_val_if_fail (GIMP_IS_CONFIG (a), FALSE);
+  g_return_val_if_fail (GIMP_IS_CONFIG (b), FALSE);
+  g_return_val_if_fail (G_TYPE_FROM_INSTANCE (a) == G_TYPE_FROM_INSTANCE (b),
+                        FALSE);
+
+  return GIMP_CONFIG_GET_INTERFACE (a)->equal (a, b);
+}
+
+/**
+ * gimp_config_reset:
+ * @config: a #GObject that implements the #GimpConfigInterface.
+ *
+ * Resets the object to its default state. The default implementation of the
+ * #GimpConfigInterface only works for objects that are completely defined by
+ * their properties.
+ *
+ * Since: 2.4
+ **/
+void
+gimp_config_reset (GimpConfig *config)
+{
+  g_return_if_fail (GIMP_IS_CONFIG (config));
+
+  g_object_freeze_notify (G_OBJECT (config));
+
+  GIMP_CONFIG_GET_INTERFACE (config)->reset (config);
+
+  g_object_thaw_notify (G_OBJECT (config));
+}
+
+/**
+ * gimp_config_copy:
+ * @src: a #GObject that implements the #GimpConfigInterface.
+ * @dest: another #GObject of the same type as @a.
+ * @flags: a mask of GParamFlags
+ *
+ * Compares all read- and write-able properties from @src and @dest
+ * that have all @flags set. Differing values are then copied from
+ * @src to @dest. If @flags is 0, all differing read/write properties.
+ *
+ * Properties marked as "construct-only" are not touched.
+ *
+ * Return value: %TRUE if @dest was modified, %FALSE otherwise
+ *
+ * Since: 2.6
+ **/
+gboolean
+gimp_config_copy (GimpConfig  *src,
+                  GimpConfig  *dest,
+                  GParamFlags  flags)
+{
+  gboolean changed;
+
+  g_return_val_if_fail (GIMP_IS_CONFIG (src), FALSE);
+  g_return_val_if_fail (GIMP_IS_CONFIG (dest), FALSE);
+  g_return_val_if_fail (G_TYPE_FROM_INSTANCE (src) == G_TYPE_FROM_INSTANCE (dest),
+                        FALSE);
+
+  g_object_freeze_notify (G_OBJECT (dest));
+
+  changed = GIMP_CONFIG_GET_INTERFACE (src)->copy (src, dest, flags);
+
+  g_object_thaw_notify (G_OBJECT (dest));
+
+  return changed;
+}