dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app/widgets/gimpdocked.[ch] renamed GimpDockedIface to 

2003-10-11  Sven Neumann  <sven@gimp.org>

	* app/widgets/gimpdocked.[ch]
	* app/widgets/widgets-types.h: renamed GimpDockedIface to
	GimpDockedInterface.

	* app/display/gimpnavigationview.c
	* app/widgets/gimpcoloreditor.c
	* app/widgets/gimpcontainereditor.c
	* app/widgets/gimpcontainerview.c
	* app/widgets/gimpeditor.c
	* app/widgets/gimpimageeditor.c
	* app/widgets/gimpitemtreeview.c
	* app/widgets/gimptooloptionseditor.c: changed accordingly.

	* app/config/config-types.h
	* app/config/gimpconfig.[ch]
	* app/config/gimpconfig-deserialize.[ch]
	* app/config/gimpconfig-serialize.[ch]
	* app/config/gimpconfig-utils.[ch]: added a GimpConfig typedef and
	changed the GimpConfig API to take GimpConfig instead of GObject
	pointers.

	* app/config/gimpconfig-dump.c
	* app/config/gimprc.c
	* app/config/test-config.c
	* app/core/gimp-documents.c
	* app/core/gimp-parasites.c
	* app/core/gimp-templates.c
	* app/core/gimp.[ch]
	* app/core/gimpcontainer.c
	* app/core/gimpcontext.c
	* app/core/gimpdocumentlist.c
	* app/core/gimpgrid.c
	* app/core/gimpimage-duplicate.c
	* app/core/gimpimage-new.c
	* app/core/gimpimage.c
	* app/core/gimpparasitelist.c
	* app/core/gimptemplate.c
	* app/core/gimptooloptions.c
	* app/core/gimpviewable.c
	* app/gui/grid-dialog.c
	* app/gui/preferences-dialog.c
	* app/gui/stroke-dialog.c
	* app/gui/templates-commands.c
	* app/gui/tool-options-commands.c
	* app/paint/gimppaintcore.c
	* app/pdb/gimprc_cmds.c
	* app/text/gimptext-parasite.c
	* app/text/gimptext.c
	* app/text/gimptextlayer.c
	* app/tools/gimp-tools.c
	* app/tools/gimptexttool.c
	* app/widgets/gimpdevices.c
	* app/widgets/gimptemplateeditor.c
	* app/widgets/gimptemplateview.c
	* tools/pdbgen/pdb/gimprc.pdb: changed accordingly.
This commit is contained in:
Sven Neumann 2003-10-11 14:30:18 +00:00 committed by Sven Neumann
parent 99746e1d6c
commit a88e11afb3
70 changed files with 1092 additions and 1084 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
ChangeLog
View File

@ -1,3 +1,61 @@
2003-10-11 Sven Neumann <sven@gimp.org>
* app/widgets/gimpdocked.[ch]
* app/widgets/widgets-types.h: renamed GimpDockedIface to
GimpDockedInterface.
* app/display/gimpnavigationview.c
* app/widgets/gimpcoloreditor.c
* app/widgets/gimpcontainereditor.c
* app/widgets/gimpcontainerview.c
* app/widgets/gimpeditor.c
* app/widgets/gimpimageeditor.c
* app/widgets/gimpitemtreeview.c
* app/widgets/gimptooloptionseditor.c: changed accordingly.
* app/config/config-types.h
* app/config/gimpconfig.[ch]
* app/config/gimpconfig-deserialize.[ch]
* app/config/gimpconfig-serialize.[ch]
* app/config/gimpconfig-utils.[ch]: added a GimpConfig typedef and
changed the GimpConfig API to take GimpConfig instead of GObject
pointers.
* app/config/gimpconfig-dump.c
* app/config/gimprc.c
* app/config/test-config.c
* app/core/gimp-documents.c
* app/core/gimp-parasites.c
* app/core/gimp-templates.c
* app/core/gimp.[ch]
* app/core/gimpcontainer.c
* app/core/gimpcontext.c
* app/core/gimpdocumentlist.c
* app/core/gimpgrid.c
* app/core/gimpimage-duplicate.c
* app/core/gimpimage-new.c
* app/core/gimpimage.c
* app/core/gimpparasitelist.c
* app/core/gimptemplate.c
* app/core/gimptooloptions.c
* app/core/gimpviewable.c
* app/gui/grid-dialog.c
* app/gui/preferences-dialog.c
* app/gui/stroke-dialog.c
* app/gui/templates-commands.c
* app/gui/tool-options-commands.c
* app/paint/gimppaintcore.c
* app/pdb/gimprc_cmds.c
* app/text/gimptext-parasite.c
* app/text/gimptext.c
* app/text/gimptextlayer.c
* app/tools/gimp-tools.c
* app/tools/gimptexttool.c
* app/widgets/gimpdevices.c
* app/widgets/gimptemplateeditor.c
* app/widgets/gimptemplateview.c
* tools/pdbgen/pdb/gimprc.pdb: changed accordingly.
2003-10-10 Michael Natterer <mitch@gimp.org>
* app/widgets/Makefile.am

9
app/actions/templates-commands.c
View File

@ -24,6 +24,7 @@
#include "gui-types.h"
#include "config/gimpconfig.h"
#include "config/gimpconfig-utils.h"
#include "core/gimp.h"
@ -103,8 +104,8 @@ templates_new_template_ok_callback (GtkWidget *widget,
template = g_object_get_data (G_OBJECT (dialog), "gimp-template");
gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
gimp_config_copy_properties (G_OBJECT (editor->template),
G_OBJECT (template));
gimp_config_copy_properties (GIMP_CONFIG (editor->template),
GIMP_CONFIG (template));
gimp_list_uniquefy_name (GIMP_LIST (gimp->templates),
GIMP_OBJECT (template), TRUE);
@ -181,8 +182,8 @@ templates_edit_template_ok_callback (GtkWidget *widget,
template = g_object_get_data (G_OBJECT (dialog), "gimp-template");
gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
gimp_config_copy_properties (G_OBJECT (editor->template),
G_OBJECT (template));
gimp_config_copy_properties (GIMP_CONFIG (editor->template),
GIMP_CONFIG (template));
gimp_list_uniquefy_name (GIMP_LIST (gimp->templates),
GIMP_OBJECT (template), TRUE);

12
app/actions/tool-options-commands.c
View File

@ -66,8 +66,8 @@ tool_options_save_to_cmd_callback (GtkWidget *widget,
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (options)));
gimp_config_copy_properties (G_OBJECT (options->tool_info->tool_options),
G_OBJECT (options));
gimp_config_copy_properties (GIMP_CONFIG (options->tool_info->tool_options),
GIMP_CONFIG (options));
gimp_object_set_name (GIMP_OBJECT (options), name);
g_free (name);
@ -105,8 +105,8 @@ tool_options_restore_from_cmd_callback (GtkWidget *widget,
{
GimpToolOptions *options = GIMP_TOOL_OPTIONS (data);
gimp_config_copy_properties (G_OBJECT (options),
G_OBJECT (options->tool_info->tool_options));
gimp_config_copy_properties (GIMP_CONFIG (options),
GIMP_CONFIG (options->tool_info->tool_options));
}
void
@ -170,12 +170,12 @@ tool_options_save_callback (GtkWidget *widget,
gpointer data)
{
GimpToolInfo *tool_info = GIMP_TOOL_INFO (data);
GObject *copy;
GimpConfig *copy;
if (! name || ! strlen (name))
name = _("Saved Options");
copy = gimp_config_duplicate (G_OBJECT (tool_info->tool_options));
copy = gimp_config_duplicate (GIMP_CONFIG (tool_info->tool_options));
gimp_object_set_name (GIMP_OBJECT (copy), name);
gimp_list_uniquefy_name (GIMP_LIST (tool_info->options_presets),

3
app/config/config-types.h
View File

@ -23,6 +23,9 @@
#define __CONFIG_TYPES_H__
typedef struct _GimpConfig GimpConfig; /* dummy typedef */
typedef struct _GimpConfigInterface GimpConfigInterface;
typedef struct _GimpBaseConfig GimpBaseConfig;
typedef struct _GimpCoreConfig GimpCoreConfig;
typedef struct _GimpDisplayConfig GimpDisplayConfig;

96
app/config/gimpconfig-deserialize.c
View File

@ -54,13 +54,13 @@
* couldn't parse it.
*/
static GTokenType gimp_config_deserialize_unknown (GObject *object,
static GTokenType gimp_config_deserialize_unknown (GimpConfig *object,
GScanner *scanner);
static GTokenType gimp_config_deserialize_property (GObject *object,
static GTokenType gimp_config_deserialize_property (GimpConfig *object,
GScanner *scanner,
gint nest_level);
static GTokenType gimp_config_deserialize_value (GValue *value,
GObject *object,
GimpConfig *object,
GParamSpec *prop_spec,
GScanner *scanner);
static GTokenType gimp_config_deserialize_fundamental (GValue *value,
@ -82,12 +82,12 @@ static GTokenType gimp_config_deserialize_matrix2 (GValue *value,
GParamSpec *prop_spec,
GScanner *scanner);
static GTokenType gimp_config_deserialize_object (GValue *value,
GObject *object,
GimpConfig *object,
GParamSpec *prop_spec,
GScanner *scanner,
gint nest_level);
static GTokenType gimp_config_deserialize_value_array (GValue *value,
GObject *object,
GimpConfig *object,
GParamSpec *prop_spec,
GScanner *scanner);
static GTokenType gimp_config_deserialize_any (GValue *value,
@ -100,7 +100,7 @@ static inline gboolean scanner_string_utf8_valid (GScanner *scanner,
/**
* gimp_config_deserialize_properties:
* @object: a #GObject.
* @object: a #GimpConfig.
* @scanner: a #GScanner.
* @nest_level:
* @store_unknown_tokens: %TRUE if you want to store unknown tokens.
@ -116,10 +116,10 @@ static inline gboolean scanner_string_utf8_valid (GScanner *scanner,
* Return value:
**/
gboolean
gimp_config_deserialize_properties (GObject *object,
GScanner *scanner,
gint nest_level,
gboolean store_unknown_tokens)
gimp_config_deserialize_properties (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gboolean store_unknown_tokens)
{
GObjectClass *klass;
GParamSpec **property_specs;
@ -130,15 +130,15 @@ gimp_config_deserialize_properties (GObject *object,
GTokenType token;
GTokenType next;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
if (!property_specs)
return TRUE;
scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (object));
scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config));
old_scope_id = g_scanner_set_scope (scanner, scope_id);
for (i = 0; i < n_property_specs; i++)
@ -154,7 +154,7 @@ gimp_config_deserialize_properties (GObject *object,
g_free (property_specs);
g_object_freeze_notify (object);
g_object_freeze_notify (G_OBJECT (config));
token = G_TOKEN_LEFT_PAREN;
@ -178,11 +178,11 @@ gimp_config_deserialize_properties (GObject *object,
break;
case G_TOKEN_IDENTIFIER:
token = gimp_config_deserialize_unknown (object, scanner);
token = gimp_config_deserialize_unknown (config, scanner);
break;
case G_TOKEN_SYMBOL:
token = gimp_config_deserialize_property (object,
token = gimp_config_deserialize_property (config,
scanner, nest_level);
break;
@ -197,7 +197,7 @@ gimp_config_deserialize_properties (GObject *object,
g_scanner_set_scope (scanner, old_scope_id);
g_object_thaw_notify (object);
g_object_thaw_notify (G_OBJECT (config));
/* If store_unknown_tokens is TRUE but the unknown token value couldn't
be parsed the default error message is rather confusing.
@ -214,8 +214,8 @@ gimp_config_deserialize_properties (GObject *object,
}
static GTokenType
gimp_config_deserialize_unknown (GObject *object,
GScanner *scanner)
gimp_config_deserialize_unknown (GimpConfig *object,
GScanner *scanner)
{
gchar *key;
@ -239,12 +239,12 @@ gimp_config_deserialize_unknown (GObject *object,
}
static GTokenType
gimp_config_deserialize_property (GObject *object,
gimp_config_deserialize_property (GimpConfig *config,
GScanner *scanner,
gint nest_level)
{
GTypeClass *owner_class;
GimpConfigInterface *gimp_config_iface;
GimpConfigInterface *config_iface;
GimpConfigInterface *parent_iface;
GParamSpec *prop_spec;
GTokenType token = G_TOKEN_RIGHT_PAREN;
@ -256,8 +256,7 @@ gimp_config_deserialize_property (GObject *object,
owner_class = g_type_class_peek (prop_spec->owner_type);
gimp_config_iface = g_type_interface_peek (owner_class,
GIMP_TYPE_CONFIG_INTERFACE);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
@ -269,25 +268,25 @@ gimp_config_deserialize_property (GObject *object,
* GimpConfigInterface is inherited from one of it's parent classes
* and thus not able to handle param_spec->owner_type's properties).
*/
if (gimp_config_iface)
if (config_iface)
{
GTypeClass *owner_parent_class;
owner_parent_class = g_type_class_peek_parent (owner_class),
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG_INTERFACE);
GIMP_TYPE_CONFIG);
}
if (gimp_config_iface &&
gimp_config_iface != parent_iface && /* see comment above */
gimp_config_iface->deserialize_property &&
gimp_config_iface->deserialize_property (object,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->deserialize_property &&
config_iface->deserialize_property (config,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
{
/* nop */
}
@ -295,11 +294,11 @@ gimp_config_deserialize_property (GObject *object,
{
if (G_VALUE_HOLDS_OBJECT (&value))
token = gimp_config_deserialize_object (&value,
object, prop_spec,
config, prop_spec,
scanner, nest_level);
else
token = gimp_config_deserialize_value (&value,
object, prop_spec, scanner);
config, prop_spec, scanner);
}
if (token == G_TOKEN_RIGHT_PAREN &&
@ -307,13 +306,13 @@ gimp_config_deserialize_property (GObject *object,
{
if (! (G_VALUE_HOLDS_OBJECT (&value) &&
(prop_spec->flags & GIMP_PARAM_AGGREGATE)))
g_object_set_property (object, prop_spec->name, &value);
g_object_set_property (G_OBJECT (config), prop_spec->name, &value);
}
#ifdef CONFIG_DEBUG
else
{
g_warning ("couldn't deserialize property %s::%s of type %s",
g_type_name (G_TYPE_FROM_INSTANCE (object)),
g_type_name (G_TYPE_FROM_INSTANCE (config)),
prop_spec->name,
g_type_name (prop_spec->value_type));
}
@ -326,7 +325,7 @@ gimp_config_deserialize_property (GObject *object,
static GTokenType
gimp_config_deserialize_value (GValue *value,
GObject *object,
GimpConfig *object,
GParamSpec *prop_spec,
GScanner *scanner)
{
@ -625,28 +624,27 @@ gimp_config_deserialize_matrix2 (GValue *value,
static GTokenType
gimp_config_deserialize_object (GValue *value,
GObject *object,
GimpConfig *config,
GParamSpec *prop_spec,
GScanner *scanner,
gint nest_level)
{
GimpConfigInterface *gimp_config_iface;
GObject *prop_object;
GimpConfigInterface *config_iface;
GimpConfig *prop_object;
g_object_get_property (object, prop_spec->name, value);
g_object_get_property (G_OBJECT (config), prop_spec->name, value);
prop_object = g_value_get_object (value);
if (! prop_object)
return G_TOKEN_RIGHT_PAREN;
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (prop_object);
config_iface = GIMP_CONFIG_GET_INTERFACE (prop_object);
if (! gimp_config_iface)
if (! config_iface)
return gimp_config_deserialize_any (value, prop_spec, scanner);
if (! gimp_config_iface->deserialize (prop_object,
scanner, nest_level + 1, NULL))
if (! config_iface->deserialize (prop_object, scanner, nest_level + 1, NULL))
return G_TOKEN_NONE;
return G_TOKEN_RIGHT_PAREN;
@ -654,7 +652,7 @@ gimp_config_deserialize_object (GValue *value,
static GTokenType
gimp_config_deserialize_value_array (GValue *value,
GObject *object,
GimpConfig *config,
GParamSpec *prop_spec,
GScanner *scanner)
{
@ -677,7 +675,7 @@ gimp_config_deserialize_value_array (GValue *value,
g_value_init (&array_value, array_spec->element_spec->value_type);
token = gimp_config_deserialize_value (&array_value,
object,
config,
array_spec->element_spec,
scanner);

8
app/config/gimpconfig-deserialize.h
View File

@ -23,10 +23,10 @@
#define __GIMP_CONFIG_DESERIALIZE_H__
gboolean gimp_config_deserialize_properties (GObject *object,
GScanner *scanner,
gint nest_level,
gboolean store_unknown_tokens);
gboolean gimp_config_deserialize_properties (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gboolean store_unknown_tokens);
#endif /* __GIMP_CONFIG_DESERIALIZE_H__ */

26
app/config/gimpconfig-dump.c
View File

@ -1,9 +1,9 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* GimpConfig object property dumper.
* GimpConfig object property dumper.
* Copyright (C) 2001-2003 Sven Neumann <sven@gimp.org>
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
@ -54,10 +54,10 @@ typedef enum
static gint dump_gimprc (DumpFormat format);
static void dump_gimprc_system (GObject *rc,
static void dump_gimprc_system (GimpConfig *rc,
GimpConfigWriter *writer,
gint fd);
static void dump_gimprc_manpage (GObject *rc,
static void dump_gimprc_manpage (GimpConfig *rc,
GimpConfigWriter *writer,
gint fd);
static gchar * dump_describe_param (GParamSpec *param_spec);
@ -70,7 +70,7 @@ main (int argc,
char *argv[])
{
DumpFormat format = DUMP_DEFAULT;
if (argc > 1)
{
if (strcmp (argv[1], "--system-gimprc") == 0)
@ -111,7 +111,7 @@ static gint
dump_gimprc (DumpFormat format)
{
GimpConfigWriter *writer;
GObject *rc;
GimpConfig *rc;
gint fd = 1;
if (format == DUMP_NONE)
@ -159,7 +159,7 @@ static const gchar *system_gimprc_header =
"Lines that start with a '#' are comments. Blank lines are ignored.\n"
"\n"
"By default everything in this file is commented out. The file then "
"documents the default values and shows what changes are possible.\n"
"documents the default values and shows what changes are possible.\n"
"\n"
"The variable ${gimp_dir} is set to the value of the environment "
"variable GIMP2_DIRECTORY or, if that is not set, the compiled-in "
@ -167,7 +167,7 @@ static const gchar *system_gimprc_header =
"it is interpreted relative to your home directory.";
static void
dump_gimprc_system (GObject *rc,
dump_gimprc_system (GimpConfig *rc,
GimpConfigWriter *writer,
gint fd)
{
@ -296,7 +296,7 @@ static const gchar *man_page_footer =
static void
dump_gimprc_manpage (GObject *rc,
dump_gimprc_manpage (GimpConfig *rc,
GimpConfigWriter *writer,
gint fd)
{
@ -340,7 +340,7 @@ dump_gimprc_manpage (GObject *rc,
}
static const gchar * display_format_description =
static const gchar * display_format_description =
"This is a format string; certain % character sequences are recognised and "
"expanded as follows:\n"
"\n"
@ -425,7 +425,7 @@ dump_describe_param (GParamSpec *param_spec)
case GIMP_PARAM_PATH_DIR:
values = "This is a single folder.";
break;
case GIMP_PARAM_PATH_DIR_LIST:
switch (G_SEARCHPATH_SEPARATOR)
{
@ -484,9 +484,9 @@ dump_describe_param (GParamSpec *param_spec)
GEnumValue *enum_value;
GString *str;
gint i;
enum_class = g_type_class_peek (type);
str = g_string_new (blurb);
g_string_append (str, " Possible values are ");

78
app/config/gimpconfig-serialize.c
View File

@ -54,7 +54,7 @@ static void serialize_unknown_token (const gchar *key,
/**
* gimp_config_serialize_properties:
* @object: a #GObject.
* @config: a #GimpConfig.
* @writer: a #GimpConfigWriter.
*
* This function writes all object properties to the @writer.
@ -62,7 +62,7 @@ static void serialize_unknown_token (const gchar *key,
* Returns: %TRUE if serialization succeeded, %FALSE otherwise
**/
gboolean
gimp_config_serialize_properties (GObject *object,
gimp_config_serialize_properties (GimpConfig *config,
GimpConfigWriter *writer)
{
GObjectClass *klass;
@ -70,9 +70,9 @@ gimp_config_serialize_properties (GObject *object,
guint n_property_specs;
guint i;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (G_IS_OBJECT (config), FALSE);
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
@ -86,7 +86,7 @@ gimp_config_serialize_properties (GObject *object,
if (! (prop_spec->flags & GIMP_PARAM_SERIALIZE))
continue;
if (! gimp_config_serialize_property (object, prop_spec, writer))
if (! gimp_config_serialize_property (config, prop_spec, writer))
return FALSE;
}
@ -97,7 +97,7 @@ gimp_config_serialize_properties (GObject *object,
/**
* gimp_config_serialize_changed_properties:
* @object: a #GObject.
* @config: a #GimpConfig.
* @writer: a #GimpConfigWriter.
*
* This function writes all object properties that have been changed from
@ -106,7 +106,7 @@ gimp_config_serialize_properties (GObject *object,
* Returns: %TRUE if serialization succeeded, %FALSE otherwise
**/
gboolean
gimp_config_serialize_changed_properties (GObject *object,
gimp_config_serialize_changed_properties (GimpConfig *config,
GimpConfigWriter *writer)
{
GObjectClass *klass;
@ -115,9 +115,9 @@ gimp_config_serialize_changed_properties (GObject *object,
guint i;
GValue value = { 0, };
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (G_IS_OBJECT (config), FALSE);
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
@ -132,11 +132,11 @@ gimp_config_serialize_changed_properties (GObject *object,
continue;
g_value_init (&value, prop_spec->value_type);
g_object_get_property (object, prop_spec->name, &value);
g_object_get_property (G_OBJECT (config), prop_spec->name, &value);
if (! g_param_value_defaults (prop_spec, &value))
{
if (! gimp_config_serialize_property (object, prop_spec, writer))
if (! gimp_config_serialize_property (config, prop_spec, writer))
return FALSE;
}
@ -150,33 +150,33 @@ gimp_config_serialize_changed_properties (GObject *object,
/**
* gimp_config_serialize_properties_diff:
* @object: a #GObject.
* @compare: a #GObject of the same type as @object.
* @config: a #GimpConfig.
* @compare: a #GimpConfig of the same type as @config.
* @writer: a #GimpConfigWriter.
*
* This function compares @object and @compare and writes all
* properties of @object that have different values than @compare to
* This function compares @config and @compare and writes all
* properties of @config that have different values than @compare to
* the @writer.
*
* Returns: %TRUE if serialization succeeded, %FALSE otherwise
**/
gboolean
gimp_config_serialize_properties_diff (GObject *object,
GObject *compare,
gimp_config_serialize_properties_diff (GimpConfig *config,
GimpConfig *compare,
GimpConfigWriter *writer)
{
GObjectClass *klass;
GList *diff;
GList *list;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (G_IS_OBJECT (config), FALSE);
g_return_val_if_fail (G_IS_OBJECT (compare), FALSE);
g_return_val_if_fail (G_TYPE_FROM_INSTANCE (object) ==
g_return_val_if_fail (G_TYPE_FROM_INSTANCE (config) ==
G_TYPE_FROM_INSTANCE (compare), FALSE);
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
diff = gimp_config_diff (object, compare, GIMP_PARAM_SERIALIZE);
diff = gimp_config_diff (config, compare, GIMP_PARAM_SERIALIZE);
if (! diff)
return TRUE;
@ -188,7 +188,7 @@ gimp_config_serialize_properties_diff (GObject *object,
if (! (prop_spec->flags & GIMP_PARAM_SERIALIZE))
continue;
if (! gimp_config_serialize_property (object, prop_spec, writer))
if (! gimp_config_serialize_property (config, prop_spec, writer))
return FALSE;
}
@ -199,7 +199,7 @@ gimp_config_serialize_properties_diff (GObject *object,
gboolean
gimp_config_serialize_property (GObject *object,
gimp_config_serialize_property (GimpConfig *config,
GParamSpec *param_spec,
GimpConfigWriter *writer)
{
@ -213,12 +213,11 @@ gimp_config_serialize_property (GObject *object,
return FALSE;
g_value_init (&value, param_spec->value_type);
g_object_get_property (object, param_spec->name, &value);
g_object_get_property (G_OBJECT (config), param_spec->name, &value);
owner_class = g_type_class_peek (param_spec->owner_type);
config_iface = g_type_interface_peek (owner_class,
GIMP_TYPE_CONFIG_INTERFACE);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
@ -237,13 +236,13 @@ gimp_config_serialize_property (GObject *object,
owner_parent_class = g_type_class_peek_parent (owner_class),
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG_INTERFACE);
GIMP_TYPE_CONFIG);
}
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->serialize_property &&
config_iface->serialize_property (object,
config_iface->serialize_property (config,
param_spec->param_id,
(const GValue *) &value,
param_spec,
@ -261,22 +260,21 @@ gimp_config_serialize_property (GObject *object,
if (G_VALUE_HOLDS_OBJECT (&value) &&
(param_spec->flags & GIMP_PARAM_AGGREGATE))
{
GimpConfigInterface *gimp_config_iface = NULL;
GObject *prop_object;
GimpConfigInterface *config_iface = NULL;
GimpConfig *prop_object;
prop_object = g_value_get_object (&value);
if (prop_object)
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (prop_object);
config_iface = GIMP_CONFIG_GET_INTERFACE (prop_object);
else
success = TRUE;
if (gimp_config_iface)
if (config_iface)
{
gimp_config_writer_open (writer, param_spec->name);
success = gimp_config_iface->serialize (prop_object, writer,
NULL);
success = config_iface->serialize (prop_object, writer, NULL);
if (success)
gimp_config_writer_close (writer);
@ -310,7 +308,7 @@ gimp_config_serialize_property (GObject *object,
else
{
g_warning ("couldn't serialize property %s::%s of type %s",
g_type_name (G_TYPE_FROM_INSTANCE (object)),
g_type_name (G_TYPE_FROM_INSTANCE (config)),
param_spec->name,
g_type_name (param_spec->value_type));
}
@ -482,22 +480,22 @@ gimp_config_serialize_value (const GValue *value,
/**
* gimp_config_serialize_unknown_tokens:
* @object: a #GObject.
* @config: a #GimpConfig.
* @writer: a #GimpConfigWriter.
*
* Writes all unknown tokens attached to #object to the @writer. See
* Writes all unknown tokens attached to @config to the @writer. See
* gimp_config_add_unknown_token().
*
* Returns: %TRUE if serialization succeeded, %FALSE otherwise
**/
gboolean
gimp_config_serialize_unknown_tokens (GObject *object,
gimp_config_serialize_unknown_tokens (GimpConfig *config,
GimpConfigWriter *writer)
{
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (G_IS_OBJECT (config), FALSE);
gimp_config_writer_linefeed (writer);
gimp_config_foreach_unknown_token (object, serialize_unknown_token, writer);
gimp_config_foreach_unknown_token (config, serialize_unknown_token, writer);
return TRUE;
}

12
app/config/gimpconfig-serialize.h
View File

@ -23,17 +23,17 @@
#define __GIMP_CONFIG_SERIALIZE_H__
gboolean gimp_config_serialize_properties (GObject *object,
gboolean gimp_config_serialize_properties (GimpConfig *config,
GimpConfigWriter *writer);
gboolean gimp_config_serialize_changed_properties (GObject *object,
gboolean gimp_config_serialize_changed_properties (GimpConfig *config,
GimpConfigWriter *writer);
gboolean gimp_config_serialize_properties_diff (GObject *object,
GObject *compare,
gboolean gimp_config_serialize_properties_diff (GimpConfig *config,
GimpConfig *compare,
GimpConfigWriter *writer);
gboolean gimp_config_serialize_unknown_tokens (GObject *object,
gboolean gimp_config_serialize_unknown_tokens (GimpConfig *config,
GimpConfigWriter *writer);
gboolean gimp_config_serialize_property (GObject *object,
gboolean gimp_config_serialize_property (GimpConfig *config,
GParamSpec *param_spec,
GimpConfigWriter *writer);

67
app/config/gimpconfig-utils.c
View File

@ -36,8 +36,8 @@
/**
* gimp_config_diff:
* @a: a #GObject
* @b: another #GObject of the same type as @a
* @a: a #GimpConfig
* @b: another #GimpConfig of the same type as @a
* @flags: a mask of GParamFlags
*
* Compares all properties of @a and @b that have all @flags set. If
@ -46,8 +46,8 @@
* Return value: a GList of differing GParamSpecs.
**/
GList *
gimp_config_diff (GObject *a,
GObject *b,
gimp_config_diff (GimpConfig *a,
GimpConfig *b,
GParamFlags flags)
{
GParamSpec **param_specs;
@ -73,14 +73,14 @@ gimp_config_diff (GObject *a,
g_value_init (&a_value, param_specs[i]->value_type);
g_value_init (&b_value, param_specs[i]->value_type);
g_object_get_property (a, param_specs[i]->name, &a_value);
g_object_get_property (b, param_specs[i]->name, &b_value);
g_object_get_property (G_OBJECT (a), param_specs[i]->name, &a_value);
g_object_get_property (G_OBJECT (b), param_specs[i]->name, &b_value);
if (G_IS_PARAM_SPEC_OBJECT (param_specs[i]) &&
(param_specs[i]->flags & GIMP_PARAM_AGGREGATE))
{
GObject *a_object = g_value_get_object (&a_value);
GObject *b_object = g_value_get_object (&b_value);
GimpConfig *a_object = g_value_get_object (&a_value);
GimpConfig *b_object = g_value_get_object (&b_value);
if (a_object && b_object &&
G_TYPE_FROM_INSTANCE (a_object) ==
@ -180,23 +180,23 @@ gimp_config_disconnect (GObject *src,
/**
* gimp_config_copy_properties:
* @src: a #GObject
* @dest: another #GObject of the same type as @src
* @src: a #GimpConfig
* @dest: another #GimpConfig of the same type as @src
*
* Retrieves all read and writeable property settings from @src and
* applies the values to @dest.
**/
void
gimp_config_copy_properties (GObject *src,
GObject *dest)
gimp_config_copy_properties (GimpConfig *src,
GimpConfig *dest)
{
GObjectClass *klass;
GParamSpec **property_specs;
guint n_property_specs;
guint i;
g_return_if_fail (G_IS_OBJECT (src));
g_return_if_fail (G_IS_OBJECT (dest));
g_return_if_fail (GIMP_IS_CONFIG (src));
g_return_if_fail (GIMP_IS_CONFIG (dest));
g_return_if_fail (G_TYPE_FROM_INSTANCE (src) == G_TYPE_FROM_INSTANCE (dest));
klass = G_OBJECT_GET_CLASS (src);
@ -206,7 +206,7 @@ gimp_config_copy_properties (GObject *src,
if (!property_specs)
return;
g_object_freeze_notify (dest);
g_object_freeze_notify (G_OBJECT (dest));
for (i = 0; i < n_property_specs; i++)
{
@ -221,16 +221,18 @@ gimp_config_copy_properties (GObject *src,
if (G_IS_PARAM_SPEC_OBJECT (prop_spec) &&
(prop_spec->flags & GIMP_PARAM_AGGREGATE))
{
GValue src_value = { 0, };
GValue dest_value = { 0, };
GObject *src_object;
GObject *dest_object;
GValue src_value = { 0, };
GValue dest_value = { 0, };
GimpConfig *src_object;
GimpConfig *dest_object;
g_value_init (&src_value, prop_spec->value_type);
g_value_init (&dest_value, prop_spec->value_type);
g_object_get_property (src, prop_spec->name, &src_value);
g_object_get_property (dest, prop_spec->name, &dest_value);
g_object_get_property (G_OBJECT (src),
prop_spec->name, &src_value);
g_object_get_property (G_OBJECT (dest),
prop_spec->name, &dest_value);
src_object = g_value_get_object (&src_value);
dest_object = g_value_get_object (&dest_value);
@ -251,8 +253,8 @@ gimp_config_copy_properties (GObject *src,
g_value_init (&value, prop_spec->value_type);
g_object_get_property (src, prop_spec->name, &value);
g_object_set_property (dest, prop_spec->name, &value);
g_object_get_property (G_OBJECT (src), prop_spec->name, &value);
g_object_set_property (G_OBJECT (dest), prop_spec->name, &value);
g_value_unset (&value);
}
@ -261,34 +263,37 @@ gimp_config_copy_properties (GObject *src,
g_free (property_specs);
g_object_thaw_notify (dest);
g_object_thaw_notify (G_OBJECT (dest));
}
/**
* gimp_config_reset_properties:
* @object: a #GObject
* @config: a #GimpConfig
*
* Resets all writable properties of @object to the default values as
* defined in their #GParamSpec.
**/
void
gimp_config_reset_properties (GObject *object)
gimp_config_reset_properties (GimpConfig *config)
{
GObject *object;
GObjectClass *klass;
GParamSpec **property_specs;
GValue value = { 0, };
guint n_property_specs;
guint i;
g_return_if_fail (G_IS_OBJECT (object));
g_return_if_fail (GIMP_IS_CONFIG (config));
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
if (!property_specs)
return;
object = G_OBJECT (config);
g_object_freeze_notify (object);
for (i = 0; i < n_property_specs; i++)
@ -305,13 +310,13 @@ gimp_config_reset_properties (GObject *object)
if ((prop_spec->flags & GIMP_PARAM_SERIALIZE) &&
(prop_spec->flags & GIMP_PARAM_AGGREGATE) &&
g_type_interface_peek (g_type_class_peek (prop_spec->value_type),
GIMP_TYPE_CONFIG_INTERFACE))
GIMP_TYPE_CONFIG))
{
g_value_init (&value, prop_spec->value_type);
g_object_get_property (object, prop_spec->name, &value);
gimp_config_reset (g_value_get_object (&value));
gimp_config_reset (GIMP_CONFIG (g_value_get_object (&value)));
g_value_unset (&value);
}
@ -319,8 +324,8 @@ gimp_config_reset_properties (GObject *object)
else
{
g_value_init (&value, prop_spec->value_type);
g_param_value_set_default (prop_spec, &value);
g_object_set_property (object, prop_spec->name, &value);
g_value_unset (&value);

15
app/config/gimpconfig-utils.h
View File

@ -23,16 +23,19 @@
#define __GIMP_CONFIG_UTILS_H__
GList * gimp_config_diff (GObject *a,
GObject *b,
GParamFlags flags);
void gimp_config_connect (GObject *src,
GObject *dest);
void gimp_config_disconnect (GObject *src,
GObject *dest);
void gimp_config_copy_properties (GObject *src,
GObject *dest);
void gimp_config_reset_properties (GObject *object);
GList * gimp_config_diff (GimpConfig *a,
GimpConfig *b,
GParamFlags flags);
void gimp_config_copy_properties (GimpConfig *src,
GimpConfig *dest);
void gimp_config_reset_properties (GimpConfig *config);
void gimp_config_string_append_escaped (GString *string,
const gchar *val);

238
app/config/gimpconfig.c
View File

@ -43,19 +43,19 @@
* The GimpConfig serialization and deserialization interface.
*/
static void gimp_config_iface_init (GimpConfigInterface *gimp_config_iface);
static void gimp_config_iface_init (GimpConfigInterface *gimp_config_iface);
static gboolean gimp_config_iface_serialize (GObject *object,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_config_iface_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data);
static GObject *gimp_config_iface_duplicate (GObject *object);
static gboolean gimp_config_iface_equal (GObject *a,
GObject *b);
static void gimp_config_iface_reset (GObject *object);
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);
GType
@ -96,25 +96,25 @@ gimp_config_iface_init (GimpConfigInterface *gimp_config_iface)
}
static gboolean
gimp_config_iface_serialize (GObject *object,
gimp_config_iface_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data)
{
return gimp_config_serialize_properties (object, writer);
return gimp_config_serialize_properties (config, writer);
}
static gboolean
gimp_config_iface_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data)
gimp_config_iface_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
return gimp_config_deserialize_properties (object,
return gimp_config_deserialize_properties (config,
scanner, nest_level, FALSE);
}
static GObject *
gimp_config_iface_duplicate (GObject *object)
static GimpConfig *
gimp_config_iface_duplicate (GimpConfig *config)
{
GObjectClass *klass;
GParamSpec **property_specs;
@ -122,9 +122,9 @@ gimp_config_iface_duplicate (GObject *object)
GParameter *construct_params = NULL;
gint n_construct_params = 0;
guint i;
GObject *dup;
GimpConfig *dup;
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
@ -145,14 +145,14 @@ gimp_config_iface_duplicate (GObject *object)
construct_params->name = prop_spec->name;
g_value_init (&construct_params->value, prop_spec->value_type);
g_object_get_property (object, prop_spec->name,
g_object_get_property (G_OBJECT (config), prop_spec->name,
&construct_param->value);
}
}
g_free (property_specs);
dup = g_object_newv (G_TYPE_FROM_INSTANCE (object),
dup = g_object_newv (G_TYPE_FROM_INSTANCE (config),
n_construct_params, construct_params);
for (i = 0; i < n_construct_params; i++)
@ -160,14 +160,14 @@ gimp_config_iface_duplicate (GObject *object)
g_free (construct_params);
gimp_config_copy_properties (object, dup);
gimp_config_copy_properties (config, dup);
return dup;
}
static gboolean
gimp_config_iface_equal (GObject *a,
GObject *b)
gimp_config_iface_equal (GimpConfig *a,
GimpConfig *b)
{
GObjectClass *klass;
GParamSpec **property_specs;
@ -192,8 +192,8 @@ gimp_config_iface_equal (GObject *a,
g_value_init (&a_value, prop_spec->value_type);
g_value_init (&b_value, prop_spec->value_type);
g_object_get_property (a, prop_spec->name, &a_value);
g_object_get_property (b, prop_spec->name, &b_value);
g_object_get_property (G_OBJECT (a), prop_spec->name, &a_value);
g_object_get_property (G_OBJECT (b), prop_spec->name, &b_value);
equal = (g_param_values_cmp (prop_spec, &a_value, &b_value) == 0);
@ -207,103 +207,91 @@ gimp_config_iface_equal (GObject *a,
}
static void
gimp_config_iface_reset (GObject *object)
gimp_config_iface_reset (GimpConfig *config)
{
gimp_config_reset_properties (object);
gimp_config_reset_properties (config);
}
/**
* gimp_config_serialize_to_file:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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:
*
* Serializes the object properties of @object to the file specified
* 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 @object's #GimpConfigInterface.
* calls the serialize function of the @config's #GimpConfigInterface.
*
* Return value: %TRUE if serialization succeeded, %FALSE otherwise.
**/
gboolean
gimp_config_serialize_to_file (GObject *object,
gimp_config_serialize_to_file (GimpConfig *config,
const gchar *filename,
const gchar *header,
const gchar *footer,
gpointer data,
GError **error)
{
GimpConfigInterface *gimp_config_iface;
GimpConfigWriter *writer;
GimpConfigWriter *writer;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
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);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
writer = gimp_config_writer_new_file (filename, TRUE, header, error);
if (!writer)
return FALSE;
gimp_config_iface->serialize (object, writer, data);
GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
return gimp_config_writer_finish (writer, footer, error);
}
gboolean
gimp_config_serialize_to_fd (GObject *object,
gint fd,
gpointer data)
gimp_config_serialize_to_fd (GimpConfig *config,
gint fd,
gpointer data)
{
GimpConfigInterface *gimp_config_iface;
GimpConfigWriter *writer;
GimpConfigWriter *writer;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
g_return_val_if_fail (fd > 0, FALSE);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
writer = gimp_config_writer_new_fd (fd);
if (!writer)
return FALSE;
gimp_config_iface->serialize (object, writer, data);
GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
return gimp_config_writer_finish (writer, NULL, NULL);
}
/**
* gimp_config_serialize_to_string:
* @object: a #GObject that implements the #GimpConfigInterface.
* @config: a #GObject that implements the #GimpConfigInterface.
* @data: user data passed to the serialize implementation.
*
* Serializes the object properties of @object to a string.
* Serializes the object properties of @config to a string.
*
* Return value: a newly allocated %NUL-terminated string.
**/
gchar *
gimp_config_serialize_to_string (GObject *object,
gpointer data)
gimp_config_serialize_to_string (GimpConfig *config,
gpointer data)
{
GimpConfigInterface *gimp_config_iface;
GimpConfigWriter *writer;
GString *str;
GimpConfigWriter *writer;
GString *str;
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
str = g_string_new (NULL);
writer = gimp_config_writer_new_string (str);
gimp_config_iface->serialize (object, writer, data);
GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
gimp_config_writer_finish (writer, NULL, NULL);
@ -312,40 +300,37 @@ gimp_config_serialize_to_string (GObject *object,
/**
* gimp_config_deserialize:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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:
*
* Opens the file specified by @filename, reads configuration data
* from it and configures @object accordingly. Basically this function
* from it and configures @config accordingly. Basically this function
* creates a properly configured #GScanner for you and calls the
* deserialize function of the @object's #GimpConfigInterface.
* deserialize function of the @config's #GimpConfigInterface.
*
* Return value: %TRUE if deserialization succeeded, %FALSE otherwise.
**/
gboolean
gimp_config_deserialize_file (GObject *object,
gimp_config_deserialize_file (GimpConfig *config,
const gchar *filename,
gpointer data,
GError **error)
{
GimpConfigInterface *gimp_config_iface;
GScanner *scanner;
gboolean success;
GScanner *scanner;
gboolean success;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
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);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
scanner = gimp_scanner_new_file (filename, error);
if (! scanner)
return FALSE;
success = gimp_config_iface->deserialize (object, scanner, 0, data);
success = GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
scanner, 0, data);
gimp_scanner_destroy (scanner);
@ -357,39 +342,36 @@ gimp_config_deserialize_file (GObject *object,
/**
* gimp_config_deserialize_string:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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:
* @error:
*
* Configures @object from @text. Basically this function creates a
* Configures @config from @text. Basically this function creates a
* properly configured #GScanner for you and calls the deserialize
* function of the @object's #GimpConfigInterface.
* function of the @config's #GimpConfigInterface.
*
* Returns: %TRUE if deserialization succeeded, %FALSE otherwise.
**/
gboolean
gimp_config_deserialize_string (GObject *object,
gimp_config_deserialize_string (GimpConfig *config,
const gchar *text,
gint text_len,
gpointer data,
GError **error)
{
GimpConfigInterface *gimp_config_iface;
GScanner *scanner;
gboolean success;
GScanner *scanner;
gboolean success;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
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);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
scanner = gimp_scanner_new_string (text, text_len, error);
success = gimp_config_iface->deserialize (object, scanner, 0, data);
success = GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
scanner, 0, data);
gimp_scanner_destroy (scanner);
@ -438,7 +420,7 @@ gimp_config_deserialize_return (GScanner *scanner,
/**
* gimp_config_duplicate:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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
@ -447,18 +429,12 @@ gimp_config_deserialize_return (GScanner *scanner,
*
* Return value: the duplicated #GObject.
**/
GObject *
gimp_config_duplicate (GObject *object)
GimpConfig *
gimp_config_duplicate (GimpConfig *config)
{
GimpConfigInterface *gimp_config_iface;
g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
return gimp_config_iface->duplicate (object);
return GIMP_CONFIG_GET_INTERFACE (config)->duplicate (config);
}
/**
@ -474,43 +450,31 @@ gimp_config_duplicate (GObject *object)
* Return value: %TRUE if the two objects are equal.
**/
gboolean
gimp_config_is_equal_to (GObject *a,
GObject *b)
gimp_config_is_equal_to (GimpConfig *a,
GimpConfig *b)
{
GimpConfigInterface *gimp_config_iface;
g_return_val_if_fail (G_IS_OBJECT (a), FALSE);
g_return_val_if_fail (G_IS_OBJECT (b), FALSE);
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);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (a);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
return gimp_config_iface->equal (a, b);
return GIMP_CONFIG_GET_INTERFACE (a)->equal (a, b);
}
/**
* gimp_config_reset:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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.
**/
void
gimp_config_reset (GObject *object)
gimp_config_reset (GimpConfig *config)
{
GimpConfigInterface *gimp_config_iface;
g_return_if_fail (GIMP_IS_CONFIG (config));
g_return_if_fail (G_IS_OBJECT (object));
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_if_fail (gimp_config_iface != NULL);
gimp_config_iface->reset (object);
GIMP_CONFIG_GET_INTERFACE (config)->reset (config);
}
@ -531,7 +495,7 @@ static void gimp_config_destroy_unknown_tokens (GSList *unknown_tokens);
/**
* gimp_config_add_unknown_token:
* @object: a #GObject.
* @config: a #GObject.
* @key: a nul-terminated string to identify the value.
* @value: a nul-terminated string representing the value.
*
@ -546,7 +510,7 @@ static void gimp_config_destroy_unknown_tokens (GSList *unknown_tokens);
* function with a %NULL @value.
**/
void
gimp_config_add_unknown_token (GObject *object,
gimp_config_add_unknown_token (GimpConfig *config,
const gchar *key,
const gchar *value)
{
@ -555,10 +519,10 @@ gimp_config_add_unknown_token (GObject *object,
GSList *last;
GSList *list;
g_return_if_fail (G_IS_OBJECT (object));
g_return_if_fail (GIMP_IS_CONFIG (config));
g_return_if_fail (key != NULL);
unknown_tokens = (GSList *) g_object_get_data (object,
unknown_tokens = (GSList *) g_object_get_data (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS);
for (last = NULL, list = unknown_tokens;
@ -580,7 +544,8 @@ gimp_config_add_unknown_token (GObject *object,
g_free (token->key);
unknown_tokens = g_slist_remove (unknown_tokens, token);
g_object_set_data_full (object, GIMP_CONFIG_UNKNOWN_TOKENS,
g_object_set_data_full (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS,
unknown_tokens,
(GDestroyNotify) gimp_config_destroy_unknown_tokens);
}
@ -604,7 +569,8 @@ gimp_config_add_unknown_token (GObject *object,
{
unknown_tokens = g_slist_append (NULL, token);
g_object_set_data_full (object, GIMP_CONFIG_UNKNOWN_TOKENS,
g_object_set_data_full (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS,
unknown_tokens,
(GDestroyNotify) gimp_config_destroy_unknown_tokens);
}
@ -612,7 +578,7 @@ gimp_config_add_unknown_token (GObject *object,
/**
* gimp_config_lookup_unknown_token:
* @object: a #GObject.
* @config: a #GObject.
* @key: a nul-terminated string to identify the value.
*
* This function retrieves data that was previously attached using
@ -622,17 +588,17 @@ gimp_config_add_unknown_token (GObject *object,
* Returns: a pointer to a constant string.
**/
const gchar *
gimp_config_lookup_unknown_token (GObject *object,
gimp_config_lookup_unknown_token (GimpConfig *config,
const gchar *key)
{
GimpConfigToken *token;
GSList *unknown_tokens;
GSList *list;
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
g_return_val_if_fail (key != NULL, NULL);
unknown_tokens = (GSList *) g_object_get_data (object,
unknown_tokens = (GSList *) g_object_get_data (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS);
for (list = unknown_tokens; list; list = g_slist_next (list))
@ -648,15 +614,15 @@ gimp_config_lookup_unknown_token (GObject *object,
/**
* gimp_config_foreach_unknown_token:
* @object: a #GObject.
* @config: a #GObject.
* @func: a function to call for each key/value pair.
* @user_data: data to pass to @func.
*
* Calls @func for each key/value stored with the @object using
* Calls @func for each key/value stored with the @config using
* gimp_config_add_unknown_token().
**/
void
gimp_config_foreach_unknown_token (GObject *object,
gimp_config_foreach_unknown_token (GimpConfig *config,
GimpConfigForeachFunc func,
gpointer user_data)
{
@ -664,10 +630,10 @@ gimp_config_foreach_unknown_token (GObject *object,
GSList *unknown_tokens;
GSList *list;
g_return_if_fail (G_IS_OBJECT (object));
g_return_if_fail (GIMP_IS_CONFIG (config));
g_return_if_fail (func != NULL);
unknown_tokens = (GSList *) g_object_get_data (object,
unknown_tokens = (GSList *) g_object_get_data (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS);
for (list = unknown_tokens; list; list = g_slist_next (list))

75
app/config/gimpconfig.h
View File

@ -23,37 +23,38 @@
#define __GIMP_CONFIG_H__
#define GIMP_TYPE_CONFIG_INTERFACE (gimp_config_interface_get_type ())
#define GIMP_GET_CONFIG_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GIMP_TYPE_CONFIG_INTERFACE, GimpConfigInterface))
#define GIMP_TYPE_CONFIG (gimp_config_interface_get_type ())
#define GIMP_IS_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CONFIG))
#define GIMP_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CONFIG, GimpConfig))
#define GIMP_CONFIG_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GIMP_TYPE_CONFIG, GimpConfigInterface))
typedef struct _GimpConfigInterface GimpConfigInterface;
struct _GimpConfigInterface
{
GTypeInterface base_iface;
gboolean (* serialize) (GObject *object,
GimpConfigWriter *writer,
gpointer data);
gboolean (* deserialize) (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data);
gboolean (* serialize_property) (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec,
GimpConfigWriter *writer);
gboolean (* deserialize_property) (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec,
GScanner *scanner,
GTokenType *expected);
GObject * (* duplicate) (GObject *object);
gboolean (* equal) (GObject *a,
GObject *b);
void (* reset) (GObject *object);
gboolean (* serialize) (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data);
gboolean (* deserialize) (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data);
gboolean (* serialize_property) (GimpConfig *config,
guint property_id,
const GValue *value,
GParamSpec *pspec,
GimpConfigWriter *writer);
gboolean (* deserialize_property) (GimpConfig *config,
guint property_id,
GValue *value,
GParamSpec *pspec,
GScanner *scanner,
GTokenType *expected);
GimpConfig * (* duplicate) (GimpConfig *config);
gboolean (* equal) (GimpConfig *a,
GimpConfig *b);
void (* reset) (GimpConfig *config);
};
typedef void (* GimpConfigForeachFunc) (const gchar *key,
@ -63,22 +64,22 @@ typedef void (* GimpConfigForeachFunc) (const gchar *key,
GType gimp_config_interface_get_type (void) G_GNUC_CONST;
gboolean gimp_config_serialize_to_file (GObject *object,
gboolean gimp_config_serialize_to_file (GimpConfig *config,
const gchar *filename,
const gchar *header,
const gchar *footer,
gpointer data,
GError **error);
gboolean gimp_config_serialize_to_fd (GObject *object,
gboolean gimp_config_serialize_to_fd (GimpConfig *config,
gint fd,
gpointer data);
gchar * gimp_config_serialize_to_string (GObject *object,
gchar * gimp_config_serialize_to_string (GimpConfig *config,
gpointer data);
gboolean gimp_config_deserialize_file (GObject *object,
gboolean gimp_config_deserialize_file (GimpConfig *config,
const gchar *filename,
gpointer data,
GError **error);
gboolean gimp_config_deserialize_string (GObject *object,
gboolean gimp_config_deserialize_string (GimpConfig *config,
const gchar *text,
gint text_len,
gpointer data,
@ -87,17 +88,17 @@ gboolean gimp_config_deserialize_return (GScanner *scanner,
GTokenType expected_token,
gint nest_level);
GObject * gimp_config_duplicate (GObject *object);
gboolean gimp_config_is_equal_to (GObject *a,
GObject *b);
void gimp_config_reset (GObject *object);
GimpConfig * gimp_config_duplicate (GimpConfig *config);
gboolean gimp_config_is_equal_to (GimpConfig *a,
GimpConfig *b);
void gimp_config_reset (GimpConfig *config);
void gimp_config_add_unknown_token (GObject *object,
void gimp_config_add_unknown_token (GimpConfig *config,
const gchar *key,
const gchar *value);
const gchar * gimp_config_lookup_unknown_token (GObject *object,
const gchar * gimp_config_lookup_unknown_token (GimpConfig *config,
const gchar *key);
void gimp_config_foreach_unknown_token (GObject *object,
void gimp_config_foreach_unknown_token (GimpConfig *config,
GimpConfigForeachFunc func,
gpointer user_data);

135
app/config/gimprc.c
View File

@ -58,39 +58,39 @@ enum
};
static void gimp_rc_class_init (GimpRcClass *klass);
static void gimp_rc_config_iface_init (gpointer iface,
gpointer iface_data);
static void gimp_rc_init (GimpRc *rc);
static void gimp_rc_dispose (GObject *object);
static void gimp_rc_finalize (GObject *object);
static void gimp_rc_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_rc_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gboolean gimp_rc_serialize (GObject *object,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_rc_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data);
static GObject * gimp_rc_duplicate (GObject *object);
static void gimp_rc_load (GimpRc *rc);
static gboolean gimp_rc_idle_save (GimpRc *rc);
static void gimp_rc_notify (GimpRc *rc,
GParamSpec *param,
gpointer data);
static void gimp_rc_class_init (GimpRcClass *klass);
static void gimp_rc_config_iface_init (gpointer iface,
gpointer iface_data);
static void gimp_rc_init (GimpRc *rc);
static void gimp_rc_dispose (GObject *object);
static void gimp_rc_finalize (GObject *object);
static void gimp_rc_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_rc_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gboolean gimp_rc_serialize (GimpConfig *object,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_rc_deserialize (GimpConfig *object,
GScanner *scanner,
gint nest_level,
gpointer data);
static GimpConfig * gimp_rc_duplicate (GimpConfig *object);
static void gimp_rc_load (GimpRc *rc);
static gboolean gimp_rc_idle_save (GimpRc *rc);
static void gimp_rc_notify (GimpRc *rc,
GParamSpec *param,
gpointer data);
static GObjectClass *parent_class = NULL;
GType
GType
gimp_rc_get_type (void)
{
static GType rc_type = 0;
@ -109,19 +109,17 @@ gimp_rc_get_type (void)
0, /* n_preallocs */
(GInstanceInitFunc) gimp_rc_init
};
static const GInterfaceInfo rc_iface_info =
{
static const GInterfaceInfo rc_iface_info =
{
gimp_rc_config_iface_init,
NULL, /* iface_finalize */
NULL, /* iface_finalize */
NULL /* iface_data */
};
rc_type = g_type_register_static (GIMP_TYPE_PLUGIN_CONFIG,
rc_type = g_type_register_static (GIMP_TYPE_PLUGIN_CONFIG,
"GimpRc", &rc_info, 0);
g_type_add_interface_static (rc_type,
GIMP_TYPE_CONFIG_INTERFACE,
&rc_iface_info);
g_type_add_interface_static (rc_type, GIMP_TYPE_CONFIG, &rc_iface_info);
}
return rc_type;
@ -192,7 +190,7 @@ gimp_rc_finalize (GObject *object)
g_free (rc->user_gimprc);
rc->user_gimprc = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
@ -223,7 +221,7 @@ gimp_rc_set_property (GObject *object,
case PROP_SYSTEM_GIMPRC:
g_free (rc->system_gimprc);
if (filename)
rc->system_gimprc = g_strdup (filename);
else
@ -252,7 +250,7 @@ gimp_rc_get_property (GObject *object,
GParamSpec *pspec)
{
GimpRc *rc = GIMP_RC (object);
switch (property_id)
{
case PROP_VERBOSE:
@ -282,32 +280,32 @@ gimp_rc_config_iface_init (gpointer iface,
}
static gboolean
gimp_rc_serialize (GObject *object,
gimp_rc_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data)
{
if (data && GIMP_IS_RC (data))
{
if (! gimp_config_serialize_properties_diff (object,
G_OBJECT (data), writer))
if (! gimp_config_serialize_properties_diff (config, GIMP_CONFIG (data),
writer))
return FALSE;
}
else
{
if (! gimp_config_serialize_properties (object, writer))
if (! gimp_config_serialize_properties (config, writer))
return FALSE;
}
return gimp_config_serialize_unknown_tokens (object, writer);
return gimp_config_serialize_unknown_tokens (config, writer);
}
static gboolean
gimp_rc_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data)
gimp_rc_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
return gimp_config_deserialize_properties (object,
return gimp_config_deserialize_properties (config,
scanner, nest_level, TRUE);
}
@ -316,17 +314,17 @@ gimp_rc_duplicate_unknown_token (const gchar *key,
const gchar *value,
gpointer user_data)
{
gimp_config_add_unknown_token (G_OBJECT (user_data), key, value);
gimp_config_add_unknown_token (GIMP_CONFIG (user_data), key, value);
}
static GObject *
gimp_rc_duplicate (GObject *object)
static GimpConfig *
gimp_rc_duplicate (GimpConfig *config)
{
GObject *dup = g_object_new (GIMP_TYPE_RC, NULL);
GimpConfig *dup = g_object_new (GIMP_TYPE_RC, NULL);
gimp_config_copy_properties (object, dup);
gimp_config_copy_properties (config, dup);
gimp_config_foreach_unknown_token (object,
gimp_config_foreach_unknown_token (config,
gimp_rc_duplicate_unknown_token, dup);
return dup;
@ -342,24 +340,24 @@ gimp_rc_load (GimpRc *rc)
if (rc->verbose)
g_print (_("Parsing '%s'\n"), rc->system_gimprc);
if (! gimp_config_deserialize_file (G_OBJECT (rc),
if (! gimp_config_deserialize_file (GIMP_CONFIG (rc),
rc->system_gimprc, NULL, &error))
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
g_message (error->message);
g_clear_error (&error);
}
if (rc->verbose)
g_print (_("Parsing '%s'\n"), rc->user_gimprc);
if (! gimp_config_deserialize_file (G_OBJECT (rc),
if (! gimp_config_deserialize_file (GIMP_CONFIG (rc),
rc->user_gimprc, NULL, &error))
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
g_message (error->message);
g_clear_error (&error);
}
}
@ -445,12 +443,12 @@ gimp_rc_set_autosave (GimpRc *rc,
* gimp_rc_query:
* @rc: a #GimpRc object.
* @key: a string used as a key for the lookup.
*
*
* This function looks up @key in the object properties of @rc. If
* there's a matching property, a string representation of its value
* is returned. If no property is found, the list of unknown tokens
* attached to the @rc object is searched.
*
*
* Return value: a newly allocated string representing the value or %NULL
* if the key couldn't be found.
**/
@ -504,7 +502,8 @@ gimp_rc_query (GimpRc *rc,
}
else
{
retval = g_strdup (gimp_config_lookup_unknown_token (rc_object, key));
retval = g_strdup (gimp_config_lookup_unknown_token (GIMP_CONFIG (rc),
key));
}
g_free (property_specs);
@ -542,7 +541,7 @@ gimp_rc_query (GimpRc *rc,
/**
* gimp_rc_save:
* @gimprc: a #GimpRc object.
*
*
* Saves any settings that differ from the system-wide defined
* defaults to the users personal gimprc file.
**/
@ -553,7 +552,7 @@ gimp_rc_save (GimpRc *rc)
gchar *header;
GError *error = NULL;
const gchar *top =
const gchar *top =
"GIMP gimprc\n"
"\n"
"This is your personal gimprc file. Any variable defined in this file "
@ -566,18 +565,18 @@ gimp_rc_save (GimpRc *rc)
"end of gimprc";
g_return_if_fail (GIMP_IS_RC (rc));
global = g_object_new (GIMP_TYPE_RC, NULL);
gimp_config_deserialize_file (G_OBJECT (global),
gimp_config_deserialize_file (GIMP_CONFIG (global),
rc->system_gimprc, NULL, NULL);
header = g_strconcat (top, rc->system_gimprc, bottom, NULL);
if (rc->verbose)
g_print (_("Saving '%s'\n"), rc->user_gimprc);
if (! gimp_config_serialize_to_file (G_OBJECT (rc),
if (! gimp_config_serialize_to_file (GIMP_CONFIG (rc),
rc->user_gimprc,
header, footer, global,
&error))

22
app/config/test-config.c
View File

@ -3,7 +3,7 @@
*
* Test suite for GimpConfig.
* Copyright (C) 2001-2002 Sven Neumann <sven@gimp.org>
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
@ -48,8 +48,8 @@ int
main (int argc,
char *argv[])
{
GObject *gimprc;
GObject *gimprc2;
GimpConfig *gimprc;
GimpConfig *gimprc2;
const gchar *filename = "foorc";
gchar *header;
gchar *result;
@ -61,7 +61,7 @@ main (int argc,
if (strcmp (argv[i], "--g-fatal-warnings") == 0)
{
GLogLevelFlags fatal_mask;
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
g_log_set_always_fatal (fatal_mask);
@ -75,12 +75,12 @@ main (int argc,
g_print (" Creating a new GimpRc object ...");
gimprc = g_object_new (GIMP_TYPE_RC, NULL);
g_print (" done.\n\n");
g_print (" Adding the unknown token (foobar \"hadjaha\") ...");
g_print (" Adding the unknown token (foobar \"hadjaha\") ...");
gimp_config_add_unknown_token (gimprc, "foobar", "hadjaha");
g_print (" done.\n\n");
g_print (" Serializing %s to '%s' ...",
g_print (" Serializing %s to '%s' ...",
g_type_name (G_TYPE_FROM_INSTANCE (gimprc)), filename);
if (! gimp_config_serialize_to_file (gimprc,
@ -122,7 +122,7 @@ main (int argc,
g_object_set (gimprc2, "show-tips", FALSE, NULL);
g_print ("\n Querying for \"default-comment\" ... ");
result = gimp_rc_query (GIMP_RC (gimprc2), "default-comment");
if (result)
{
@ -136,7 +136,7 @@ main (int argc,
g_free (result);
g_print (" Querying for \"foobar\" ... ");
result = gimp_rc_query (GIMP_RC (gimprc2), "foobar");
if (result && strcmp (result, "hadjaha") == 0)
{
@ -200,7 +200,7 @@ main (int argc,
g_free (result);
g_object_unref (gimprc2);
g_object_unref (gimprc);
g_print ("\nFinished test of GimpConfig.\n\n");
return EXIT_SUCCESS;
@ -227,7 +227,7 @@ notify_callback (GObject *object,
}
else
{
g_print (" %s changed but we failed to serialize its value!\n",
g_print (" %s changed but we failed to serialize its value!\n",
pspec->name);
}

4
app/core/gimp-documents.c
View File

@ -46,7 +46,7 @@ gimp_documents_load (Gimp *gimp)
filename = gimp_personal_rc_file ("documents");
if (! gimp_config_deserialize_file (G_OBJECT (gimp->documents),
if (! gimp_config_deserialize_file (GIMP_CONFIG (gimp->documents),
filename,
GINT_TO_POINTER (gimp->config->thumbnail_size),
&error))
@ -77,7 +77,7 @@ gimp_documents_save (Gimp *gimp)
filename = gimp_personal_rc_file ("documents");
if (! gimp_config_serialize_to_file (G_OBJECT (gimp->documents),
if (! gimp_config_serialize_to_file (GIMP_CONFIG (gimp->documents),
filename,
header, footer, NULL,
&error))

8
app/core/gimp-parasites.c
View File

@ -1,4 +1,4 @@
/* gimpparasite.c: Copyright 1998 Jay Cox <jaycox@earthlink.net>
/* gimpparasite.c: Copyright 1998 Jay Cox <jaycox@earthlink.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -52,7 +52,7 @@ gimp_parasite_find (Gimp *gimp,
return gimp_parasite_list_find (gimp->parasites, name);
}
static void
static void
list_func (const gchar *key,
GimpParasite *parasite,
gchar ***current)
@ -101,7 +101,7 @@ gimp_parasiterc_load (Gimp *gimp)
filename = gimp_personal_rc_file ("parasiterc");
if (! gimp_config_deserialize_file (G_OBJECT (gimp->parasites),
if (! gimp_config_deserialize_file (GIMP_CONFIG (gimp->parasites),
filename, NULL, &error))
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
@ -130,7 +130,7 @@ gimp_parasiterc_save (Gimp *gimp)
filename = gimp_personal_rc_file ("parasiterc");
if (! gimp_config_serialize_to_file (G_OBJECT (gimp->parasites),
if (! gimp_config_serialize_to_file (GIMP_CONFIG (gimp->parasites),
filename,
header, footer, NULL,
&error))

4
app/core/gimp-templates.c
View File

@ -46,7 +46,7 @@ gimp_templates_load (Gimp *gimp)
filename = gimp_personal_rc_file ("templaterc");
if (!gimp_config_deserialize_file (G_OBJECT (gimp->templates),
if (!gimp_config_deserialize_file (GIMP_CONFIG (gimp->templates),
filename,
NULL,
&error))
@ -79,7 +79,7 @@ gimp_templates_save (Gimp *gimp)
filename = gimp_personal_rc_file ("templaterc");
if (! gimp_config_serialize_to_file (G_OBJECT (gimp->templates),
if (! gimp_config_serialize_to_file (GIMP_CONFIG (gimp->templates),
filename,
header, footer, NULL,
&error))

2
app/core/gimp.c
View File

@ -836,7 +836,7 @@ gimp_load_config (Gimp *gimp,
gimp->config = GIMP_CORE_CONFIG (gimprc);
gimp->edit_config =
GIMP_CORE_CONFIG (gimp_config_duplicate (G_OBJECT (gimp->config)));
GIMP_CORE_CONFIG (gimp_config_duplicate (GIMP_CONFIG (gimp->config)));
g_signal_connect_object (gimp->config, "notify",
G_CALLBACK (gimp_global_config_notify),

4
app/core/gimp.h
View File

@ -74,8 +74,8 @@ struct _Gimp
GimpCoreConfig *config;
GimpCoreConfig *edit_config; /* don't use this one, it's just
* for the preferences dialog
*/
* for the preferences dialog
*/
gboolean be_verbose;
gboolean no_data;

49
app/core/gimpcontainer.c
View File

@ -101,10 +101,10 @@ static void gimp_container_get_property (GObject *object,
static gsize gimp_container_get_memsize (GimpObject *object,
gsize *gui_size);
static gboolean gimp_container_serialize (GObject *object,
static gboolean gimp_container_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_container_deserialize (GObject *object,
static gboolean gimp_container_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data);
@ -148,8 +148,7 @@ gimp_container_get_type (void)
"GimpContainer",
&container_info, 0);
g_type_add_interface_static (container_type,
GIMP_TYPE_CONFIG_INTERFACE,
g_type_add_interface_static (container_type, GIMP_TYPE_CONFIG,
&config_iface_info);
}
@ -375,7 +374,7 @@ gimp_container_serialize_foreach (GObject *object,
GimpConfigInterface *config_iface;
const gchar *name;
config_iface = GIMP_GET_CONFIG_INTERFACE (object);
config_iface = GIMP_CONFIG_GET_INTERFACE (object);
if (! config_iface)
serialize_data->success = FALSE;
@ -393,21 +392,21 @@ gimp_container_serialize_foreach (GObject *object,
else
gimp_config_writer_print (serialize_data->writer, "NULL", 4);
serialize_data->success = config_iface->serialize (object,
serialize_data->success = config_iface->serialize (GIMP_CONFIG (object),
serialize_data->writer,
serialize_data->data);
gimp_config_writer_close (serialize_data->writer);
}
static gboolean
gimp_container_serialize (GObject *object,
gimp_container_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data)
{
GimpContainer *container;
SerializeData serialize_data;
container = GIMP_CONTAINER (object);
container = GIMP_CONTAINER (config);
serialize_data.writer = writer;
serialize_data.data = data;
@ -421,15 +420,15 @@ gimp_container_serialize (GObject *object,
}
static gboolean
gimp_container_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data)
gimp_container_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
GimpContainer *container;
GTokenType token;
container = GIMP_CONTAINER (object);
container = GIMP_CONTAINER (config);
token = G_TOKEN_LEFT_PAREN;
@ -468,7 +467,7 @@ gimp_container_deserialize (GObject *object,
return FALSE;
}
if (! g_type_is_a (type, GIMP_TYPE_CONFIG_INTERFACE))
if (! g_type_is_a (type, GIMP_TYPE_CONFIG))
{
g_scanner_error (scanner,
"'%s' does not implement GimpConfigInterface",
@ -509,20 +508,14 @@ gimp_container_deserialize (GObject *object,
g_free (name);
{
GimpConfigInterface *config_iface;
config_iface = GIMP_GET_CONFIG_INTERFACE (child);
if (! config_iface->deserialize (G_OBJECT (child),
scanner,
nest_level + 1,
FALSE))
{
/* warning should be already set by child */
return FALSE;
}
}
if (! GIMP_CONFIG_GET_INTERFACE (config)->deserialize (GIMP_CONFIG (child),
scanner,
nest_level + 1,
FALSE))
{
/* warning should be already set by child */
return FALSE;
}
}
token = G_TOKEN_RIGHT_PAREN;
break;

19
app/core/gimpcontext.c
View File

@ -90,15 +90,15 @@ static void gimp_context_get_property (GObject *object,
static gsize gimp_context_get_memsize (GimpObject *object,
gsize *gui_size);
static gboolean gimp_context_serialize (GObject *object,
static gboolean gimp_context_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_context_serialize_property (GObject *object,
static gboolean gimp_context_serialize_property (GimpConfig *config,
guint property_id,
const GValue *value,
GParamSpec *pspec,
GimpConfigWriter *writer);
static gboolean gimp_context_deserialize_property (GObject *object,
static gboolean gimp_context_deserialize_property (GimpConfig *config,
guint property_id,
GValue *value,
GParamSpec *pspec,
@ -352,8 +352,7 @@ gimp_context_get_type (void)
"GimpContext",
&context_info, 0);
g_type_add_interface_static (context_type,
GIMP_TYPE_CONFIG_INTERFACE,
g_type_add_interface_static (context_type, GIMP_TYPE_CONFIG,
&config_iface_info);
}
@ -1102,15 +1101,15 @@ gimp_context_get_memsize (GimpObject *object,
}
static gboolean
gimp_context_serialize (GObject *object,
gimp_context_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data)
{
return gimp_config_serialize_changed_properties (object, writer);
return gimp_config_serialize_changed_properties (config, writer);
}
static gboolean
gimp_context_serialize_property (GObject *object,
gimp_context_serialize_property (GimpConfig *config,
guint property_id,
const GValue *value,
GParamSpec *pspec,
@ -1119,7 +1118,7 @@ gimp_context_serialize_property (GObject *object,
GimpContext *context;
GimpObject *serialize_obj;
context = GIMP_CONTEXT (object);
context = GIMP_CONTEXT (config);
#if 0
/* serialize nothing if the property is not defined */
@ -1155,7 +1154,7 @@ gimp_context_serialize_property (GObject *object,
}
static gboolean
gimp_context_deserialize_property (GObject *object,
gimp_context_deserialize_property (GimpConfig *object,
guint property_id,
GValue *value,
GParamSpec *pspec,

35
app/core/gimpdocumentlist.c
View File

@ -42,10 +42,10 @@
static void gimp_document_list_config_iface_init (gpointer iface,
gpointer iface_data);
static gboolean gimp_document_list_serialize (GObject *object,
static gboolean gimp_document_list_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_document_list_deserialize (GObject *object,
static gboolean gimp_document_list_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data);
@ -54,7 +54,7 @@ static gboolean gimp_document_list_deserialize (GObject *object,
static const gchar *document_symbol = "document";
GType
GType
gimp_document_list_get_type (void)
{
static GType document_list_type = 0;
@ -73,19 +73,18 @@ gimp_document_list_get_type (void)
0, /* n_preallocs */
NULL /* instance_init */
};
static const GInterfaceInfo document_list_iface_info =
{
static const GInterfaceInfo document_list_iface_info =
{
gimp_document_list_config_iface_init,
NULL, /* iface_finalize */
NULL, /* iface_finalize */
NULL /* iface_data */
};
document_list_type = g_type_register_static (GIMP_TYPE_LIST,
document_list_type = g_type_register_static (GIMP_TYPE_LIST,
"GimpDocumentList",
&document_list_info, 0);
g_type_add_interface_static (document_list_type,
GIMP_TYPE_CONFIG_INTERFACE,
g_type_add_interface_static (document_list_type, GIMP_TYPE_CONFIG,
&document_list_iface_info);
}
@ -103,16 +102,16 @@ gimp_document_list_config_iface_init (gpointer iface,
}
static gboolean
gimp_document_list_serialize (GObject *object,
gimp_document_list_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data)
{
GList *list;
for (list = GIMP_LIST (object)->list; list; list = list->next)
for (list = GIMP_LIST (config)->list; list; list = list->next)
{
gimp_config_writer_open (writer, document_symbol);
gimp_config_writer_string (writer, GIMP_OBJECT (list->data)->name);
gimp_config_writer_string (writer, GIMP_OBJECT (list->data)->name);
gimp_config_writer_close (writer);
}
@ -120,17 +119,15 @@ gimp_document_list_serialize (GObject *object,
}
static gboolean
gimp_document_list_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data)
gimp_document_list_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
GimpDocumentList *document_list;
GimpDocumentList *document_list = GIMP_DOCUMENT_LIST (config);
GTokenType token;
gint size;
document_list = GIMP_DOCUMENT_LIST (object);
size = GPOINTER_TO_INT (data);
g_scanner_scope_add_symbol (scanner, 0,

7
app/core/gimpgrid.c
View File

@ -98,8 +98,7 @@ gimp_grid_get_type (void)
grid_type = g_type_register_static (GIMP_TYPE_OBJECT,
"GimpGrid", &grid_info, 0);
g_type_add_interface_static (grid_type,
GIMP_TYPE_CONFIG_INTERFACE,
g_type_add_interface_static (grid_type, GIMP_TYPE_CONFIG,
&grid_iface_info);
}
@ -285,7 +284,7 @@ gimp_grid_to_parasite (const GimpGrid *grid)
g_return_val_if_fail (GIMP_IS_GRID (grid), NULL);
str = gimp_config_serialize_to_string (G_OBJECT (grid), NULL);
str = gimp_config_serialize_to_string (GIMP_CONFIG (grid), NULL);
g_return_val_if_fail (str != NULL, NULL);
parasite = gimp_parasite_new (gimp_grid_parasite_name (),
@ -312,7 +311,7 @@ gimp_grid_from_parasite (const GimpParasite *parasite)
grid = g_object_new (GIMP_TYPE_GRID, NULL);
if (! gimp_config_deserialize_string (G_OBJECT (grid),
if (! gimp_config_deserialize_string (GIMP_CONFIG (grid),
str,
gimp_parasite_data_size (parasite),
NULL,

2
app/core/gimpimage-duplicate.c
View File

@ -243,7 +243,7 @@ gimp_image_duplicate (GimpImage *gimage)
if (gimage->grid)
{
new_gimage->grid =
GIMP_GRID (gimp_config_duplicate (G_OBJECT (gimage->grid)));
GIMP_GRID (gimp_config_duplicate (GIMP_CONFIG (gimage->grid)));
}
/* Copy the qmask info */

10
app/core/gimpimage-new.c
View File

@ -1,6 +1,6 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995-1999 Spencer Kimball and Peter Mattis
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
@ -48,8 +48,8 @@ gimp_image_new_get_last_template (Gimp *gimp,
if (gimage)
gimp_template_set_from_image (template, gimage);
else
gimp_config_copy_properties (G_OBJECT (gimp->image_new_last_template),
G_OBJECT (template));
gimp_config_copy_properties (GIMP_CONFIG (gimp->image_new_last_template),
GIMP_CONFIG (template));
if (gimp->global_buffer && gimp->have_current_cut_buffer)
{
@ -69,7 +69,7 @@ gimp_image_new_set_last_template (Gimp *gimp,
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_TEMPLATE (template));
gimp_config_copy_properties (G_OBJECT (template),
G_OBJECT (gimp->image_new_last_template));
gimp_config_copy_properties (GIMP_CONFIG (template),
GIMP_CONFIG (gimp->image_new_last_template));
gimp->have_current_cut_buffer = FALSE;
}

7
app/core/gimpimage.c
View File

@ -31,8 +31,9 @@
#include "base/temp-buf.h"
#include "base/tile-manager.h"
#include "config/gimpcoreconfig.h"
#include "config/gimpconfig.h"
#include "config/gimpconfig-utils.h"
#include "config/gimpcoreconfig.h"
#include "gimp.h"
#include "gimp-parasites.h"
@ -949,8 +950,8 @@ gimp_image_new (Gimp *gimp,
gimage->unit = gimp->config->default_unit;
gimage->grid = g_object_new (GIMP_TYPE_GRID, NULL);
gimp_config_copy_properties (G_OBJECT (gimp->config->default_grid),
G_OBJECT (gimage->grid));
gimp_config_copy_properties (GIMP_CONFIG (gimp->config->default_grid),
GIMP_CONFIG (gimage->grid));
switch (base_type)
{

17
app/core/gimpparasitelist.c
View File

@ -56,10 +56,10 @@ static gsize gimp_parasite_list_get_memsize (GimpObject *object,
static void gimp_parasite_list_config_iface_init (gpointer iface,
gpointer iface_data);
static gboolean gimp_parasite_list_serialize (GObject *list,
static gboolean gimp_parasite_list_serialize (GimpConfig *list,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_parasite_list_deserialize (GObject *list,
static gboolean gimp_parasite_list_deserialize (GimpConfig *list,
GScanner *scanner,
gint nest_level,
gpointer data);
@ -114,8 +114,7 @@ gimp_parasite_list_get_type (void)
list_type = g_type_register_static (GIMP_TYPE_OBJECT,
"GimpParasiteList",
&list_info, 0);
g_type_add_interface_static (list_type,
GIMP_TYPE_CONFIG_INTERFACE,
g_type_add_interface_static (list_type, GIMP_TYPE_CONFIG,
&list_iface_info);
}
@ -232,7 +231,7 @@ gimp_parasite_list_get_memsize (GimpObject *object,
}
static gboolean
gimp_parasite_list_serialize (GObject *list,
gimp_parasite_list_serialize (GimpConfig *list,
GimpConfigWriter *writer,
gpointer data)
{
@ -245,10 +244,10 @@ gimp_parasite_list_serialize (GObject *list,
}
static gboolean
gimp_parasite_list_deserialize (GObject *list,
GScanner *scanner,
gint nest_level,
gpointer data)
gimp_parasite_list_deserialize (GimpConfig *list,
GScanner *scanner,
gint nest_level,
gpointer data)
{
GTokenType token;

26
app/core/gimptemplate.c
View File

@ -74,10 +74,10 @@ static void gimp_template_get_property (GObject *object,
static void gimp_template_notify (GObject *object,
GParamSpec *pspec);
static gboolean gimp_template_serialize (GObject *object,
static gboolean gimp_template_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_template_deserialize (GObject *object,
static gboolean gimp_template_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data);
@ -105,7 +105,7 @@ gimp_template_get_type (void)
0, /* n_preallocs */
(GInstanceInitFunc) gimp_template_init,
};
static const GInterfaceInfo config_iface_info =
static const GInterfaceInfo config_iface_info =
{
(GInterfaceInitFunc) gimp_template_config_iface_init,
NULL, /* iface_finalize */
@ -113,11 +113,10 @@ gimp_template_get_type (void)
};
template_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
"GimpTemplate",
"GimpTemplate",
&template_info, 0);
g_type_add_interface_static (template_type,
GIMP_TYPE_CONFIG_INTERFACE,
g_type_add_interface_static (template_type, GIMP_TYPE_CONFIG,
&config_iface_info);
}
@ -344,20 +343,21 @@ gimp_template_notify (GObject *object,
}
static gboolean
gimp_template_serialize (GObject *object,
gimp_template_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data)
{
return gimp_config_serialize_properties (object, writer);
return gimp_config_serialize_properties (config, writer);
}
static gboolean
gimp_template_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data)
gimp_template_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
return gimp_config_deserialize_properties (object, scanner, nest_level, FALSE);
return gimp_config_deserialize_properties (config,
scanner, nest_level, FALSE);
}

6
app/core/gimptooloptions.c
View File

@ -166,7 +166,7 @@ gimp_tool_options_get_property (GObject *object,
static void
gimp_tool_options_real_reset (GimpToolOptions *tool_options)
{
gimp_config_reset (G_OBJECT (tool_options));
gimp_config_reset (GIMP_CONFIG (tool_options));
}
void
@ -229,7 +229,7 @@ gimp_tool_options_serialize (GimpToolOptions *tool_options,
footer = g_strdup_printf ("end of %s options",
GIMP_OBJECT (tool_options->tool_info)->name);
retval = gimp_config_serialize_to_file (G_OBJECT (tool_options),
retval = gimp_config_serialize_to_file (GIMP_CONFIG (tool_options),
filename,
header, footer,
NULL,
@ -255,7 +255,7 @@ gimp_tool_options_deserialize (GimpToolOptions *tool_options,
filename = gimp_tool_options_build_filename (tool_options, extension);
retval = gimp_config_deserialize_file (G_OBJECT (tool_options),
retval = gimp_config_deserialize_file (GIMP_CONFIG (tool_options),
filename,
NULL,
error);

9
app/core/gimpviewable.c
View File

@ -78,7 +78,7 @@ static void gimp_viewable_real_get_preview_size (GimpViewable *viewable,
gint *height);
static gchar * gimp_viewable_real_get_description (GimpViewable *viewable,
gchar **tooltip);
static gboolean gimp_viewable_serialize_property (GObject *object,
static gboolean gimp_viewable_serialize_property (GimpConfig *config,
guint property_id,
const GValue *value,
GParamSpec *pspec,
@ -123,8 +123,7 @@ gimp_viewable_get_type (void)
"GimpViewable",
&viewable_info, 0);
g_type_add_interface_static (viewable_type,
GIMP_TYPE_CONFIG_INTERFACE,
g_type_add_interface_static (viewable_type, GIMP_TYPE_CONFIG,
&config_iface_info);
}
@ -315,13 +314,13 @@ gimp_viewable_real_get_description (GimpViewable *viewable,
}
static gboolean
gimp_viewable_serialize_property (GObject *object,
gimp_viewable_serialize_property (GimpConfig *config,
guint property_id,
const GValue *value,
GParamSpec *pspec,
GimpConfigWriter *writer)
{
GimpViewable *viewable = GIMP_VIEWABLE (object);
GimpViewable *viewable = GIMP_VIEWABLE (config);
switch (property_id)
{

11
app/dialogs/grid-dialog.c
View File

@ -80,8 +80,8 @@ grid_dialog_new (GimpImage *gimage)
grid = gimp_image_get_grid (GIMP_IMAGE (gimage));
grid_backup = g_object_new (GIMP_TYPE_GRID, NULL);
gimp_config_copy_properties (G_OBJECT (grid),
G_OBJECT (grid_backup));
gimp_config_copy_properties (GIMP_CONFIG (grid),
GIMP_CONFIG (grid_backup));
/* dialog */
dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (gimage),
@ -148,8 +148,8 @@ reset_callback (GtkWidget *widget,
grid = g_object_get_data (G_OBJECT (dialog), "grid");
grid_backup = g_object_get_data (G_OBJECT (dialog), "grid-backup");
gimp_config_copy_properties (G_OBJECT (grid_backup),
G_OBJECT (grid));
gimp_config_copy_properties (GIMP_CONFIG (grid_backup),
GIMP_CONFIG (grid));
gimp_image_grid_changed (GIMP_IMAGE (gimage));
}
@ -180,7 +180,8 @@ ok_callback (GtkWidget *widget,
grid = g_object_get_data (G_OBJECT (dialog), "grid");
grid_backup = g_object_get_data (G_OBJECT (dialog), "grid-backup");
if (! gimp_config_is_equal_to (G_OBJECT (grid_backup), G_OBJECT (grid)))
if (! gimp_config_is_equal_to (GIMP_CONFIG (grid_backup),
GIMP_CONFIG (grid)))
gimp_image_undo_push_image_grid (gimage, _("Grid"), grid_backup);
gtk_widget_destroy (dialog);

177
app/dialogs/preferences-dialog.c
View File

@ -60,7 +60,7 @@
/* preferences local functions */
static GtkWidget * prefs_dialog_new (Gimp *gimp,
GObject *config);
GimpConfig *config);
static void prefs_config_notify (GObject *config,
GParamSpec *param_spec,
GObject *config_copy);
@ -94,9 +94,9 @@ static GtkWidget *prefs_dialog = NULL;
GtkWidget *
preferences_dialog_create (Gimp *gimp)
{
GObject *config;
GObject *config_copy;
GObject *config_orig;
GimpConfig *config;
GimpConfig *config_copy;
GimpConfig *config_orig;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
@ -106,7 +106,7 @@ preferences_dialog_create (Gimp *gimp)
/* turn of autosaving while the prefs dialog is open */
gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), FALSE);
config = G_OBJECT (gimp->edit_config);
config = GIMP_CONFIG (gimp->edit_config);
config_copy = gimp_config_duplicate (config);
config_orig = gimp_config_duplicate (config);
@ -216,10 +216,10 @@ static void
prefs_cancel_callback (GtkWidget *widget,
GtkWidget *dialog)
{
Gimp *gimp;
GObject *config_orig;
GList *diff;
GList *list;
Gimp *gimp;
GimpConfig *config_orig;
GList *diff;
GList *list;
gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
config_orig = g_object_get_data (G_OBJECT (dialog), "config-orig");
@ -228,7 +228,7 @@ prefs_cancel_callback (GtkWidget *widget,
gtk_widget_destroy (dialog); /* destroys config_copy */
diff = gimp_config_diff (G_OBJECT (gimp->edit_config), config_orig,
diff = gimp_config_diff (GIMP_CONFIG (gimp->edit_config), config_orig,
GIMP_PARAM_SERIALIZE);
g_object_freeze_notify (G_OBJECT (gimp->edit_config));
@ -242,7 +242,7 @@ prefs_cancel_callback (GtkWidget *widget,
g_value_init (&value, param_spec->value_type);
g_object_get_property (config_orig,
g_object_get_property (G_OBJECT (config_orig),
param_spec->name,
&value);
g_object_set_property (G_OBJECT (gimp->edit_config),
@ -265,11 +265,11 @@ static void
prefs_ok_callback (GtkWidget *widget,
GtkWidget *dialog)
{
Gimp *gimp;
GObject *config_copy;
GList *restart_diff;
GList *confirm_diff;
GList *list;
Gimp *gimp;
GimpConfig *config_copy;
GList *restart_diff;
GList *confirm_diff;
GList *list;
gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
config_copy = g_object_get_data (G_OBJECT (dialog), "config-copy");
@ -278,7 +278,8 @@ prefs_ok_callback (GtkWidget *widget,
gtk_widget_destroy (dialog); /* destroys config_orig */
confirm_diff = gimp_config_diff (G_OBJECT (gimp->edit_config), config_copy,
confirm_diff = gimp_config_diff (GIMP_CONFIG (gimp->edit_config),
config_copy,
GIMP_PARAM_CONFIRM);
g_object_freeze_notify (G_OBJECT (gimp->edit_config));
@ -292,12 +293,10 @@ prefs_ok_callback (GtkWidget *widget,
g_value_init (&value, param_spec->value_type);
g_object_get_property (config_copy,
param_spec->name,
&value);
g_object_get_property (G_OBJECT (config_copy),
param_spec->name, &value);
g_object_set_property (G_OBJECT (gimp->edit_config),
param_spec->name,
&value);
param_spec->name, &value);
g_value_unset (&value);
}
@ -315,8 +314,8 @@ prefs_ok_callback (GtkWidget *widget,
/* spit out a solely informational warning about changed values
* which need restart
*/
restart_diff = gimp_config_diff (G_OBJECT (gimp->edit_config),
G_OBJECT (gimp->config),
restart_diff = gimp_config_diff (GIMP_CONFIG (gimp->edit_config),
GIMP_CONFIG (gimp->config),
GIMP_PARAM_RESTART);
if (restart_diff)
@ -839,8 +838,8 @@ prefs_help_func (const gchar *help_id,
}
static GtkWidget *
prefs_dialog_new (Gimp *gimp,
GObject *config)
prefs_dialog_new (Gimp *gimp,
GimpConfig *config)
{
GtkWidget *dialog;
GtkWidget *tv;
@ -881,12 +880,14 @@ prefs_dialog_new (Gimp *gimp,
gint i;
gchar *pixels_per_unit;
GObject *object;
GimpCoreConfig *core_config;
GimpDisplayConfig *display_config;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (G_IS_OBJECT (config), NULL);
g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
object = G_OBJECT (config);
core_config = GIMP_CORE_CONFIG (config);
display_config = GIMP_DISPLAY_CONFIG (config);
@ -1030,7 +1031,7 @@ prefs_dialog_new (Gimp *gimp,
gtk_container_add (GTK_CONTAINER (vbox2), hbox);
gtk_widget_show (hbox);
sizeentry = gimp_prop_coordinates_new (config,
sizeentry = gimp_prop_coordinates_new (object,
"default-image-width",
"default-image-height",
"default-unit",
@ -1062,7 +1063,7 @@ prefs_dialog_new (Gimp *gimp,
pixels_per_unit = g_strconcat (_("Pixels"), "/%s", NULL);
sizeentry2 = gimp_prop_coordinates_new (config,
sizeentry2 = gimp_prop_coordinates_new (object,
"default-xresolution",
"default-yresolution",
"default-resolution_unit",
@ -1093,11 +1094,11 @@ prefs_dialog_new (Gimp *gimp,
table = prefs_table_new (2, GTK_CONTAINER (vbox), TRUE);
prefs_enum_option_menu_add (config, "default-image-type",
prefs_enum_option_menu_add (object, "default-image-type",
GIMP_RGB, GIMP_GRAY,
_("Default Image _Type:"),
GTK_TABLE (table), 0);
prefs_memsize_entry_add (config, "max-new-image-size",
prefs_memsize_entry_add (object, "max-new-image-size",
_("Maximum Image Size:"),
GTK_TABLE (table), 1);
@ -1130,7 +1131,7 @@ prefs_dialog_new (Gimp *gimp,
gtk_container_add (GTK_CONTAINER (vbox2), scrolled_window);
gtk_widget_show (scrolled_window);
text_buffer = gimp_prop_text_buffer_new (config, "default-comment",
text_buffer = gimp_prop_text_buffer_new (object, "default-comment",
MAX_COMMENT_LENGTH);
text_view = gtk_text_view_new_with_buffer (text_buffer);
@ -1181,49 +1182,49 @@ prefs_dialog_new (Gimp *gimp,
/* Previews */
vbox2 = prefs_frame_new (_("Previews"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "layer-previews",
prefs_check_button_add (object, "layer-previews",
_("_Enable Layer & Channel Previews"),
GTK_BOX (vbox2));
table = prefs_table_new (2, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "layer-preview-size", 0, 0,
prefs_enum_option_menu_add (object, "layer-preview-size", 0, 0,
_("_Layer & Channel Preview Size:"),
GTK_TABLE (table), 0);
prefs_enum_option_menu_add (config, "navigation-preview-size", 0, 0,
prefs_enum_option_menu_add (object, "navigation-preview-size", 0, 0,
_("_Navigation Preview Size:"),
GTK_TABLE (table), 1);
/* Dialog Bahavior */
vbox2 = prefs_frame_new (_("Dialog Behavior"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "info-window-per-display",
prefs_check_button_add (object, "info-window-per-display",
_("_Info Window Per Display"),
GTK_BOX (vbox2));
/* Menus */
vbox2 = prefs_frame_new (_("Menus"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "tearoff-menus",
prefs_check_button_add (object, "tearoff-menus",
_("Enable _Tearoff Menus"),
GTK_BOX (vbox2));
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_spin_button_add (config, "last-opened-size", 1.0, 5.0, 0,
prefs_spin_button_add (object, "last-opened-size", 1.0, 5.0, 0,
_("Open _Recent Menu Size:"),
GTK_TABLE (table), 3);
/* Keyboard Shortcuts */
vbox2 = prefs_frame_new (_("Keyboard Shortcuts"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "can-change-accels",
prefs_check_button_add (object, "can-change-accels",
_("Dynamic _Keyboard Shortcuts"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "save-accels",
prefs_check_button_add (object, "save-accels",
_("Save Keyboard Shortcuts on Exit"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "restore-accels",
prefs_check_button_add (object, "restore-accels",
_("Restore Saved Keyboard Shortcuts on Start-up"),
GTK_BOX (vbox2));
@ -1253,10 +1254,10 @@ prefs_dialog_new (Gimp *gimp,
/* Window Positions */
vbox2 = prefs_frame_new (_("Window Positions"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "save-session-info",
prefs_check_button_add (object, "save-session-info",
_("_Save Window Positions on Exit"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "restore-session",
prefs_check_button_add (object, "restore-session",
_("R_estore Saved Window Positions on Start-up"),
GTK_BOX (vbox2));
@ -1301,13 +1302,13 @@ prefs_dialog_new (Gimp *gimp,
/* General */
vbox2 = prefs_frame_new (_("General"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "show-tool-tips",
prefs_check_button_add (object, "show-tool-tips",
_("Show Tool _Tips"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "use-help",
prefs_check_button_add (object, "use-help",
_("Context Sensitive _Help with \"F1\""),
GTK_BOX (vbox2));
prefs_check_button_add (config, "show-tips",
prefs_check_button_add (object, "show-tips",
_("Show Tips on _Startup"),
GTK_BOX (vbox2));
@ -1315,7 +1316,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Help Browser"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "help-browser", 0, 0,
prefs_enum_option_menu_add (object, "help-browser", 0, 0,
_("Help _Browser to Use:"),
GTK_TABLE (table), 0);
@ -1339,7 +1340,7 @@ prefs_dialog_new (Gimp *gimp,
GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_spin_button_add (config, "default-threshold", 1.0, 5.0, 0,
prefs_spin_button_add (object, "default-threshold", 1.0, 5.0, 0,
_("Default _Threshold:"),
GTK_TABLE (table), 0);
@ -1347,7 +1348,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Scaling"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (1, GTK_CONTAINER (vbox2), TRUE);
prefs_enum_option_menu_add (config, "interpolation-type", 0, 0,
prefs_enum_option_menu_add (object, "interpolation-type", 0, 0,
_("Default _Interpolation:"),
GTK_TABLE (table), 0);
@ -1381,7 +1382,7 @@ prefs_dialog_new (Gimp *gimp,
G_CALLBACK (prefs_input_devices_dialog),
NULL);
prefs_check_button_add (config, "save-device-status",
prefs_check_button_add (object, "save-device-status",
_("Save Input Device Settings on Exit"),
GTK_BOX (vbox));
@ -1417,13 +1418,13 @@ prefs_dialog_new (Gimp *gimp,
/* General */
vbox2 = prefs_frame_new (_("General"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "default-dot-for-dot",
prefs_check_button_add (object, "default-dot-for-dot",
_("Use \"_Dot for Dot\" by default"),
GTK_BOX (vbox2));
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_spin_button_add (config, "marching-ants-speed", 10.0, 100.0, 0,
prefs_spin_button_add (object, "marching-ants-speed", 10.0, 100.0, 0,
_("Marching _Ants Speed:"),
GTK_TABLE (table), 0);
@ -1431,16 +1432,16 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Zoom & Resize Behavior"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "resize-windows-on-zoom",
prefs_check_button_add (object, "resize-windows-on-zoom",
_("Resize Window on _Zoom"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "resize-windows-on-resize",
prefs_check_button_add (object, "resize-windows-on-resize",
_("Resize Window on Image _Size Change"),
GTK_BOX (vbox2));
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_boolean_option_menu_add (config, "initial-zoom-to-fit",
prefs_boolean_option_menu_add (object, "initial-zoom-to-fit",
_("Fit to Window"),
"1:1",
_("Inital Zoom Ratio:"),
@ -1450,19 +1451,19 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Pointer Movement Feedback"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "show-brush-outline",
prefs_check_button_add (object, "show-brush-outline",
_("Show _Brush Outline"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "perfect-mouse",
prefs_check_button_add (object, "perfect-mouse",
_("Perfect-but-Slow _Pointer Tracking"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "cursor-updating",
prefs_check_button_add (object, "cursor-updating",
_("Enable Cursor _Updating"),
GTK_BOX (vbox2));
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "cursor-mode", 0, 0,
prefs_enum_option_menu_add (object, "cursor-mode", 0, 0,
_("Cursor M_ode:"),
GTK_TABLE (table), 0);
@ -1485,25 +1486,25 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Default Appearance in Normal Mode"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "show-menubar",
prefs_check_button_add (object, "show-menubar",
_("Show Menubar"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "show-rulers",
prefs_check_button_add (object, "show-rulers",
_("Show _Rulers"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "show-scrollbars",
prefs_check_button_add (object, "show-scrollbars",
_("Show Scrollbars"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "show-statusbar",
prefs_check_button_add (object, "show-statusbar",
_("Show S_tatusbar"),
GTK_BOX (vbox2));
table = prefs_table_new (2, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "canvas-padding-mode", 0, 0,
prefs_enum_option_menu_add (object, "canvas-padding-mode", 0, 0,
_("Canvas Padding Mode:"),
GTK_TABLE (table), 0);
button = prefs_color_button_add (config, "canvas-padding-color",
button = prefs_color_button_add (object, "canvas-padding-color",
_("Custom Padding Color:"),
_("Select Custom Canvas Padding Color"),
GTK_TABLE (table), 1);
@ -1514,25 +1515,25 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Default Appearance in Fullscreen Mode"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "fullscreen-show-menubar",
prefs_check_button_add (object, "fullscreen-show-menubar",
_("Show Menubar"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "fullscreen-show-rulers",
prefs_check_button_add (object, "fullscreen-show-rulers",
_("Show _Rulers"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "fullscreen-show-scrollbars",
prefs_check_button_add (object, "fullscreen-show-scrollbars",
_("Show Scrollbars"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "fullscreen-show-statusbar",
prefs_check_button_add (object, "fullscreen-show-statusbar",
_("Show S_tatusbar"),
GTK_BOX (vbox2));
table = prefs_table_new (2, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "fullscreen-canvas-padding-mode", 0, 0,
prefs_enum_option_menu_add (object, "fullscreen-canvas-padding-mode", 0, 0,
_("Canvas Padding Mode:"),
GTK_TABLE (table), 0);
button = prefs_color_button_add (config, "fullscreen-canvas-padding-color",
button = prefs_color_button_add (object, "fullscreen-canvas-padding-color",
_("Custom Padding Color:"),
_("Select Custom Canvas Padding Color"),
GTK_TABLE (table), 1);
@ -1611,7 +1612,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (gettext (formats[format].title),
GTK_CONTAINER (vbox), TRUE);
entry = gimp_prop_entry_new (config, formats[format].property_name, 0);
entry = gimp_prop_entry_new (object, formats[format].property_name, 0);
gtk_box_pack_start (GTK_BOX (vbox2), entry, FALSE, FALSE, 0);
gtk_widget_show (entry);
@ -1683,10 +1684,10 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Transparency"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (2, GTK_CONTAINER (vbox2), TRUE);
prefs_enum_option_menu_add (config, "transparency-type", 0, 0,
prefs_enum_option_menu_add (object, "transparency-type", 0, 0,
_("Transparency _Type:"),
GTK_TABLE (table), 0);
prefs_enum_option_menu_add (config, "transparency-size", 0, 0,
prefs_enum_option_menu_add (object, "transparency-size", 0, 0,
_("Check _Size:"),
GTK_TABLE (table), 1);
@ -1698,13 +1699,13 @@ prefs_dialog_new (Gimp *gimp,
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_spin_button_add (config, "min-colors", 1.0, 8.0, 0,
prefs_spin_button_add (object, "min-colors", 1.0, 8.0, 0,
_("Minimum Number of Colors:"),
GTK_TABLE (table), 0);
prefs_check_button_add (config, "install-colormap",
prefs_check_button_add (object, "install-colormap",
_("Install Colormap"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "colormap-cycling",
prefs_check_button_add (object, "colormap-cycling",
_("Colormap Cycling"),
GTK_BOX (vbox2));
@ -1740,7 +1741,7 @@ prefs_dialog_new (Gimp *gimp,
abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
sizeentry = gimp_prop_coordinates_new (config,
sizeentry = gimp_prop_coordinates_new (object,
"monitor-xresolution",
"monitor-yresolution",
NULL,
@ -1841,7 +1842,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Resource Consumption"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "stingy-memory-use",
prefs_check_button_add (object, "stingy-memory-use",
_("Conservative Memory Usage"),
GTK_BOX (vbox2));
@ -1851,18 +1852,18 @@ prefs_dialog_new (Gimp *gimp,
table = prefs_table_new (3, GTK_CONTAINER (vbox2), FALSE);
#endif /* ENABLE_MP */
prefs_spin_button_add (config, "undo-levels", 1.0, 5.0, 0,
prefs_spin_button_add (object, "undo-levels", 1.0, 5.0, 0,
_("Minimal Number of Undo Levels:"),
GTK_TABLE (table), 0);
prefs_memsize_entry_add (config, "undo-size",
prefs_memsize_entry_add (object, "undo-size",
_("Maximum Undo Memory:"),
GTK_TABLE (table), 1);
prefs_memsize_entry_add (config, "tile-cache-size",
prefs_memsize_entry_add (object, "tile-cache-size",
_("Tile Cache Size:"),
GTK_TABLE (table), 2);
#ifdef ENABLE_MP
prefs_spin_button_add (config, "num-processors", 1.0, 4.0, 0,
prefs_spin_button_add (object, "num-processors", 1.0, 4.0, 0,
_("Number of Processors to Use:"),
GTK_TABLE (table), 3);
#endif /* ENABLE_MP */
@ -1871,12 +1872,12 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("File Saving"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (2, GTK_CONTAINER (vbox2), TRUE);
prefs_boolean_option_menu_add (config, "trust-dirty-flag",
prefs_boolean_option_menu_add (object, "trust-dirty-flag",
_("Only when Modified"),
_("Always"),
_("\"File -> Save\" Saves the Image:"),
GTK_TABLE (table), 0);
prefs_enum_option_menu_add (config, "thumbnail-size", 0, 0,
prefs_enum_option_menu_add (object, "thumbnail-size", 0, 0,
_("Size of Thumbnail Files:"),
GTK_TABLE (table), 1);
@ -1884,7 +1885,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Web Browser"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
fileselection = gimp_prop_file_entry_new (config, "web-browser",
fileselection = gimp_prop_file_entry_new (object, "web-browser",
_("Select Web Browser"),
FALSE, FALSE);
@ -1942,7 +1943,7 @@ prefs_dialog_new (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (dirs); i++)
{
fileselection = gimp_prop_file_entry_new (config, dirs[i].property_name,
fileselection = gimp_prop_file_entry_new (object, dirs[i].property_name,
gettext (dirs[i].fs_label),
TRUE, TRUE);
gimp_table_attach_aligned (GTK_TABLE (table), 0, i,
@ -2022,7 +2023,7 @@ prefs_dialog_new (Gimp *gimp,
&child_iter,
page_index++);
patheditor = gimp_prop_path_editor_new (config, paths[i].property_name,
patheditor = gimp_prop_path_editor_new (object, paths[i].property_name,
gettext (paths[i].fs_label));
gtk_container_add (GTK_CONTAINER (vbox), patheditor);
gtk_widget_show (patheditor);

3
app/dialogs/stroke-dialog.c
View File

@ -235,7 +235,8 @@ stroke_dialog_reset_callback (GtkWidget *widget,
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gimp_container_menu_select_item (GIMP_CONTAINER_MENU (menu),
GIMP_VIEWABLE (tool_info->paint_info));
gimp_config_reset (options);
gimp_config_reset (GIMP_CONFIG (options));
}
static void

4
app/display/gimpnavigationeditor.c
View File

@ -56,7 +56,7 @@
static void gimp_navigation_view_class_init (GimpNavigationViewClass *klass);
static void gimp_navigation_view_init (GimpNavigationView *view);
static void gimp_navigation_view_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_navigation_view_docked_iface_init (GimpDockedInterface *docked_iface);
static void gimp_navigation_view_set_docked_context (GimpDocked *docked,
GimpContext *context,
GimpContext *prev_context);
@ -190,7 +190,7 @@ gimp_navigation_view_init (GimpNavigationView *view)
}
static void
gimp_navigation_view_docked_iface_init (GimpDockedIface *docked_iface)
gimp_navigation_view_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->set_context = gimp_navigation_view_set_docked_context;
}

4
app/display/gimpnavigationview.c
View File

@ -56,7 +56,7 @@
static void gimp_navigation_view_class_init (GimpNavigationViewClass *klass);
static void gimp_navigation_view_init (GimpNavigationView *view);
static void gimp_navigation_view_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_navigation_view_docked_iface_init (GimpDockedInterface *docked_iface);
static void gimp_navigation_view_set_docked_context (GimpDocked *docked,
GimpContext *context,
GimpContext *prev_context);
@ -190,7 +190,7 @@ gimp_navigation_view_init (GimpNavigationView *view)
}
static void
gimp_navigation_view_docked_iface_init (GimpDockedIface *docked_iface)
gimp_navigation_view_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->set_context = gimp_navigation_view_set_docked_context;
}

11
app/gui/grid-dialog.c
View File

@ -80,8 +80,8 @@ grid_dialog_new (GimpImage *gimage)
grid = gimp_image_get_grid (GIMP_IMAGE (gimage));
grid_backup = g_object_new (GIMP_TYPE_GRID, NULL);
gimp_config_copy_properties (G_OBJECT (grid),
G_OBJECT (grid_backup));
gimp_config_copy_properties (GIMP_CONFIG (grid),
GIMP_CONFIG (grid_backup));
/* dialog */
dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (gimage),
@ -148,8 +148,8 @@ reset_callback (GtkWidget *widget,
grid = g_object_get_data (G_OBJECT (dialog), "grid");
grid_backup = g_object_get_data (G_OBJECT (dialog), "grid-backup");
gimp_config_copy_properties (G_OBJECT (grid_backup),
G_OBJECT (grid));
gimp_config_copy_properties (GIMP_CONFIG (grid_backup),
GIMP_CONFIG (grid));
gimp_image_grid_changed (GIMP_IMAGE (gimage));
}
@ -180,7 +180,8 @@ ok_callback (GtkWidget *widget,
grid = g_object_get_data (G_OBJECT (dialog), "grid");
grid_backup = g_object_get_data (G_OBJECT (dialog), "grid-backup");
if (! gimp_config_is_equal_to (G_OBJECT (grid_backup), G_OBJECT (grid)))
if (! gimp_config_is_equal_to (GIMP_CONFIG (grid_backup),
GIMP_CONFIG (grid)))
gimp_image_undo_push_image_grid (gimage, _("Grid"), grid_backup);
gtk_widget_destroy (dialog);

177
app/gui/preferences-dialog.c
View File

@ -60,7 +60,7 @@
/* preferences local functions */
static GtkWidget * prefs_dialog_new (Gimp *gimp,
GObject *config);
GimpConfig *config);
static void prefs_config_notify (GObject *config,
GParamSpec *param_spec,
GObject *config_copy);
@ -94,9 +94,9 @@ static GtkWidget *prefs_dialog = NULL;
GtkWidget *
preferences_dialog_create (Gimp *gimp)
{
GObject *config;
GObject *config_copy;
GObject *config_orig;
GimpConfig *config;
GimpConfig *config_copy;
GimpConfig *config_orig;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
@ -106,7 +106,7 @@ preferences_dialog_create (Gimp *gimp)
/* turn of autosaving while the prefs dialog is open */
gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), FALSE);
config = G_OBJECT (gimp->edit_config);
config = GIMP_CONFIG (gimp->edit_config);
config_copy = gimp_config_duplicate (config);
config_orig = gimp_config_duplicate (config);
@ -216,10 +216,10 @@ static void
prefs_cancel_callback (GtkWidget *widget,
GtkWidget *dialog)
{
Gimp *gimp;
GObject *config_orig;
GList *diff;
GList *list;
Gimp *gimp;
GimpConfig *config_orig;
GList *diff;
GList *list;
gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
config_orig = g_object_get_data (G_OBJECT (dialog), "config-orig");
@ -228,7 +228,7 @@ prefs_cancel_callback (GtkWidget *widget,
gtk_widget_destroy (dialog); /* destroys config_copy */
diff = gimp_config_diff (G_OBJECT (gimp->edit_config), config_orig,
diff = gimp_config_diff (GIMP_CONFIG (gimp->edit_config), config_orig,
GIMP_PARAM_SERIALIZE);
g_object_freeze_notify (G_OBJECT (gimp->edit_config));
@ -242,7 +242,7 @@ prefs_cancel_callback (GtkWidget *widget,
g_value_init (&value, param_spec->value_type);
g_object_get_property (config_orig,
g_object_get_property (G_OBJECT (config_orig),
param_spec->name,
&value);
g_object_set_property (G_OBJECT (gimp->edit_config),
@ -265,11 +265,11 @@ static void
prefs_ok_callback (GtkWidget *widget,
GtkWidget *dialog)
{
Gimp *gimp;
GObject *config_copy;
GList *restart_diff;
GList *confirm_diff;
GList *list;
Gimp *gimp;
GimpConfig *config_copy;
GList *restart_diff;
GList *confirm_diff;
GList *list;
gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
config_copy = g_object_get_data (G_OBJECT (dialog), "config-copy");
@ -278,7 +278,8 @@ prefs_ok_callback (GtkWidget *widget,
gtk_widget_destroy (dialog); /* destroys config_orig */
confirm_diff = gimp_config_diff (G_OBJECT (gimp->edit_config), config_copy,
confirm_diff = gimp_config_diff (GIMP_CONFIG (gimp->edit_config),
config_copy,
GIMP_PARAM_CONFIRM);
g_object_freeze_notify (G_OBJECT (gimp->edit_config));
@ -292,12 +293,10 @@ prefs_ok_callback (GtkWidget *widget,
g_value_init (&value, param_spec->value_type);
g_object_get_property (config_copy,
param_spec->name,
&value);
g_object_get_property (G_OBJECT (config_copy),
param_spec->name, &value);
g_object_set_property (G_OBJECT (gimp->edit_config),
param_spec->name,
&value);
param_spec->name, &value);
g_value_unset (&value);
}
@ -315,8 +314,8 @@ prefs_ok_callback (GtkWidget *widget,
/* spit out a solely informational warning about changed values
* which need restart
*/
restart_diff = gimp_config_diff (G_OBJECT (gimp->edit_config),
G_OBJECT (gimp->config),
restart_diff = gimp_config_diff (GIMP_CONFIG (gimp->edit_config),
GIMP_CONFIG (gimp->config),
GIMP_PARAM_RESTART);
if (restart_diff)
@ -839,8 +838,8 @@ prefs_help_func (const gchar *help_id,
}
static GtkWidget *
prefs_dialog_new (Gimp *gimp,
GObject *config)
prefs_dialog_new (Gimp *gimp,
GimpConfig *config)
{
GtkWidget *dialog;
GtkWidget *tv;
@ -881,12 +880,14 @@ prefs_dialog_new (Gimp *gimp,
gint i;
gchar *pixels_per_unit;
GObject *object;
GimpCoreConfig *core_config;
GimpDisplayConfig *display_config;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (G_IS_OBJECT (config), NULL);
g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
object = G_OBJECT (config);
core_config = GIMP_CORE_CONFIG (config);
display_config = GIMP_DISPLAY_CONFIG (config);
@ -1030,7 +1031,7 @@ prefs_dialog_new (Gimp *gimp,
gtk_container_add (GTK_CONTAINER (vbox2), hbox);
gtk_widget_show (hbox);
sizeentry = gimp_prop_coordinates_new (config,
sizeentry = gimp_prop_coordinates_new (object,
"default-image-width",
"default-image-height",
"default-unit",
@ -1062,7 +1063,7 @@ prefs_dialog_new (Gimp *gimp,
pixels_per_unit = g_strconcat (_("Pixels"), "/%s", NULL);
sizeentry2 = gimp_prop_coordinates_new (config,
sizeentry2 = gimp_prop_coordinates_new (object,
"default-xresolution",
"default-yresolution",
"default-resolution_unit",
@ -1093,11 +1094,11 @@ prefs_dialog_new (Gimp *gimp,
table = prefs_table_new (2, GTK_CONTAINER (vbox), TRUE);
prefs_enum_option_menu_add (config, "default-image-type",
prefs_enum_option_menu_add (object, "default-image-type",
GIMP_RGB, GIMP_GRAY,
_("Default Image _Type:"),
GTK_TABLE (table), 0);
prefs_memsize_entry_add (config, "max-new-image-size",
prefs_memsize_entry_add (object, "max-new-image-size",
_("Maximum Image Size:"),
GTK_TABLE (table), 1);
@ -1130,7 +1131,7 @@ prefs_dialog_new (Gimp *gimp,
gtk_container_add (GTK_CONTAINER (vbox2), scrolled_window);
gtk_widget_show (scrolled_window);
text_buffer = gimp_prop_text_buffer_new (config, "default-comment",
text_buffer = gimp_prop_text_buffer_new (object, "default-comment",
MAX_COMMENT_LENGTH);
text_view = gtk_text_view_new_with_buffer (text_buffer);
@ -1181,49 +1182,49 @@ prefs_dialog_new (Gimp *gimp,
/* Previews */
vbox2 = prefs_frame_new (_("Previews"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "layer-previews",
prefs_check_button_add (object, "layer-previews",
_("_Enable Layer & Channel Previews"),
GTK_BOX (vbox2));
table = prefs_table_new (2, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "layer-preview-size", 0, 0,
prefs_enum_option_menu_add (object, "layer-preview-size", 0, 0,
_("_Layer & Channel Preview Size:"),
GTK_TABLE (table), 0);
prefs_enum_option_menu_add (config, "navigation-preview-size", 0, 0,
prefs_enum_option_menu_add (object, "navigation-preview-size", 0, 0,
_("_Navigation Preview Size:"),
GTK_TABLE (table), 1);
/* Dialog Bahavior */
vbox2 = prefs_frame_new (_("Dialog Behavior"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "info-window-per-display",
prefs_check_button_add (object, "info-window-per-display",
_("_Info Window Per Display"),
GTK_BOX (vbox2));
/* Menus */
vbox2 = prefs_frame_new (_("Menus"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "tearoff-menus",
prefs_check_button_add (object, "tearoff-menus",
_("Enable _Tearoff Menus"),
GTK_BOX (vbox2));
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_spin_button_add (config, "last-opened-size", 1.0, 5.0, 0,
prefs_spin_button_add (object, "last-opened-size", 1.0, 5.0, 0,
_("Open _Recent Menu Size:"),
GTK_TABLE (table), 3);
/* Keyboard Shortcuts */
vbox2 = prefs_frame_new (_("Keyboard Shortcuts"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "can-change-accels",
prefs_check_button_add (object, "can-change-accels",
_("Dynamic _Keyboard Shortcuts"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "save-accels",
prefs_check_button_add (object, "save-accels",
_("Save Keyboard Shortcuts on Exit"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "restore-accels",
prefs_check_button_add (object, "restore-accels",
_("Restore Saved Keyboard Shortcuts on Start-up"),
GTK_BOX (vbox2));
@ -1253,10 +1254,10 @@ prefs_dialog_new (Gimp *gimp,
/* Window Positions */
vbox2 = prefs_frame_new (_("Window Positions"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "save-session-info",
prefs_check_button_add (object, "save-session-info",
_("_Save Window Positions on Exit"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "restore-session",
prefs_check_button_add (object, "restore-session",
_("R_estore Saved Window Positions on Start-up"),
GTK_BOX (vbox2));
@ -1301,13 +1302,13 @@ prefs_dialog_new (Gimp *gimp,
/* General */
vbox2 = prefs_frame_new (_("General"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "show-tool-tips",
prefs_check_button_add (object, "show-tool-tips",
_("Show Tool _Tips"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "use-help",
prefs_check_button_add (object, "use-help",
_("Context Sensitive _Help with \"F1\""),
GTK_BOX (vbox2));
prefs_check_button_add (config, "show-tips",
prefs_check_button_add (object, "show-tips",
_("Show Tips on _Startup"),
GTK_BOX (vbox2));
@ -1315,7 +1316,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Help Browser"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "help-browser", 0, 0,
prefs_enum_option_menu_add (object, "help-browser", 0, 0,
_("Help _Browser to Use:"),
GTK_TABLE (table), 0);
@ -1339,7 +1340,7 @@ prefs_dialog_new (Gimp *gimp,
GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_spin_button_add (config, "default-threshold", 1.0, 5.0, 0,
prefs_spin_button_add (object, "default-threshold", 1.0, 5.0, 0,
_("Default _Threshold:"),
GTK_TABLE (table), 0);
@ -1347,7 +1348,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Scaling"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (1, GTK_CONTAINER (vbox2), TRUE);
prefs_enum_option_menu_add (config, "interpolation-type", 0, 0,
prefs_enum_option_menu_add (object, "interpolation-type", 0, 0,
_("Default _Interpolation:"),
GTK_TABLE (table), 0);
@ -1381,7 +1382,7 @@ prefs_dialog_new (Gimp *gimp,
G_CALLBACK (prefs_input_devices_dialog),
NULL);
prefs_check_button_add (config, "save-device-status",
prefs_check_button_add (object, "save-device-status",
_("Save Input Device Settings on Exit"),
GTK_BOX (vbox));
@ -1417,13 +1418,13 @@ prefs_dialog_new (Gimp *gimp,
/* General */
vbox2 = prefs_frame_new (_("General"), GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "default-dot-for-dot",
prefs_check_button_add (object, "default-dot-for-dot",
_("Use \"_Dot for Dot\" by default"),
GTK_BOX (vbox2));
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_spin_button_add (config, "marching-ants-speed", 10.0, 100.0, 0,
prefs_spin_button_add (object, "marching-ants-speed", 10.0, 100.0, 0,
_("Marching _Ants Speed:"),
GTK_TABLE (table), 0);
@ -1431,16 +1432,16 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Zoom & Resize Behavior"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "resize-windows-on-zoom",
prefs_check_button_add (object, "resize-windows-on-zoom",
_("Resize Window on _Zoom"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "resize-windows-on-resize",
prefs_check_button_add (object, "resize-windows-on-resize",
_("Resize Window on Image _Size Change"),
GTK_BOX (vbox2));
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_boolean_option_menu_add (config, "initial-zoom-to-fit",
prefs_boolean_option_menu_add (object, "initial-zoom-to-fit",
_("Fit to Window"),
"1:1",
_("Inital Zoom Ratio:"),
@ -1450,19 +1451,19 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Pointer Movement Feedback"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "show-brush-outline",
prefs_check_button_add (object, "show-brush-outline",
_("Show _Brush Outline"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "perfect-mouse",
prefs_check_button_add (object, "perfect-mouse",
_("Perfect-but-Slow _Pointer Tracking"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "cursor-updating",
prefs_check_button_add (object, "cursor-updating",
_("Enable Cursor _Updating"),
GTK_BOX (vbox2));
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "cursor-mode", 0, 0,
prefs_enum_option_menu_add (object, "cursor-mode", 0, 0,
_("Cursor M_ode:"),
GTK_TABLE (table), 0);
@ -1485,25 +1486,25 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Default Appearance in Normal Mode"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "show-menubar",
prefs_check_button_add (object, "show-menubar",
_("Show Menubar"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "show-rulers",
prefs_check_button_add (object, "show-rulers",
_("Show _Rulers"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "show-scrollbars",
prefs_check_button_add (object, "show-scrollbars",
_("Show Scrollbars"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "show-statusbar",
prefs_check_button_add (object, "show-statusbar",
_("Show S_tatusbar"),
GTK_BOX (vbox2));
table = prefs_table_new (2, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "canvas-padding-mode", 0, 0,
prefs_enum_option_menu_add (object, "canvas-padding-mode", 0, 0,
_("Canvas Padding Mode:"),
GTK_TABLE (table), 0);
button = prefs_color_button_add (config, "canvas-padding-color",
button = prefs_color_button_add (object, "canvas-padding-color",
_("Custom Padding Color:"),
_("Select Custom Canvas Padding Color"),
GTK_TABLE (table), 1);
@ -1514,25 +1515,25 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Default Appearance in Fullscreen Mode"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "fullscreen-show-menubar",
prefs_check_button_add (object, "fullscreen-show-menubar",
_("Show Menubar"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "fullscreen-show-rulers",
prefs_check_button_add (object, "fullscreen-show-rulers",
_("Show _Rulers"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "fullscreen-show-scrollbars",
prefs_check_button_add (object, "fullscreen-show-scrollbars",
_("Show Scrollbars"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "fullscreen-show-statusbar",
prefs_check_button_add (object, "fullscreen-show-statusbar",
_("Show S_tatusbar"),
GTK_BOX (vbox2));
table = prefs_table_new (2, GTK_CONTAINER (vbox2), FALSE);
prefs_enum_option_menu_add (config, "fullscreen-canvas-padding-mode", 0, 0,
prefs_enum_option_menu_add (object, "fullscreen-canvas-padding-mode", 0, 0,
_("Canvas Padding Mode:"),
GTK_TABLE (table), 0);
button = prefs_color_button_add (config, "fullscreen-canvas-padding-color",
button = prefs_color_button_add (object, "fullscreen-canvas-padding-color",
_("Custom Padding Color:"),
_("Select Custom Canvas Padding Color"),
GTK_TABLE (table), 1);
@ -1611,7 +1612,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (gettext (formats[format].title),
GTK_CONTAINER (vbox), TRUE);
entry = gimp_prop_entry_new (config, formats[format].property_name, 0);
entry = gimp_prop_entry_new (object, formats[format].property_name, 0);
gtk_box_pack_start (GTK_BOX (vbox2), entry, FALSE, FALSE, 0);
gtk_widget_show (entry);
@ -1683,10 +1684,10 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Transparency"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (2, GTK_CONTAINER (vbox2), TRUE);
prefs_enum_option_menu_add (config, "transparency-type", 0, 0,
prefs_enum_option_menu_add (object, "transparency-type", 0, 0,
_("Transparency _Type:"),
GTK_TABLE (table), 0);
prefs_enum_option_menu_add (config, "transparency-size", 0, 0,
prefs_enum_option_menu_add (object, "transparency-size", 0, 0,
_("Check _Size:"),
GTK_TABLE (table), 1);
@ -1698,13 +1699,13 @@ prefs_dialog_new (Gimp *gimp,
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
prefs_spin_button_add (config, "min-colors", 1.0, 8.0, 0,
prefs_spin_button_add (object, "min-colors", 1.0, 8.0, 0,
_("Minimum Number of Colors:"),
GTK_TABLE (table), 0);
prefs_check_button_add (config, "install-colormap",
prefs_check_button_add (object, "install-colormap",
_("Install Colormap"),
GTK_BOX (vbox2));
prefs_check_button_add (config, "colormap-cycling",
prefs_check_button_add (object, "colormap-cycling",
_("Colormap Cycling"),
GTK_BOX (vbox2));
@ -1740,7 +1741,7 @@ prefs_dialog_new (Gimp *gimp,
abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
sizeentry = gimp_prop_coordinates_new (config,
sizeentry = gimp_prop_coordinates_new (object,
"monitor-xresolution",
"monitor-yresolution",
NULL,
@ -1841,7 +1842,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Resource Consumption"),
GTK_CONTAINER (vbox), FALSE);
prefs_check_button_add (config, "stingy-memory-use",
prefs_check_button_add (object, "stingy-memory-use",
_("Conservative Memory Usage"),
GTK_BOX (vbox2));
@ -1851,18 +1852,18 @@ prefs_dialog_new (Gimp *gimp,
table = prefs_table_new (3, GTK_CONTAINER (vbox2), FALSE);
#endif /* ENABLE_MP */
prefs_spin_button_add (config, "undo-levels", 1.0, 5.0, 0,
prefs_spin_button_add (object, "undo-levels", 1.0, 5.0, 0,
_("Minimal Number of Undo Levels:"),
GTK_TABLE (table), 0);
prefs_memsize_entry_add (config, "undo-size",
prefs_memsize_entry_add (object, "undo-size",
_("Maximum Undo Memory:"),
GTK_TABLE (table), 1);
prefs_memsize_entry_add (config, "tile-cache-size",
prefs_memsize_entry_add (object, "tile-cache-size",
_("Tile Cache Size:"),
GTK_TABLE (table), 2);
#ifdef ENABLE_MP
prefs_spin_button_add (config, "num-processors", 1.0, 4.0, 0,
prefs_spin_button_add (object, "num-processors", 1.0, 4.0, 0,
_("Number of Processors to Use:"),
GTK_TABLE (table), 3);
#endif /* ENABLE_MP */
@ -1871,12 +1872,12 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("File Saving"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (2, GTK_CONTAINER (vbox2), TRUE);
prefs_boolean_option_menu_add (config, "trust-dirty-flag",
prefs_boolean_option_menu_add (object, "trust-dirty-flag",
_("Only when Modified"),
_("Always"),
_("\"File -> Save\" Saves the Image:"),
GTK_TABLE (table), 0);
prefs_enum_option_menu_add (config, "thumbnail-size", 0, 0,
prefs_enum_option_menu_add (object, "thumbnail-size", 0, 0,
_("Size of Thumbnail Files:"),
GTK_TABLE (table), 1);
@ -1884,7 +1885,7 @@ prefs_dialog_new (Gimp *gimp,
vbox2 = prefs_frame_new (_("Web Browser"), GTK_CONTAINER (vbox), FALSE);
table = prefs_table_new (1, GTK_CONTAINER (vbox2), FALSE);
fileselection = gimp_prop_file_entry_new (config, "web-browser",
fileselection = gimp_prop_file_entry_new (object, "web-browser",
_("Select Web Browser"),
FALSE, FALSE);
@ -1942,7 +1943,7 @@ prefs_dialog_new (Gimp *gimp,
for (i = 0; i < G_N_ELEMENTS (dirs); i++)
{
fileselection = gimp_prop_file_entry_new (config, dirs[i].property_name,
fileselection = gimp_prop_file_entry_new (object, dirs[i].property_name,
gettext (dirs[i].fs_label),
TRUE, TRUE);
gimp_table_attach_aligned (GTK_TABLE (table), 0, i,
@ -2022,7 +2023,7 @@ prefs_dialog_new (Gimp *gimp,
&child_iter,
page_index++);
patheditor = gimp_prop_path_editor_new (config, paths[i].property_name,
patheditor = gimp_prop_path_editor_new (object, paths[i].property_name,
gettext (paths[i].fs_label));
gtk_container_add (GTK_CONTAINER (vbox), patheditor);
gtk_widget_show (patheditor);

3
app/gui/stroke-dialog.c
View File

@ -235,7 +235,8 @@ stroke_dialog_reset_callback (GtkWidget *widget,
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gimp_container_menu_select_item (GIMP_CONTAINER_MENU (menu),
GIMP_VIEWABLE (tool_info->paint_info));
gimp_config_reset (options);
gimp_config_reset (GIMP_CONFIG (options));
}
static void

9
app/gui/templates-commands.c
View File

@ -24,6 +24,7 @@
#include "gui-types.h"
#include "config/gimpconfig.h"
#include "config/gimpconfig-utils.h"
#include "core/gimp.h"
@ -103,8 +104,8 @@ templates_new_template_ok_callback (GtkWidget *widget,
template = g_object_get_data (G_OBJECT (dialog), "gimp-template");
gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
gimp_config_copy_properties (G_OBJECT (editor->template),
G_OBJECT (template));
gimp_config_copy_properties (GIMP_CONFIG (editor->template),
GIMP_CONFIG (template));
gimp_list_uniquefy_name (GIMP_LIST (gimp->templates),
GIMP_OBJECT (template), TRUE);
@ -181,8 +182,8 @@ templates_edit_template_ok_callback (GtkWidget *widget,
template = g_object_get_data (G_OBJECT (dialog), "gimp-template");
gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
gimp_config_copy_properties (G_OBJECT (editor->template),
G_OBJECT (template));
gimp_config_copy_properties (GIMP_CONFIG (editor->template),
GIMP_CONFIG (template));
gimp_list_uniquefy_name (GIMP_LIST (gimp->templates),
GIMP_OBJECT (template), TRUE);

12
app/gui/tool-options-commands.c
View File

@ -66,8 +66,8 @@ tool_options_save_to_cmd_callback (GtkWidget *widget,
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (options)));
gimp_config_copy_properties (G_OBJECT (options->tool_info->tool_options),
G_OBJECT (options));
gimp_config_copy_properties (GIMP_CONFIG (options->tool_info->tool_options),
GIMP_CONFIG (options));
gimp_object_set_name (GIMP_OBJECT (options), name);
g_free (name);
@ -105,8 +105,8 @@ tool_options_restore_from_cmd_callback (GtkWidget *widget,
{
GimpToolOptions *options = GIMP_TOOL_OPTIONS (data);
gimp_config_copy_properties (G_OBJECT (options),
G_OBJECT (options->tool_info->tool_options));
gimp_config_copy_properties (GIMP_CONFIG (options),
GIMP_CONFIG (options->tool_info->tool_options));
}
void
@ -170,12 +170,12 @@ tool_options_save_callback (GtkWidget *widget,
gpointer data)
{
GimpToolInfo *tool_info = GIMP_TOOL_INFO (data);
GObject *copy;
GimpConfig *copy;
if (! name || ! strlen (name))
name = _("Saved Options");
copy = gimp_config_duplicate (G_OBJECT (tool_info->tool_options));
copy = gimp_config_duplicate (GIMP_CONFIG (tool_info->tool_options));
gimp_object_set_name (GIMP_OBJECT (copy), name);
gimp_list_uniquefy_name (GIMP_LIST (tool_info->options_presets),

11
app/paint/gimppaintcore.c
View File

@ -1224,10 +1224,19 @@ gimp_paint_core_subsample_mask (GimpPaintCore *core,
if (mask == core->last_brush_mask && ! core->cache_invalid)
{
if (core->kernel_brushes[index2][index1])
return core->kernel_brushes[index2][index1];
{
g_printerr (".");
return core->kernel_brushes[index2][index1];
}
else
{
g_printerr ("o");
}
}
else
{
g_printerr ("*");
for (i = 0; i < KERNEL_SUBSAMPLE + 1; i++)
for (j = 0; j < KERNEL_SUBSAMPLE + 1; j++)
if (core->kernel_brushes[i][j])

3
app/pdb/gimprc_cmds.c
View File

@ -132,7 +132,8 @@ gimprc_set_invoker (Gimp *gimp,
/* set the value in edit_config so we don't accidentially set
* GIMP_PARAM_RESTART values via the PDB
*/
gimp_config_add_unknown_token (G_OBJECT (gimp->edit_config), token, value);
gimp_config_add_unknown_token (GIMP_CONFIG (gimp->edit_config),
token, value);
success = TRUE;
}

8
app/text/gimptext-parasite.c
View File

@ -58,7 +58,7 @@ gimp_text_to_parasite (const GimpText *text)
g_return_val_if_fail (GIMP_IS_TEXT (text), NULL);
str = gimp_config_serialize_to_string (G_OBJECT (text), NULL);
str = gimp_config_serialize_to_string (GIMP_CONFIG (text), NULL);
g_return_val_if_fail (str != NULL, NULL);
parasite = gimp_parasite_new (gimp_text_parasite_name (),
@ -82,10 +82,10 @@ gimp_text_from_parasite (const GimpParasite *parasite)
str = gimp_parasite_data (parasite);
g_return_val_if_fail (str != NULL, NULL);
text = g_object_new (GIMP_TYPE_TEXT, NULL);
if (! gimp_config_deserialize_string (G_OBJECT (text),
if (! gimp_config_deserialize_string (GIMP_CONFIG (text),
str,
gimp_parasite_data_size (parasite),
NULL,
@ -120,7 +120,7 @@ enum
COLOR = 5,
LAYER_ALIGNMENT = 6,
XLFD = 7,
NUM_PARAMS
NUM_PARAMS
};
GimpText *

11
app/text/gimptext.c
View File

@ -103,18 +103,17 @@ gimp_text_get_type (void)
0, /* n_preallocs */
NULL /* instance_init */
};
static const GInterfaceInfo text_iface_info =
static const GInterfaceInfo text_iface_info =
{
NULL, /* iface_init */
NULL, /* iface_finalize */
NULL, /* iface_finalize */
NULL /* iface_data */
};
text_type = g_type_register_static (GIMP_TYPE_OBJECT,
"GimpText", &text_info, 0);
g_type_add_interface_static (text_type,
GIMP_TYPE_CONFIG_INTERFACE,
g_type_add_interface_static (text_type, GIMP_TYPE_CONFIG,
&text_iface_info);
}
@ -441,7 +440,7 @@ gimp_text_get_memsize (GimpObject *object,
}
/*
/*
* basically copied from gtk_get_default_language()
*/
static gchar *
@ -449,7 +448,7 @@ gimp_text_get_default_language (void)
{
gchar *lang;
gchar *p;
#ifdef G_OS_WIN32
p = getenv ("LC_ALL");
if (p != NULL)

2
app/text/gimptextlayer.c
View File

@ -215,7 +215,7 @@ gimp_text_layer_duplicate (GimpItem *item,
new_text_layer = GIMP_TEXT_LAYER (new_item);
new_text_layer->text =
GIMP_TEXT (gimp_config_duplicate (G_OBJECT (text_layer->text)));
GIMP_TEXT (gimp_config_duplicate (GIMP_CONFIG (text_layer->text)));
g_signal_connect_object (new_text_layer->text, "notify",
G_CALLBACK (gimp_text_layer_notify_text),

4
app/tools/gimp-tools.c
View File

@ -228,7 +228,7 @@ gimp_tools_restore (Gimp *gimp)
filename = gimp_tool_options_build_filename (tool_info->tool_options,
"presets");
gimp_config_deserialize_file (G_OBJECT (tool_info->options_presets),
gimp_config_deserialize_file (GIMP_CONFIG (tool_info->options_presets),
filename,
gimp, NULL);
g_free (filename);
@ -274,7 +274,7 @@ gimp_tools_save (Gimp *gimp)
footer = g_strdup_printf ("end of %s options presets",
GIMP_OBJECT (tool_info)->name);
gimp_config_serialize_to_file (G_OBJECT (tool_info->options_presets),
gimp_config_serialize_to_file (GIMP_CONFIG (tool_info->options_presets),
filename, header, footer,
NULL, NULL);

6
app/tools/gimptexttool.c
View File

@ -316,7 +316,7 @@ gimp_text_tool_create_layer (GimpTextTool *text_tool)
gimage = text_tool->gdisp->gimage;
text = GIMP_TEXT (gimp_config_duplicate (G_OBJECT (options->text)));
text = GIMP_TEXT (gimp_config_duplicate (GIMP_CONFIG (options->text)));
layer = gimp_text_layer_new (gimage, text);
@ -381,8 +381,8 @@ gimp_text_tool_connect (GimpTextTool *tool,
{
tool->text = g_object_ref (text);
gimp_config_copy_properties (G_OBJECT (tool->text),
G_OBJECT (options->text));
gimp_config_copy_properties (GIMP_CONFIG (tool->text),
GIMP_CONFIG (options->text));
gimp_config_connect (G_OBJECT (options->text), G_OBJECT (tool->text));

4
app/widgets/gimpcoloreditor.c
View File

@ -39,7 +39,7 @@
static void gimp_color_editor_class_init (GimpColorEditorClass *klass);
static void gimp_color_editor_init (GimpColorEditor *editor);
static void gimp_color_editor_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_color_editor_docked_iface_init (GimpDockedInterface *docked_iface);
static void gimp_color_editor_destroy (GtkObject *object);
@ -286,7 +286,7 @@ gimp_color_editor_init (GimpColorEditor *editor)
}
static void
gimp_color_editor_docked_iface_init (GimpDockedIface *docked_iface)
gimp_color_editor_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->set_context = gimp_color_editor_set_docked_context;
}

4
app/widgets/gimpcontainereditor.c
View File

@ -42,7 +42,7 @@
static void gimp_container_editor_class_init (GimpContainerEditorClass *klass);
static void gimp_container_editor_init (GimpContainerEditor *view);
static void gimp_container_editor_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_container_editor_docked_iface_init (GimpDockedInterface *docked_iface);
static gboolean gimp_container_editor_select_item (GtkWidget *widget,
GimpViewable *viewable,
@ -126,7 +126,7 @@ gimp_container_editor_init (GimpContainerEditor *view)
}
static void
gimp_container_editor_docked_iface_init (GimpDockedIface *docked_iface)
gimp_container_editor_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->get_preview = gimp_container_editor_get_preview;
docked_iface->set_context = gimp_container_editor_set_context;

6
app/widgets/gimpcontainerview.c
View File

@ -54,9 +54,9 @@ enum
static void gimp_container_view_class_init (GimpContainerViewClass *klass);
static void gimp_container_view_init (GimpContainerView *view,
GimpContainerViewClass *klass);
static void gimp_container_view_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_container_view_docked_iface_init (GimpDockedInterface *docked_iface);
static void gimp_container_view_destroy (GtkObject *object);
static void gimp_container_view_destroy (GtkObject *object);
static void gimp_container_view_real_set_container (GimpContainerView *view,
GimpContainer *container);
@ -242,7 +242,7 @@ gimp_container_view_destroy (GtkObject *object)
}
static void
gimp_container_view_docked_iface_init (GimpDockedIface *docked_iface)
gimp_container_view_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->get_preview = gimp_container_view_get_preview;
docked_iface->set_context = gimp_container_view_set_docked_context;

4
app/widgets/gimpdevices.c
View File

@ -129,7 +129,7 @@ gimp_devices_restore (Gimp *gimp)
filename = gimp_personal_rc_file ("devicerc");
if (! gimp_config_deserialize_file (G_OBJECT (manager->device_info_list),
if (! gimp_config_deserialize_file (GIMP_CONFIG (manager->device_info_list),
filename,
gimp,
&error))
@ -171,7 +171,7 @@ gimp_devices_save (Gimp *gimp)
filename = gimp_personal_rc_file ("devicerc");
if (! gimp_config_serialize_to_file (G_OBJECT (manager->device_info_list),
if (! gimp_config_serialize_to_file (GIMP_CONFIG (manager->device_info_list),
filename,
"GIMP devicerc",
"end of devicerc",

16
app/widgets/gimpdocked.c
View File

@ -30,7 +30,7 @@
#include "gimpdocked.h"
static void gimp_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_docked_iface_init (GimpDockedInterface *docked_iface);
GType
@ -42,7 +42,7 @@ gimp_docked_interface_get_type (void)
{
static const GTypeInfo docked_iface_info =
{
sizeof (GimpDockedIface),
sizeof (GimpDockedInterface),
(GBaseInitFunc) gimp_docked_iface_init,
(GBaseFinalizeFunc) NULL,
};
@ -59,7 +59,7 @@ gimp_docked_interface_get_type (void)
}
static void
gimp_docked_iface_init (GimpDockedIface *docked_iface)
gimp_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->set_aux_info = NULL;
docked_iface->get_aux_info = NULL;
@ -72,7 +72,7 @@ void
gimp_docked_set_aux_info (GimpDocked *docked,
GList *aux_info)
{
GimpDockedIface *docked_iface;
GimpDockedInterface *docked_iface;
g_return_if_fail (GIMP_IS_DOCKED (docked));
@ -85,7 +85,7 @@ gimp_docked_set_aux_info (GimpDocked *docked,
GList *
gimp_docked_get_aux_info (GimpDocked *docked)
{
GimpDockedIface *docked_iface;
GimpDockedInterface *docked_iface;
g_return_val_if_fail (GIMP_IS_DOCKED (docked), NULL);
@ -102,7 +102,7 @@ gimp_docked_get_preview (GimpDocked *docked,
GimpContext *context,
GtkIconSize size)
{
GimpDockedIface *docked_iface;
GimpDockedInterface *docked_iface;
g_return_val_if_fail (GIMP_IS_DOCKED (docked), NULL);
@ -119,7 +119,7 @@ gimp_docked_set_context (GimpDocked *docked,
GimpContext *context,
GimpContext *prev_context)
{
GimpDockedIface *docked_iface;
GimpDockedInterface *docked_iface;
g_return_if_fail (GIMP_IS_DOCKED (docked));
g_return_if_fail (context == NULL || GIMP_IS_CONTEXT (context));
@ -135,7 +135,7 @@ GimpItemFactory *
gimp_docked_get_menu (GimpDocked *docked,
gpointer *item_factory_data)
{
GimpDockedIface *docked_iface;
GimpDockedInterface *docked_iface;
g_return_val_if_fail (GIMP_IS_DOCKED (docked), NULL);
g_return_val_if_fail (item_factory_data != NULL, NULL);

4
app/widgets/gimpdocked.h
View File

@ -26,10 +26,10 @@
#define GIMP_TYPE_DOCKED (gimp_docked_interface_get_type ())
#define GIMP_IS_DOCKED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DOCKED))
#define GIMP_DOCKED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DOCKED, GimpDocked))
#define GIMP_DOCKED_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GIMP_TYPE_DOCKED, GimpDockedIface))
#define GIMP_DOCKED_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GIMP_TYPE_DOCKED, GimpDockedInterface))
struct _GimpDockedIface
struct _GimpDockedInterface
{
GTypeInterface base_iface;

4
app/widgets/gimpeditor.c
View File

@ -41,7 +41,7 @@
static void gimp_editor_class_init (GimpEditorClass *klass);
static void gimp_editor_init (GimpEditor *editor);
static void gimp_editor_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_editor_docked_iface_init (GimpDockedInterface *docked_iface);
static void gimp_editor_destroy (GtkObject *object);
static void gimp_editor_style_set (GtkWidget *widget,
@ -142,7 +142,7 @@ gimp_editor_init (GimpEditor *editor)
}
static void
gimp_editor_docked_iface_init (GimpDockedIface *docked_iface)
gimp_editor_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->get_menu = gimp_editor_get_menu;
}

4
app/widgets/gimpimageeditor.c
View File

@ -32,7 +32,7 @@
static void gimp_image_editor_class_init (GimpImageEditorClass *klass);
static void gimp_image_editor_init (GimpImageEditor *editor);
static void gimp_image_editor_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_image_editor_docked_iface_init (GimpDockedInterface *docked_iface);
static void gimp_image_editor_set_docked_context (GimpDocked *docked,
GimpContext *context,
GimpContext *prev_context);
@ -106,7 +106,7 @@ gimp_image_editor_init (GimpImageEditor *editor)
}
static void
gimp_image_editor_docked_iface_init (GimpDockedIface *docked_iface)
gimp_image_editor_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->set_context = gimp_image_editor_set_docked_context;
}

4
app/widgets/gimpitemtreeview.c
View File

@ -64,7 +64,7 @@ static void gimp_item_tree_view_class_init (GimpItemTreeViewClass *klass);
static void gimp_item_tree_view_init (GimpItemTreeView *view,
GimpItemTreeViewClass *view_class);
static void gimp_item_tree_view_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_item_tree_view_docked_iface_init (GimpDockedInterface *docked_iface);
static void gimp_item_tree_view_set_docked_context (GimpDocked *docked,
GimpContext *context,
GimpContext *prev_context);
@ -354,7 +354,7 @@ gimp_item_tree_view_init (GimpItemTreeView *view,
}
static void
gimp_item_tree_view_docked_iface_init (GimpDockedIface *docked_iface)
gimp_item_tree_view_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->set_context = gimp_item_tree_view_set_docked_context;
}

6
app/widgets/gimptemplateeditor.c
View File

@ -494,8 +494,8 @@ gimp_template_editor_set_template (GimpTemplateEditor *editor,
gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (editor->size_se), 1,
template->yresolution, FALSE);
gimp_config_copy_properties (G_OBJECT (template),
G_OBJECT (editor->template));
gimp_config_copy_properties (GIMP_CONFIG (template),
GIMP_CONFIG (editor->template));
g_signal_connect (editor->template, "notify",
G_CALLBACK (gimp_template_editor_template_notify),
@ -508,7 +508,7 @@ gimp_template_editor_get_template (GimpTemplateEditor *editor)
{
g_return_val_if_fail (GIMP_IS_TEMPLATE_EDITOR (editor), NULL);
return GIMP_TEMPLATE (gimp_config_duplicate (G_OBJECT (editor->template)));
return GIMP_TEMPLATE (gimp_config_duplicate (GIMP_CONFIG (editor->template)));
}

3
app/widgets/gimptemplateview.c
View File

@ -294,7 +294,8 @@ gimp_template_view_duplicate_clicked (GtkWidget *widget,
{
GimpTemplate *new_template;
new_template = GIMP_TEMPLATE (gimp_config_duplicate (G_OBJECT (template)));
new_template =
GIMP_TEMPLATE (gimp_config_duplicate (GIMP_CONFIG (template)));
gimp_list_uniquefy_name (GIMP_LIST (editor->view->container),
GIMP_OBJECT (new_template), TRUE);

4
app/widgets/gimptooloptionseditor.c
View File

@ -46,7 +46,7 @@
static void gimp_tool_options_editor_class_init (GimpToolOptionsEditorClass *klass);
static void gimp_tool_options_editor_init (GimpToolOptionsEditor *editor);
static void gimp_tool_options_editor_docked_iface_init (GimpDockedIface *docked_iface);
static void gimp_tool_options_editor_docked_iface_init (GimpDockedInterface *docked_iface);
static void gimp_tool_options_editor_destroy (GtkObject *object);
@ -200,7 +200,7 @@ gimp_tool_options_editor_init (GimpToolOptionsEditor *editor)
}
static void
gimp_tool_options_editor_docked_iface_init (GimpDockedIface *docked_iface)
gimp_tool_options_editor_docked_iface_init (GimpDockedInterface *docked_iface)
{
docked_iface->get_preview = gimp_tool_options_editor_get_preview;
}

2
app/widgets/widgets-types.h
View File

@ -99,7 +99,7 @@ typedef struct _GimpImageDock GimpImageDock;
typedef struct _GimpDockable GimpDockable;
typedef struct _GimpDockbook GimpDockbook;
typedef struct _GimpDocked GimpDocked; /* dummy typedef */
typedef struct _GimpDockedIface GimpDockedIface;
typedef struct _GimpDockedInterface GimpDockedInterface;
typedef struct _GimpContainerPopup GimpContainerPopup;
typedef struct _GimpViewableButton GimpViewableButton;

96
libgimpconfig/gimpconfig-deserialize.c
View File

@ -54,13 +54,13 @@
* couldn't parse it.
*/
static GTokenType gimp_config_deserialize_unknown (GObject *object,
static GTokenType gimp_config_deserialize_unknown (GimpConfig *object,
GScanner *scanner);
static GTokenType gimp_config_deserialize_property (GObject *object,
static GTokenType gimp_config_deserialize_property (GimpConfig *object,
GScanner *scanner,
gint nest_level);
static GTokenType gimp_config_deserialize_value (GValue *value,
GObject *object,
GimpConfig *object,
GParamSpec *prop_spec,
GScanner *scanner);
static GTokenType gimp_config_deserialize_fundamental (GValue *value,
@ -82,12 +82,12 @@ static GTokenType gimp_config_deserialize_matrix2 (GValue *value,
GParamSpec *prop_spec,
GScanner *scanner);
static GTokenType gimp_config_deserialize_object (GValue *value,
GObject *object,
GimpConfig *object,
GParamSpec *prop_spec,
GScanner *scanner,
gint nest_level);
static GTokenType gimp_config_deserialize_value_array (GValue *value,
GObject *object,
GimpConfig *object,
GParamSpec *prop_spec,
GScanner *scanner);
static GTokenType gimp_config_deserialize_any (GValue *value,
@ -100,7 +100,7 @@ static inline gboolean scanner_string_utf8_valid (GScanner *scanner,
/**
* gimp_config_deserialize_properties:
* @object: a #GObject.
* @object: a #GimpConfig.
* @scanner: a #GScanner.
* @nest_level:
* @store_unknown_tokens: %TRUE if you want to store unknown tokens.
@ -116,10 +116,10 @@ static inline gboolean scanner_string_utf8_valid (GScanner *scanner,
* Return value:
**/
gboolean
gimp_config_deserialize_properties (GObject *object,
GScanner *scanner,
gint nest_level,
gboolean store_unknown_tokens)
gimp_config_deserialize_properties (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gboolean store_unknown_tokens)
{
GObjectClass *klass;
GParamSpec **property_specs;
@ -130,15 +130,15 @@ gimp_config_deserialize_properties (GObject *object,
GTokenType token;
GTokenType next;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
if (!property_specs)
return TRUE;
scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (object));
scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config));
old_scope_id = g_scanner_set_scope (scanner, scope_id);
for (i = 0; i < n_property_specs; i++)
@ -154,7 +154,7 @@ gimp_config_deserialize_properties (GObject *object,
g_free (property_specs);
g_object_freeze_notify (object);
g_object_freeze_notify (G_OBJECT (config));
token = G_TOKEN_LEFT_PAREN;
@ -178,11 +178,11 @@ gimp_config_deserialize_properties (GObject *object,
break;
case G_TOKEN_IDENTIFIER:
token = gimp_config_deserialize_unknown (object, scanner);
token = gimp_config_deserialize_unknown (config, scanner);
break;
case G_TOKEN_SYMBOL:
token = gimp_config_deserialize_property (object,
token = gimp_config_deserialize_property (config,
scanner, nest_level);
break;
@ -197,7 +197,7 @@ gimp_config_deserialize_properties (GObject *object,
g_scanner_set_scope (scanner, old_scope_id);
g_object_thaw_notify (object);
g_object_thaw_notify (G_OBJECT (config));
/* If store_unknown_tokens is TRUE but the unknown token value couldn't
be parsed the default error message is rather confusing.
@ -214,8 +214,8 @@ gimp_config_deserialize_properties (GObject *object,
}
static GTokenType
gimp_config_deserialize_unknown (GObject *object,
GScanner *scanner)
gimp_config_deserialize_unknown (GimpConfig *object,
GScanner *scanner)
{
gchar *key;
@ -239,12 +239,12 @@ gimp_config_deserialize_unknown (GObject *object,
}
static GTokenType
gimp_config_deserialize_property (GObject *object,
gimp_config_deserialize_property (GimpConfig *config,
GScanner *scanner,
gint nest_level)
{
GTypeClass *owner_class;
GimpConfigInterface *gimp_config_iface;
GimpConfigInterface *config_iface;
GimpConfigInterface *parent_iface;
GParamSpec *prop_spec;
GTokenType token = G_TOKEN_RIGHT_PAREN;
@ -256,8 +256,7 @@ gimp_config_deserialize_property (GObject *object,
owner_class = g_type_class_peek (prop_spec->owner_type);
gimp_config_iface = g_type_interface_peek (owner_class,
GIMP_TYPE_CONFIG_INTERFACE);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
@ -269,25 +268,25 @@ gimp_config_deserialize_property (GObject *object,
* GimpConfigInterface is inherited from one of it's parent classes
* and thus not able to handle param_spec->owner_type's properties).
*/
if (gimp_config_iface)
if (config_iface)
{
GTypeClass *owner_parent_class;
owner_parent_class = g_type_class_peek_parent (owner_class),
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG_INTERFACE);
GIMP_TYPE_CONFIG);
}
if (gimp_config_iface &&
gimp_config_iface != parent_iface && /* see comment above */
gimp_config_iface->deserialize_property &&
gimp_config_iface->deserialize_property (object,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->deserialize_property &&
config_iface->deserialize_property (config,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
{
/* nop */
}
@ -295,11 +294,11 @@ gimp_config_deserialize_property (GObject *object,
{
if (G_VALUE_HOLDS_OBJECT (&value))
token = gimp_config_deserialize_object (&value,
object, prop_spec,
config, prop_spec,
scanner, nest_level);
else
token = gimp_config_deserialize_value (&value,
object, prop_spec, scanner);
config, prop_spec, scanner);
}
if (token == G_TOKEN_RIGHT_PAREN &&
@ -307,13 +306,13 @@ gimp_config_deserialize_property (GObject *object,
{
if (! (G_VALUE_HOLDS_OBJECT (&value) &&
(prop_spec->flags & GIMP_PARAM_AGGREGATE)))
g_object_set_property (object, prop_spec->name, &value);
g_object_set_property (G_OBJECT (config), prop_spec->name, &value);
}
#ifdef CONFIG_DEBUG
else
{
g_warning ("couldn't deserialize property %s::%s of type %s",
g_type_name (G_TYPE_FROM_INSTANCE (object)),
g_type_name (G_TYPE_FROM_INSTANCE (config)),
prop_spec->name,
g_type_name (prop_spec->value_type));
}
@ -326,7 +325,7 @@ gimp_config_deserialize_property (GObject *object,
static GTokenType
gimp_config_deserialize_value (GValue *value,
GObject *object,
GimpConfig *object,
GParamSpec *prop_spec,
GScanner *scanner)
{
@ -625,28 +624,27 @@ gimp_config_deserialize_matrix2 (GValue *value,
static GTokenType
gimp_config_deserialize_object (GValue *value,
GObject *object,
GimpConfig *config,
GParamSpec *prop_spec,
GScanner *scanner,
gint nest_level)
{
GimpConfigInterface *gimp_config_iface;
GObject *prop_object;
GimpConfigInterface *config_iface;
GimpConfig *prop_object;
g_object_get_property (object, prop_spec->name, value);
g_object_get_property (G_OBJECT (config), prop_spec->name, value);
prop_object = g_value_get_object (value);
if (! prop_object)
return G_TOKEN_RIGHT_PAREN;
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (prop_object);
config_iface = GIMP_CONFIG_GET_INTERFACE (prop_object);
if (! gimp_config_iface)
if (! config_iface)
return gimp_config_deserialize_any (value, prop_spec, scanner);
if (! gimp_config_iface->deserialize (prop_object,
scanner, nest_level + 1, NULL))
if (! config_iface->deserialize (prop_object, scanner, nest_level + 1, NULL))
return G_TOKEN_NONE;
return G_TOKEN_RIGHT_PAREN;
@ -654,7 +652,7 @@ gimp_config_deserialize_object (GValue *value,
static GTokenType
gimp_config_deserialize_value_array (GValue *value,
GObject *object,
GimpConfig *config,
GParamSpec *prop_spec,
GScanner *scanner)
{
@ -677,7 +675,7 @@ gimp_config_deserialize_value_array (GValue *value,
g_value_init (&array_value, array_spec->element_spec->value_type);
token = gimp_config_deserialize_value (&array_value,
object,
config,
array_spec->element_spec,
scanner);

8
libgimpconfig/gimpconfig-deserialize.h
View File

@ -23,10 +23,10 @@
#define __GIMP_CONFIG_DESERIALIZE_H__
gboolean gimp_config_deserialize_properties (GObject *object,
GScanner *scanner,
gint nest_level,
gboolean store_unknown_tokens);
gboolean gimp_config_deserialize_properties (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gboolean store_unknown_tokens);
#endif /* __GIMP_CONFIG_DESERIALIZE_H__ */

238
libgimpconfig/gimpconfig-iface.c
View File

@ -43,19 +43,19 @@
* The GimpConfig serialization and deserialization interface.
*/
static void gimp_config_iface_init (GimpConfigInterface *gimp_config_iface);
static void gimp_config_iface_init (GimpConfigInterface *gimp_config_iface);
static gboolean gimp_config_iface_serialize (GObject *object,
GimpConfigWriter *writer,
gpointer data);
static gboolean gimp_config_iface_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data);
static GObject *gimp_config_iface_duplicate (GObject *object);
static gboolean gimp_config_iface_equal (GObject *a,
GObject *b);
static void gimp_config_iface_reset (GObject *object);
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);
GType
@ -96,25 +96,25 @@ gimp_config_iface_init (GimpConfigInterface *gimp_config_iface)
}
static gboolean
gimp_config_iface_serialize (GObject *object,
gimp_config_iface_serialize (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data)
{
return gimp_config_serialize_properties (object, writer);
return gimp_config_serialize_properties (config, writer);
}
static gboolean
gimp_config_iface_deserialize (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data)
gimp_config_iface_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
return gimp_config_deserialize_properties (object,
return gimp_config_deserialize_properties (config,
scanner, nest_level, FALSE);
}
static GObject *
gimp_config_iface_duplicate (GObject *object)
static GimpConfig *
gimp_config_iface_duplicate (GimpConfig *config)
{
GObjectClass *klass;
GParamSpec **property_specs;
@ -122,9 +122,9 @@ gimp_config_iface_duplicate (GObject *object)
GParameter *construct_params = NULL;
gint n_construct_params = 0;
guint i;
GObject *dup;
GimpConfig *dup;
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
@ -145,14 +145,14 @@ gimp_config_iface_duplicate (GObject *object)
construct_params->name = prop_spec->name;
g_value_init (&construct_params->value, prop_spec->value_type);
g_object_get_property (object, prop_spec->name,
g_object_get_property (G_OBJECT (config), prop_spec->name,
&construct_param->value);
}
}
g_free (property_specs);
dup = g_object_newv (G_TYPE_FROM_INSTANCE (object),
dup = g_object_newv (G_TYPE_FROM_INSTANCE (config),
n_construct_params, construct_params);
for (i = 0; i < n_construct_params; i++)
@ -160,14 +160,14 @@ gimp_config_iface_duplicate (GObject *object)
g_free (construct_params);
gimp_config_copy_properties (object, dup);
gimp_config_copy_properties (config, dup);
return dup;
}
static gboolean
gimp_config_iface_equal (GObject *a,
GObject *b)
gimp_config_iface_equal (GimpConfig *a,
GimpConfig *b)
{
GObjectClass *klass;
GParamSpec **property_specs;
@ -192,8 +192,8 @@ gimp_config_iface_equal (GObject *a,
g_value_init (&a_value, prop_spec->value_type);
g_value_init (&b_value, prop_spec->value_type);
g_object_get_property (a, prop_spec->name, &a_value);
g_object_get_property (b, prop_spec->name, &b_value);
g_object_get_property (G_OBJECT (a), prop_spec->name, &a_value);
g_object_get_property (G_OBJECT (b), prop_spec->name, &b_value);
equal = (g_param_values_cmp (prop_spec, &a_value, &b_value) == 0);
@ -207,103 +207,91 @@ gimp_config_iface_equal (GObject *a,
}
static void
gimp_config_iface_reset (GObject *object)
gimp_config_iface_reset (GimpConfig *config)
{
gimp_config_reset_properties (object);
gimp_config_reset_properties (config);
}
/**
* gimp_config_serialize_to_file:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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:
*
* Serializes the object properties of @object to the file specified
* 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 @object's #GimpConfigInterface.
* calls the serialize function of the @config's #GimpConfigInterface.
*
* Return value: %TRUE if serialization succeeded, %FALSE otherwise.
**/
gboolean
gimp_config_serialize_to_file (GObject *object,
gimp_config_serialize_to_file (GimpConfig *config,
const gchar *filename,
const gchar *header,
const gchar *footer,
gpointer data,
GError **error)
{
GimpConfigInterface *gimp_config_iface;
GimpConfigWriter *writer;
GimpConfigWriter *writer;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
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);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
writer = gimp_config_writer_new_file (filename, TRUE, header, error);
if (!writer)
return FALSE;
gimp_config_iface->serialize (object, writer, data);
GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
return gimp_config_writer_finish (writer, footer, error);
}
gboolean
gimp_config_serialize_to_fd (GObject *object,
gint fd,
gpointer data)
gimp_config_serialize_to_fd (GimpConfig *config,
gint fd,
gpointer data)
{
GimpConfigInterface *gimp_config_iface;
GimpConfigWriter *writer;
GimpConfigWriter *writer;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
g_return_val_if_fail (fd > 0, FALSE);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
writer = gimp_config_writer_new_fd (fd);
if (!writer)
return FALSE;
gimp_config_iface->serialize (object, writer, data);
GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
return gimp_config_writer_finish (writer, NULL, NULL);
}
/**
* gimp_config_serialize_to_string:
* @object: a #GObject that implements the #GimpConfigInterface.
* @config: a #GObject that implements the #GimpConfigInterface.
* @data: user data passed to the serialize implementation.
*
* Serializes the object properties of @object to a string.
* Serializes the object properties of @config to a string.
*
* Return value: a newly allocated %NUL-terminated string.
**/
gchar *
gimp_config_serialize_to_string (GObject *object,
gpointer data)
gimp_config_serialize_to_string (GimpConfig *config,
gpointer data)
{
GimpConfigInterface *gimp_config_iface;
GimpConfigWriter *writer;
GString *str;
GimpConfigWriter *writer;
GString *str;
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
str = g_string_new (NULL);
writer = gimp_config_writer_new_string (str);
gimp_config_iface->serialize (object, writer, data);
GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data);
gimp_config_writer_finish (writer, NULL, NULL);
@ -312,40 +300,37 @@ gimp_config_serialize_to_string (GObject *object,
/**
* gimp_config_deserialize:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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:
*
* Opens the file specified by @filename, reads configuration data
* from it and configures @object accordingly. Basically this function
* from it and configures @config accordingly. Basically this function
* creates a properly configured #GScanner for you and calls the
* deserialize function of the @object's #GimpConfigInterface.
* deserialize function of the @config's #GimpConfigInterface.
*
* Return value: %TRUE if deserialization succeeded, %FALSE otherwise.
**/
gboolean
gimp_config_deserialize_file (GObject *object,
gimp_config_deserialize_file (GimpConfig *config,
const gchar *filename,
gpointer data,
GError **error)
{
GimpConfigInterface *gimp_config_iface;
GScanner *scanner;
gboolean success;
GScanner *scanner;
gboolean success;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
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);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
scanner = gimp_scanner_new_file (filename, error);
if (! scanner)
return FALSE;
success = gimp_config_iface->deserialize (object, scanner, 0, data);
success = GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
scanner, 0, data);
gimp_scanner_destroy (scanner);
@ -357,39 +342,36 @@ gimp_config_deserialize_file (GObject *object,
/**
* gimp_config_deserialize_string:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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:
* @error:
*
* Configures @object from @text. Basically this function creates a
* Configures @config from @text. Basically this function creates a
* properly configured #GScanner for you and calls the deserialize
* function of the @object's #GimpConfigInterface.
* function of the @config's #GimpConfigInterface.
*
* Returns: %TRUE if deserialization succeeded, %FALSE otherwise.
**/
gboolean
gimp_config_deserialize_string (GObject *object,
gimp_config_deserialize_string (GimpConfig *config,
const gchar *text,
gint text_len,
gpointer data,
GError **error)
{
GimpConfigInterface *gimp_config_iface;
GScanner *scanner;
gboolean success;
GScanner *scanner;
gboolean success;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
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);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
scanner = gimp_scanner_new_string (text, text_len, error);
success = gimp_config_iface->deserialize (object, scanner, 0, data);
success = GIMP_CONFIG_GET_INTERFACE (config)->deserialize (config,
scanner, 0, data);
gimp_scanner_destroy (scanner);
@ -438,7 +420,7 @@ gimp_config_deserialize_return (GScanner *scanner,
/**
* gimp_config_duplicate:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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
@ -447,18 +429,12 @@ gimp_config_deserialize_return (GScanner *scanner,
*
* Return value: the duplicated #GObject.
**/
GObject *
gimp_config_duplicate (GObject *object)
GimpConfig *
gimp_config_duplicate (GimpConfig *config)
{
GimpConfigInterface *gimp_config_iface;
g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
return gimp_config_iface->duplicate (object);
return GIMP_CONFIG_GET_INTERFACE (config)->duplicate (config);
}
/**
@ -474,43 +450,31 @@ gimp_config_duplicate (GObject *object)
* Return value: %TRUE if the two objects are equal.
**/
gboolean
gimp_config_is_equal_to (GObject *a,
GObject *b)
gimp_config_is_equal_to (GimpConfig *a,
GimpConfig *b)
{
GimpConfigInterface *gimp_config_iface;
g_return_val_if_fail (G_IS_OBJECT (a), FALSE);
g_return_val_if_fail (G_IS_OBJECT (b), FALSE);
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);
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (a);
g_return_val_if_fail (gimp_config_iface != NULL, FALSE);
return gimp_config_iface->equal (a, b);
return GIMP_CONFIG_GET_INTERFACE (a)->equal (a, b);
}
/**
* gimp_config_reset:
* @object: a #GObject that implements the #GimpConfigInterface.
* @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.
**/
void
gimp_config_reset (GObject *object)
gimp_config_reset (GimpConfig *config)
{
GimpConfigInterface *gimp_config_iface;
g_return_if_fail (GIMP_IS_CONFIG (config));
g_return_if_fail (G_IS_OBJECT (object));
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (object);
g_return_if_fail (gimp_config_iface != NULL);
gimp_config_iface->reset (object);
GIMP_CONFIG_GET_INTERFACE (config)->reset (config);
}
@ -531,7 +495,7 @@ static void gimp_config_destroy_unknown_tokens (GSList *unknown_tokens);
/**
* gimp_config_add_unknown_token:
* @object: a #GObject.
* @config: a #GObject.
* @key: a nul-terminated string to identify the value.
* @value: a nul-terminated string representing the value.
*
@ -546,7 +510,7 @@ static void gimp_config_destroy_unknown_tokens (GSList *unknown_tokens);
* function with a %NULL @value.
**/
void
gimp_config_add_unknown_token (GObject *object,
gimp_config_add_unknown_token (GimpConfig *config,
const gchar *key,
const gchar *value)
{
@ -555,10 +519,10 @@ gimp_config_add_unknown_token (GObject *object,
GSList *last;
GSList *list;
g_return_if_fail (G_IS_OBJECT (object));
g_return_if_fail (GIMP_IS_CONFIG (config));
g_return_if_fail (key != NULL);
unknown_tokens = (GSList *) g_object_get_data (object,
unknown_tokens = (GSList *) g_object_get_data (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS);
for (last = NULL, list = unknown_tokens;
@ -580,7 +544,8 @@ gimp_config_add_unknown_token (GObject *object,
g_free (token->key);
unknown_tokens = g_slist_remove (unknown_tokens, token);
g_object_set_data_full (object, GIMP_CONFIG_UNKNOWN_TOKENS,
g_object_set_data_full (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS,
unknown_tokens,
(GDestroyNotify) gimp_config_destroy_unknown_tokens);
}
@ -604,7 +569,8 @@ gimp_config_add_unknown_token (GObject *object,
{
unknown_tokens = g_slist_append (NULL, token);
g_object_set_data_full (object, GIMP_CONFIG_UNKNOWN_TOKENS,
g_object_set_data_full (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS,
unknown_tokens,
(GDestroyNotify) gimp_config_destroy_unknown_tokens);
}
@ -612,7 +578,7 @@ gimp_config_add_unknown_token (GObject *object,
/**
* gimp_config_lookup_unknown_token:
* @object: a #GObject.
* @config: a #GObject.
* @key: a nul-terminated string to identify the value.
*
* This function retrieves data that was previously attached using
@ -622,17 +588,17 @@ gimp_config_add_unknown_token (GObject *object,
* Returns: a pointer to a constant string.
**/
const gchar *
gimp_config_lookup_unknown_token (GObject *object,
gimp_config_lookup_unknown_token (GimpConfig *config,
const gchar *key)
{
GimpConfigToken *token;
GSList *unknown_tokens;
GSList *list;
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
g_return_val_if_fail (key != NULL, NULL);
unknown_tokens = (GSList *) g_object_get_data (object,
unknown_tokens = (GSList *) g_object_get_data (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS);
for (list = unknown_tokens; list; list = g_slist_next (list))
@ -648,15 +614,15 @@ gimp_config_lookup_unknown_token (GObject *object,
/**
* gimp_config_foreach_unknown_token:
* @object: a #GObject.
* @config: a #GObject.
* @func: a function to call for each key/value pair.
* @user_data: data to pass to @func.
*
* Calls @func for each key/value stored with the @object using
* Calls @func for each key/value stored with the @config using
* gimp_config_add_unknown_token().
**/
void
gimp_config_foreach_unknown_token (GObject *object,
gimp_config_foreach_unknown_token (GimpConfig *config,
GimpConfigForeachFunc func,
gpointer user_data)
{
@ -664,10 +630,10 @@ gimp_config_foreach_unknown_token (GObject *object,
GSList *unknown_tokens;
GSList *list;
g_return_if_fail (G_IS_OBJECT (object));
g_return_if_fail (GIMP_IS_CONFIG (config));
g_return_if_fail (func != NULL);
unknown_tokens = (GSList *) g_object_get_data (object,
unknown_tokens = (GSList *) g_object_get_data (G_OBJECT (config),
GIMP_CONFIG_UNKNOWN_TOKENS);
for (list = unknown_tokens; list; list = g_slist_next (list))

75
libgimpconfig/gimpconfig-iface.h
View File

@ -23,37 +23,38 @@
#define __GIMP_CONFIG_H__
#define GIMP_TYPE_CONFIG_INTERFACE (gimp_config_interface_get_type ())
#define GIMP_GET_CONFIG_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GIMP_TYPE_CONFIG_INTERFACE, GimpConfigInterface))
#define GIMP_TYPE_CONFIG (gimp_config_interface_get_type ())
#define GIMP_IS_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_CONFIG))
#define GIMP_CONFIG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_CONFIG, GimpConfig))
#define GIMP_CONFIG_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GIMP_TYPE_CONFIG, GimpConfigInterface))
typedef struct _GimpConfigInterface GimpConfigInterface;
struct _GimpConfigInterface
{
GTypeInterface base_iface;
gboolean (* serialize) (GObject *object,
GimpConfigWriter *writer,
gpointer data);
gboolean (* deserialize) (GObject *object,
GScanner *scanner,
gint nest_level,
gpointer data);
gboolean (* serialize_property) (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec,
GimpConfigWriter *writer);
gboolean (* deserialize_property) (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec,
GScanner *scanner,
GTokenType *expected);
GObject * (* duplicate) (GObject *object);
gboolean (* equal) (GObject *a,
GObject *b);
void (* reset) (GObject *object);
gboolean (* serialize) (GimpConfig *config,
GimpConfigWriter *writer,
gpointer data);
gboolean (* deserialize) (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data);
gboolean (* serialize_property) (GimpConfig *config,
guint property_id,
const GValue *value,
GParamSpec *pspec,
GimpConfigWriter *writer);
gboolean (* deserialize_property) (GimpConfig *config,
guint property_id,
GValue *value,
GParamSpec *pspec,
GScanner *scanner,
GTokenType *expected);
GimpConfig * (* duplicate) (GimpConfig *config);
gboolean (* equal) (GimpConfig *a,
GimpConfig *b);
void (* reset) (GimpConfig *config);
};
typedef void (* GimpConfigForeachFunc) (const gchar *key,
@ -63,22 +64,22 @@ typedef void (* GimpConfigForeachFunc) (const gchar *key,
GType gimp_config_interface_get_type (void) G_GNUC_CONST;
gboolean gimp_config_serialize_to_file (GObject *object,
gboolean gimp_config_serialize_to_file (GimpConfig *config,
const gchar *filename,
const gchar *header,
const gchar *footer,
gpointer data,
GError **error);
gboolean gimp_config_serialize_to_fd (GObject *object,
gboolean gimp_config_serialize_to_fd (GimpConfig *config,
gint fd,
gpointer data);
gchar * gimp_config_serialize_to_string (GObject *object,
gchar * gimp_config_serialize_to_string (GimpConfig *config,
gpointer data);
gboolean gimp_config_deserialize_file (GObject *object,
gboolean gimp_config_deserialize_file (GimpConfig *config,
const gchar *filename,
gpointer data,
GError **error);
gboolean gimp_config_deserialize_string (GObject *object,
gboolean gimp_config_deserialize_string (GimpConfig *config,
const gchar *text,
gint text_len,
gpointer data,
@ -87,17 +88,17 @@ gboolean gimp_config_deserialize_return (GScanner *scanner,
GTokenType expected_token,
gint nest_level);
GObject * gimp_config_duplicate (GObject *object);
gboolean gimp_config_is_equal_to (GObject *a,
GObject *b);
void gimp_config_reset (GObject *object);
GimpConfig * gimp_config_duplicate (GimpConfig *config);
gboolean gimp_config_is_equal_to (GimpConfig *a,
GimpConfig *b);
void gimp_config_reset (GimpConfig *config);
void gimp_config_add_unknown_token (GObject *object,
void gimp_config_add_unknown_token (GimpConfig *config,
const gchar *key,
const gchar *value);
const gchar * gimp_config_lookup_unknown_token (GObject *object,
const gchar * gimp_config_lookup_unknown_token (GimpConfig *config,
const gchar *key);
void gimp_config_foreach_unknown_token (GObject *object,
void gimp_config_foreach_unknown_token (GimpConfig *config,
GimpConfigForeachFunc func,
gpointer user_data);

78
libgimpconfig/gimpconfig-serialize.c
View File

@ -54,7 +54,7 @@ static void serialize_unknown_token (const gchar *key,
/**
* gimp_config_serialize_properties:
* @object: a #GObject.
* @config: a #GimpConfig.
* @writer: a #GimpConfigWriter.
*
* This function writes all object properties to the @writer.
@ -62,7 +62,7 @@ static void serialize_unknown_token (const gchar *key,
* Returns: %TRUE if serialization succeeded, %FALSE otherwise
**/
gboolean
gimp_config_serialize_properties (GObject *object,
gimp_config_serialize_properties (GimpConfig *config,
GimpConfigWriter *writer)
{
GObjectClass *klass;
@ -70,9 +70,9 @@ gimp_config_serialize_properties (GObject *object,
guint n_property_specs;
guint i;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (G_IS_OBJECT (config), FALSE);
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
@ -86,7 +86,7 @@ gimp_config_serialize_properties (GObject *object,
if (! (prop_spec->flags & GIMP_PARAM_SERIALIZE))
continue;
if (! gimp_config_serialize_property (object, prop_spec, writer))
if (! gimp_config_serialize_property (config, prop_spec, writer))
return FALSE;
}
@ -97,7 +97,7 @@ gimp_config_serialize_properties (GObject *object,
/**
* gimp_config_serialize_changed_properties:
* @object: a #GObject.
* @config: a #GimpConfig.
* @writer: a #GimpConfigWriter.
*
* This function writes all object properties that have been changed from
@ -106,7 +106,7 @@ gimp_config_serialize_properties (GObject *object,
* Returns: %TRUE if serialization succeeded, %FALSE otherwise
**/
gboolean
gimp_config_serialize_changed_properties (GObject *object,
gimp_config_serialize_changed_properties (GimpConfig *config,
GimpConfigWriter *writer)
{
GObjectClass *klass;
@ -115,9 +115,9 @@ gimp_config_serialize_changed_properties (GObject *object,
guint i;
GValue value = { 0, };
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (G_IS_OBJECT (config), FALSE);
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
@ -132,11 +132,11 @@ gimp_config_serialize_changed_properties (GObject *object,
continue;
g_value_init (&value, prop_spec->value_type);
g_object_get_property (object, prop_spec->name, &value);
g_object_get_property (G_OBJECT (config), prop_spec->name, &value);
if (! g_param_value_defaults (prop_spec, &value))
{
if (! gimp_config_serialize_property (object, prop_spec, writer))
if (! gimp_config_serialize_property (config, prop_spec, writer))
return FALSE;
}
@ -150,33 +150,33 @@ gimp_config_serialize_changed_properties (GObject *object,
/**
* gimp_config_serialize_properties_diff:
* @object: a #GObject.
* @compare: a #GObject of the same type as @object.
* @config: a #GimpConfig.
* @compare: a #GimpConfig of the same type as @config.
* @writer: a #GimpConfigWriter.
*
* This function compares @object and @compare and writes all
* properties of @object that have different values than @compare to
* This function compares @config and @compare and writes all
* properties of @config that have different values than @compare to
* the @writer.
*
* Returns: %TRUE if serialization succeeded, %FALSE otherwise
**/
gboolean
gimp_config_serialize_properties_diff (GObject *object,
GObject *compare,
gimp_config_serialize_properties_diff (GimpConfig *config,
GimpConfig *compare,
GimpConfigWriter *writer)
{
GObjectClass *klass;
GList *diff;
GList *list;
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (G_IS_OBJECT (config), FALSE);
g_return_val_if_fail (G_IS_OBJECT (compare), FALSE);
g_return_val_if_fail (G_TYPE_FROM_INSTANCE (object) ==
g_return_val_if_fail (G_TYPE_FROM_INSTANCE (config) ==
G_TYPE_FROM_INSTANCE (compare), FALSE);
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
diff = gimp_config_diff (object, compare, GIMP_PARAM_SERIALIZE);
diff = gimp_config_diff (config, compare, GIMP_PARAM_SERIALIZE);
if (! diff)
return TRUE;
@ -188,7 +188,7 @@ gimp_config_serialize_properties_diff (GObject *object,
if (! (prop_spec->flags & GIMP_PARAM_SERIALIZE))
continue;
if (! gimp_config_serialize_property (object, prop_spec, writer))
if (! gimp_config_serialize_property (config, prop_spec, writer))
return FALSE;
}
@ -199,7 +199,7 @@ gimp_config_serialize_properties_diff (GObject *object,
gboolean
gimp_config_serialize_property (GObject *object,
gimp_config_serialize_property (GimpConfig *config,
GParamSpec *param_spec,
GimpConfigWriter *writer)
{
@ -213,12 +213,11 @@ gimp_config_serialize_property (GObject *object,
return FALSE;
g_value_init (&value, param_spec->value_type);
g_object_get_property (object, param_spec->name, &value);
g_object_get_property (G_OBJECT (config), param_spec->name, &value);
owner_class = g_type_class_peek (param_spec->owner_type);
config_iface = g_type_interface_peek (owner_class,
GIMP_TYPE_CONFIG_INTERFACE);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
@ -237,13 +236,13 @@ gimp_config_serialize_property (GObject *object,
owner_parent_class = g_type_class_peek_parent (owner_class),
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG_INTERFACE);
GIMP_TYPE_CONFIG);
}
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->serialize_property &&
config_iface->serialize_property (object,
config_iface->serialize_property (config,
param_spec->param_id,
(const GValue *) &value,
param_spec,
@ -261,22 +260,21 @@ gimp_config_serialize_property (GObject *object,
if (G_VALUE_HOLDS_OBJECT (&value) &&
(param_spec->flags & GIMP_PARAM_AGGREGATE))
{
GimpConfigInterface *gimp_config_iface = NULL;
GObject *prop_object;
GimpConfigInterface *config_iface = NULL;
GimpConfig *prop_object;
prop_object = g_value_get_object (&value);
if (prop_object)
gimp_config_iface = GIMP_GET_CONFIG_INTERFACE (prop_object);
config_iface = GIMP_CONFIG_GET_INTERFACE (prop_object);
else
success = TRUE;
if (gimp_config_iface)
if (config_iface)
{
gimp_config_writer_open (writer, param_spec->name);
success = gimp_config_iface->serialize (prop_object, writer,
NULL);
success = config_iface->serialize (prop_object, writer, NULL);
if (success)
gimp_config_writer_close (writer);
@ -310,7 +308,7 @@ gimp_config_serialize_property (GObject *object,
else
{
g_warning ("couldn't serialize property %s::%s of type %s",
g_type_name (G_TYPE_FROM_INSTANCE (object)),
g_type_name (G_TYPE_FROM_INSTANCE (config)),
param_spec->name,
g_type_name (param_spec->value_type));
}
@ -482,22 +480,22 @@ gimp_config_serialize_value (const GValue *value,
/**
* gimp_config_serialize_unknown_tokens:
* @object: a #GObject.
* @config: a #GimpConfig.
* @writer: a #GimpConfigWriter.
*
* Writes all unknown tokens attached to #object to the @writer. See
* Writes all unknown tokens attached to @config to the @writer. See
* gimp_config_add_unknown_token().
*
* Returns: %TRUE if serialization succeeded, %FALSE otherwise
**/
gboolean
gimp_config_serialize_unknown_tokens (GObject *object,
gimp_config_serialize_unknown_tokens (GimpConfig *config,
GimpConfigWriter *writer)
{
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
g_return_val_if_fail (G_IS_OBJECT (config), FALSE);
gimp_config_writer_linefeed (writer);
gimp_config_foreach_unknown_token (object, serialize_unknown_token, writer);
gimp_config_foreach_unknown_token (config, serialize_unknown_token, writer);
return TRUE;
}

12
libgimpconfig/gimpconfig-serialize.h
View File

@ -23,17 +23,17 @@
#define __GIMP_CONFIG_SERIALIZE_H__
gboolean gimp_config_serialize_properties (GObject *object,
gboolean gimp_config_serialize_properties (GimpConfig *config,
GimpConfigWriter *writer);
gboolean gimp_config_serialize_changed_properties (GObject *object,
gboolean gimp_config_serialize_changed_properties (GimpConfig *config,
GimpConfigWriter *writer);
gboolean gimp_config_serialize_properties_diff (GObject *object,
GObject *compare,
gboolean gimp_config_serialize_properties_diff (GimpConfig *config,
GimpConfig *compare,
GimpConfigWriter *writer);
gboolean gimp_config_serialize_unknown_tokens (GObject *object,
gboolean gimp_config_serialize_unknown_tokens (GimpConfig *config,
GimpConfigWriter *writer);
gboolean gimp_config_serialize_property (GObject *object,
gboolean gimp_config_serialize_property (GimpConfig *config,
GParamSpec *param_spec,
GimpConfigWriter *writer);

67
libgimpconfig/gimpconfig-utils.c
View File

@ -36,8 +36,8 @@
/**
* gimp_config_diff:
* @a: a #GObject
* @b: another #GObject of the same type as @a
* @a: a #GimpConfig
* @b: another #GimpConfig of the same type as @a
* @flags: a mask of GParamFlags
*
* Compares all properties of @a and @b that have all @flags set. If
@ -46,8 +46,8 @@
* Return value: a GList of differing GParamSpecs.
**/
GList *
gimp_config_diff (GObject *a,
GObject *b,
gimp_config_diff (GimpConfig *a,
GimpConfig *b,
GParamFlags flags)
{
GParamSpec **param_specs;
@ -73,14 +73,14 @@ gimp_config_diff (GObject *a,
g_value_init (&a_value, param_specs[i]->value_type);
g_value_init (&b_value, param_specs[i]->value_type);
g_object_get_property (a, param_specs[i]->name, &a_value);
g_object_get_property (b, param_specs[i]->name, &b_value);
g_object_get_property (G_OBJECT (a), param_specs[i]->name, &a_value);
g_object_get_property (G_OBJECT (b), param_specs[i]->name, &b_value);
if (G_IS_PARAM_SPEC_OBJECT (param_specs[i]) &&
(param_specs[i]->flags & GIMP_PARAM_AGGREGATE))
{
GObject *a_object = g_value_get_object (&a_value);
GObject *b_object = g_value_get_object (&b_value);
GimpConfig *a_object = g_value_get_object (&a_value);
GimpConfig *b_object = g_value_get_object (&b_value);
if (a_object && b_object &&
G_TYPE_FROM_INSTANCE (a_object) ==
@ -180,23 +180,23 @@ gimp_config_disconnect (GObject *src,
/**
* gimp_config_copy_properties:
* @src: a #GObject
* @dest: another #GObject of the same type as @src
* @src: a #GimpConfig
* @dest: another #GimpConfig of the same type as @src
*
* Retrieves all read and writeable property settings from @src and
* applies the values to @dest.
**/
void
gimp_config_copy_properties (GObject *src,
GObject *dest)
gimp_config_copy_properties (GimpConfig *src,
GimpConfig *dest)
{
GObjectClass *klass;
GParamSpec **property_specs;
guint n_property_specs;
guint i;
g_return_if_fail (G_IS_OBJECT (src));
g_return_if_fail (G_IS_OBJECT (dest));
g_return_if_fail (GIMP_IS_CONFIG (src));
g_return_if_fail (GIMP_IS_CONFIG (dest));
g_return_if_fail (G_TYPE_FROM_INSTANCE (src) == G_TYPE_FROM_INSTANCE (dest));
klass = G_OBJECT_GET_CLASS (src);
@ -206,7 +206,7 @@ gimp_config_copy_properties (GObject *src,
if (!property_specs)
return;
g_object_freeze_notify (dest);
g_object_freeze_notify (G_OBJECT (dest));
for (i = 0; i < n_property_specs; i++)
{
@ -221,16 +221,18 @@ gimp_config_copy_properties (GObject *src,
if (G_IS_PARAM_SPEC_OBJECT (prop_spec) &&
(prop_spec->flags & GIMP_PARAM_AGGREGATE))
{
GValue src_value = { 0, };
GValue dest_value = { 0, };
GObject *src_object;
GObject *dest_object;
GValue src_value = { 0, };
GValue dest_value = { 0, };
GimpConfig *src_object;
GimpConfig *dest_object;
g_value_init (&src_value, prop_spec->value_type);
g_value_init (&dest_value, prop_spec->value_type);
g_object_get_property (src, prop_spec->name, &src_value);
g_object_get_property (dest, prop_spec->name, &dest_value);
g_object_get_property (G_OBJECT (src),
prop_spec->name, &src_value);
g_object_get_property (G_OBJECT (dest),
prop_spec->name, &dest_value);
src_object = g_value_get_object (&src_value);
dest_object = g_value_get_object (&dest_value);
@ -251,8 +253,8 @@ gimp_config_copy_properties (GObject *src,
g_value_init (&value, prop_spec->value_type);
g_object_get_property (src, prop_spec->name, &value);
g_object_set_property (dest, prop_spec->name, &value);
g_object_get_property (G_OBJECT (src), prop_spec->name, &value);
g_object_set_property (G_OBJECT (dest), prop_spec->name, &value);
g_value_unset (&value);
}
@ -261,34 +263,37 @@ gimp_config_copy_properties (GObject *src,
g_free (property_specs);
g_object_thaw_notify (dest);
g_object_thaw_notify (G_OBJECT (dest));
}
/**
* gimp_config_reset_properties:
* @object: a #GObject
* @config: a #GimpConfig
*
* Resets all writable properties of @object to the default values as
* defined in their #GParamSpec.
**/
void
gimp_config_reset_properties (GObject *object)
gimp_config_reset_properties (GimpConfig *config)
{
GObject *object;
GObjectClass *klass;
GParamSpec **property_specs;
GValue value = { 0, };
guint n_property_specs;
guint i;
g_return_if_fail (G_IS_OBJECT (object));
g_return_if_fail (GIMP_IS_CONFIG (config));
klass = G_OBJECT_GET_CLASS (object);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
if (!property_specs)
return;
object = G_OBJECT (config);
g_object_freeze_notify (object);
for (i = 0; i < n_property_specs; i++)
@ -305,13 +310,13 @@ gimp_config_reset_properties (GObject *object)
if ((prop_spec->flags & GIMP_PARAM_SERIALIZE) &&
(prop_spec->flags & GIMP_PARAM_AGGREGATE) &&
g_type_interface_peek (g_type_class_peek (prop_spec->value_type),
GIMP_TYPE_CONFIG_INTERFACE))
GIMP_TYPE_CONFIG))
{
g_value_init (&value, prop_spec->value_type);
g_object_get_property (object, prop_spec->name, &value);
gimp_config_reset (g_value_get_object (&value));
gimp_config_reset (GIMP_CONFIG (g_value_get_object (&value)));
g_value_unset (&value);
}
@ -319,8 +324,8 @@ gimp_config_reset_properties (GObject *object)
else
{
g_value_init (&value, prop_spec->value_type);
g_param_value_set_default (prop_spec, &value);
g_object_set_property (object, prop_spec->name, &value);
g_value_unset (&value);

15
libgimpconfig/gimpconfig-utils.h
View File

@ -23,16 +23,19 @@
#define __GIMP_CONFIG_UTILS_H__
GList * gimp_config_diff (GObject *a,
GObject *b,
GParamFlags flags);
void gimp_config_connect (GObject *src,
GObject *dest);
void gimp_config_disconnect (GObject *src,
GObject *dest);
void gimp_config_copy_properties (GObject *src,
GObject *dest);
void gimp_config_reset_properties (GObject *object);
GList * gimp_config_diff (GimpConfig *a,
GimpConfig *b,
GParamFlags flags);
void gimp_config_copy_properties (GimpConfig *src,
GimpConfig *dest);
void gimp_config_reset_properties (GimpConfig *config);
void gimp_config_string_append_escaped (GString *string,
const gchar *val);

3
tools/pdbgen/pdb/gimprc.pdb
View File

@ -93,7 +93,8 @@ HELP
/* set the value in edit_config so we don't accidentially set
* GIMP_PARAM_RESTART values via the PDB
*/
gimp_config_add_unknown_token (G_OBJECT (gimp->edit_config), token, value);
gimp_config_add_unknown_token (GIMP_CONFIG (gimp->edit_config),
token, value);
success = TRUE;
}
CODE