static GValueArray * image_grid_set_background_color_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; GimpRGB bgcolor; image = gimp_value_get_image (&args->values[0], gimp); gimp_value_get_rgb (&args->values[1], &bgcolor); if (success) { GimpGrid *grid = gimp_image_get_grid (image); if (grid) g_object_set (grid, "bgcolor", &bgcolor, NULL); else success = FALSE; } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
static GValueArray * channel_set_color_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GimpChannel *channel; GimpRGB color; channel = gimp_value_get_channel (&args->values[0], gimp); gimp_value_get_rgb (&args->values[1], &color); if (success) { GimpRGB rgb_color = color; rgb_color.a = channel->color.a; gimp_channel_set_color (channel, &rgb_color, TRUE); } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
static GimpValueArray * image_grid_set_foreground_color_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; GimpRGB fgcolor; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); gimp_value_get_rgb (gimp_value_array_index (args, 1), &fgcolor); if (success) { GimpGrid *grid = gimp_image_get_grid (image); if (grid) g_object_set (grid, "fgcolor", &fgcolor, NULL); else success = FALSE; } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
static GimpValueArray * palette_entry_set_color_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; const gchar *name; gint32 entry_num; GimpRGB color; name = g_value_get_string (gimp_value_array_index (args, 0)); entry_num = g_value_get_int (gimp_value_array_index (args, 1)); gimp_value_get_rgb (gimp_value_array_index (args, 2), &color); if (success) { GimpPalette *palette = gimp_pdb_get_palette (gimp, name, TRUE, error); if (palette) success = gimp_palette_set_entry_color (palette, entry_num, &color); else success = FALSE; } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
void gimp_gegl_config_proxy_sync (GimpObject *proxy, GeglNode *node) { GParamSpec **pspecs; gchar *operation; guint n_pspecs; gint i; g_return_if_fail (GIMP_IS_OBJECT (proxy)); g_return_if_fail (GEGL_IS_NODE (node)); gegl_node_get (node, "operation", &operation, NULL); g_return_if_fail (operation != NULL); pspecs = gegl_operation_list_properties (operation, &n_pspecs); g_free (operation); for (i = 0; i < n_pspecs; i++) { GParamSpec *gegl_pspec = pspecs[i]; GParamSpec *gimp_pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (proxy), gegl_pspec->name); if (gimp_pspec) { GValue value = { 0, }; g_value_init (&value, gimp_pspec->value_type); g_object_get_property (G_OBJECT (proxy), gimp_pspec->name, &value); if (GEGL_IS_PARAM_SPEC_COLOR (gegl_pspec)) { GimpRGB gimp_color; GeglColor *gegl_color; gimp_value_get_rgb (&value, &gimp_color); g_value_unset (&value); gegl_color = gimp_gegl_color_new (&gimp_color); g_value_init (&value, gegl_pspec->value_type); g_value_take_object (&value, gegl_color); } gegl_node_set_property (node, gegl_pspec->name, &value); g_value_unset (&value); } } g_free (pspecs); }
static void gimp_gegl_tool_map (GimpImageMapTool *image_map_tool) { GimpGeglTool *tool = GIMP_GEGL_TOOL (image_map_tool); GParamSpec **pspecs; guint n_pspecs; gint i; if (! tool->config) return; pspecs = gegl_list_properties (tool->operation, &n_pspecs); for (i = 0; i < n_pspecs; i++) { GParamSpec *gegl_pspec = pspecs[i]; GParamSpec *gimp_pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (tool->config), gegl_pspec->name); if (gimp_pspec) { GValue value = { 0, }; g_value_init (&value, gimp_pspec->value_type); g_object_get_property (G_OBJECT (tool->config), gimp_pspec->name, &value); if (GIMP_IS_PARAM_SPEC_RGB (gimp_pspec)) { GeglColor *gegl_color = gegl_color_new (NULL); GimpRGB gimp_color; gimp_value_get_rgb (&value, &gimp_color); g_value_unset (&value); gegl_color_set_rgba (gegl_color, gimp_color.r, gimp_color.g, gimp_color.b, gimp_color.a); g_value_init (&value, gegl_pspec->value_type); g_value_take_object (&value, gegl_color); } gegl_node_set_property (image_map_tool->operation, gegl_pspec->name, &value); g_value_unset (&value); } } g_free (pspecs); }
static void gimp_colorize_config_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpColorizeConfig *self = GIMP_COLORIZE_CONFIG (object); switch (property_id) { case PROP_HUE: self->hue = g_value_get_double (value); g_object_notify (object, "color"); break; case PROP_SATURATION: self->saturation = g_value_get_double (value); g_object_notify (object, "color"); break; case PROP_LIGHTNESS: self->lightness = g_value_get_double (value); g_object_notify (object, "color"); break; case PROP_COLOR: { GimpRGB rgb; GimpHSL hsl; gimp_value_get_rgb (value, &rgb); gimp_rgb_to_hsl (&rgb, &hsl); if (hsl.h == -1) hsl.h = self->hue; if (hsl.l == 0.0 || hsl.l == 1.0) hsl.s = self->saturation; g_object_set (self, "hue", hsl.h, "saturation", hsl.s, "lightness", hsl.l * 2.0 - 1.0, NULL); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static GimpValueArray * image_select_color_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; gint32 operation; GimpDrawable *drawable; GimpRGB color; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); operation = g_value_get_enum (gimp_value_array_index (args, 1)); drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); gimp_value_get_rgb (gimp_value_array_index (args, 3), &color); if (success) { GimpPDBContext *pdb_context = GIMP_PDB_CONTEXT (context); if (pdb_context->sample_merged || gimp_pdb_item_is_attached (GIMP_ITEM (drawable), image, 0, error)) { gimp_channel_select_by_color (gimp_image_get_mask (image), drawable, pdb_context->sample_merged, &color, pdb_context->sample_threshold, pdb_context->sample_transparent, pdb_context->sample_criterion, operation, pdb_context->antialias, pdb_context->feather, pdb_context->feather_radius_x, pdb_context->feather_radius_y); } else success = FALSE; } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
static GValueArray * channel_new_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GValueArray *return_vals; GimpImage *image; gint32 width; gint32 height; const gchar *name; gdouble opacity; GimpRGB color; GimpChannel *channel = NULL; image = gimp_value_get_image (&args->values[0], gimp); width = g_value_get_int (&args->values[1]); height = g_value_get_int (&args->values[2]); name = g_value_get_string (&args->values[3]); opacity = g_value_get_double (&args->values[4]); gimp_value_get_rgb (&args->values[5], &color); if (success) { GimpRGB rgb_color = color; rgb_color.a = opacity / 100.0; channel = gimp_channel_new (image, width, height, name, &rgb_color); if (! channel) success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) gimp_value_set_channel (&return_vals->values[1], channel); return return_vals; }
static GimpValueArray * palette_add_entry_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; const gchar *name; const gchar *entry_name; GimpRGB color; gint32 entry_num = 0; name = g_value_get_string (gimp_value_array_index (args, 0)); entry_name = g_value_get_string (gimp_value_array_index (args, 1)); gimp_value_get_rgb (gimp_value_array_index (args, 2), &color); if (success) { GimpPalette *palette = gimp_pdb_get_palette (gimp, name, TRUE, error); if (palette) { GimpPaletteEntry *entry = gimp_palette_add_entry (palette, -1, entry_name, &color); entry_num = entry->position; } else success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) g_value_set_int (gimp_value_array_index (return_vals, 1), entry_num); return return_vals; }
static GValueArray * palette_add_entry_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args) { gboolean success = TRUE; GValueArray *return_vals; const gchar *name; const gchar *entry_name; GimpRGB color; gint32 entry_num = 0; name = g_value_get_string (&args->values[0]); entry_name = g_value_get_string (&args->values[1]); gimp_value_get_rgb (&args->values[2], &color); if (success) { GimpPalette *palette = (GimpPalette *) gimp_container_get_child_by_name (gimp->palette_factory->container, name); if (palette && GIMP_DATA (palette)->writable) { GimpPaletteEntry *entry = gimp_palette_add_entry (palette, -1, entry_name, &color); entry_num = entry->position; } else success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success); if (success) g_value_set_int (&return_vals->values[1], entry_num); return return_vals; }
static GValueArray * palette_entry_set_color_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args) { gboolean success = TRUE; const gchar *name; gint32 entry_num; GimpRGB color; name = g_value_get_string (&args->values[0]); entry_num = g_value_get_int (&args->values[1]); gimp_value_get_rgb (&args->values[2], &color); if (success) { GimpPalette *palette = (GimpPalette *) gimp_container_get_child_by_name (gimp->palette_factory->container, name); if (palette && GIMP_DATA (palette)->writable) { if (entry_num >= 0 && entry_num < palette->n_colors) { GimpPaletteEntry *entry = g_list_nth_data (palette->colors, entry_num); entry->color = color; gimp_data_dirty (GIMP_DATA (palette)); } else success = FALSE; } else success = FALSE; } return gimp_procedure_get_return_values (procedure, success); }
GPParam * plug_in_args_to_params (GimpValueArray *args, gboolean full_copy) { GPParam *params; gint length; gint i; g_return_val_if_fail (args != NULL, NULL); params = g_new0 (GPParam, gimp_value_array_length (args)); length = gimp_value_array_length (args); for (i = 0; i < length; i++) { GValue *value = gimp_value_array_index (args, i); params[i].type = gimp_pdb_compat_arg_type_from_gtype (G_VALUE_TYPE (value)); switch (params[i].type) { case GIMP_PDB_INT32: if (G_VALUE_HOLDS_INT (value)) params[i].data.d_int32 = g_value_get_int (value); else if (G_VALUE_HOLDS_UINT (value)) params[i].data.d_int32 = g_value_get_uint (value); else if (G_VALUE_HOLDS_ENUM (value)) params[i].data.d_int32 = g_value_get_enum (value); else if (G_VALUE_HOLDS_BOOLEAN (value)) params[i].data.d_int32 = g_value_get_boolean (value); else { g_printerr ("%s: unhandled GIMP_PDB_INT32 type: %s\n", G_STRFUNC, g_type_name (G_VALUE_TYPE (value))); g_return_val_if_reached (params); } break; case GIMP_PDB_INT16: params[i].data.d_int16 = g_value_get_int (value); break; case GIMP_PDB_INT8: params[i].data.d_int8 = g_value_get_uint (value); break; case GIMP_PDB_FLOAT: params[i].data.d_float = g_value_get_double (value); break; case GIMP_PDB_STRING: if (full_copy) params[i].data.d_string = g_value_dup_string (value); else params[i].data.d_string = (gchar *) g_value_get_string (value); break; case GIMP_PDB_INT32ARRAY: if (full_copy) params[i].data.d_int32array = gimp_value_dup_int32array (value); else params[i].data.d_int32array = (gint32 *) gimp_value_get_int32array (value); break; case GIMP_PDB_INT16ARRAY: if (full_copy) params[i].data.d_int16array = gimp_value_dup_int16array (value); else params[i].data.d_int16array = (gint16 *) gimp_value_get_int16array (value); break; case GIMP_PDB_INT8ARRAY: if (full_copy) params[i].data.d_int8array = gimp_value_dup_int8array (value); else params[i].data.d_int8array = (guint8 *) gimp_value_get_int8array (value); break; case GIMP_PDB_FLOATARRAY: if (full_copy) params[i].data.d_floatarray = gimp_value_dup_floatarray (value); else params[i].data.d_floatarray = (gdouble *) gimp_value_get_floatarray (value); break; case GIMP_PDB_STRINGARRAY: if (full_copy) params[i].data.d_stringarray = gimp_value_dup_stringarray (value); else params[i].data.d_stringarray = (gchar **) gimp_value_get_stringarray (value); break; case GIMP_PDB_COLOR: gimp_value_get_rgb (value, ¶ms[i].data.d_color); break; case GIMP_PDB_ITEM: params[i].data.d_item = g_value_get_int (value); break; case GIMP_PDB_DISPLAY: params[i].data.d_display = g_value_get_int (value); break; case GIMP_PDB_IMAGE: params[i].data.d_image = g_value_get_int (value); break; case GIMP_PDB_LAYER: params[i].data.d_layer = g_value_get_int (value); break; case GIMP_PDB_CHANNEL: params[i].data.d_channel = g_value_get_int (value); break; case GIMP_PDB_DRAWABLE: params[i].data.d_drawable = g_value_get_int (value); break; case GIMP_PDB_SELECTION: params[i].data.d_selection = g_value_get_int (value); break; case GIMP_PDB_COLORARRAY: if (full_copy) params[i].data.d_colorarray = gimp_value_dup_colorarray (value); else params[i].data.d_colorarray = (GimpRGB *) gimp_value_get_colorarray (value); break; case GIMP_PDB_VECTORS: params[i].data.d_vectors = g_value_get_int (value); break; case GIMP_PDB_PARASITE: { GimpParasite *parasite = (full_copy ? g_value_dup_boxed (value) : g_value_get_boxed (value)); if (parasite) { params[i].data.d_parasite.name = parasite->name; params[i].data.d_parasite.flags = parasite->flags; params[i].data.d_parasite.size = parasite->size; params[i].data.d_parasite.data = parasite->data; if (full_copy) { parasite->name = NULL; parasite->flags = 0; parasite->size = 0; parasite->data = NULL; gimp_parasite_free (parasite); } } else { params[i].data.d_parasite.name = NULL; params[i].data.d_parasite.flags = 0; params[i].data.d_parasite.size = 0; params[i].data.d_parasite.data = NULL; } } break; case GIMP_PDB_STATUS: params[i].data.d_status = g_value_get_enum (value); break; case GIMP_PDB_END: break; } } return params; }
GParamSpec * gimp_param_spec_duplicate (GParamSpec *pspec) { GParamSpec *copy = NULL; GParamFlags flags; g_return_val_if_fail (pspec != NULL, NULL); flags = pspec->flags | GIMP_CONFIG_PARAM_SERIALIZE; if (G_IS_PARAM_SPEC_STRING (pspec)) { GParamSpecString *spec = G_PARAM_SPEC_STRING (pspec); if (GEGL_IS_PARAM_SPEC_FILE_PATH (pspec)) { copy = gimp_param_spec_config_path (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), GIMP_CONFIG_PATH_FILE, spec->default_value, flags); } else { static GQuark multiline_quark = 0; if (! multiline_quark) multiline_quark = g_quark_from_static_string ("multiline"); copy = g_param_spec_string (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), spec->default_value, flags); if (GEGL_IS_PARAM_SPEC_MULTILINE (pspec)) { g_param_spec_set_qdata (copy, multiline_quark, GINT_TO_POINTER (TRUE)); } } } else if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) { GParamSpecBoolean *spec = G_PARAM_SPEC_BOOLEAN (pspec); copy = g_param_spec_boolean (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), spec->default_value, flags); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { GParamSpecEnum *spec = G_PARAM_SPEC_ENUM (pspec); copy = g_param_spec_enum (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), G_TYPE_FROM_CLASS (spec->enum_class), spec->default_value, flags); } else if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec)) { GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec); GParamSpecDouble *spec = G_PARAM_SPEC_DOUBLE (pspec); copy = gegl_param_spec_double (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), spec->minimum, spec->maximum, spec->default_value, gspec->ui_minimum, gspec->ui_maximum, gspec->ui_gamma, flags); } else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) { GParamSpecDouble *spec = G_PARAM_SPEC_DOUBLE (pspec); copy = g_param_spec_double (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), spec->minimum, spec->maximum, spec->default_value, flags); } else if (G_IS_PARAM_SPEC_FLOAT (pspec)) { GParamSpecFloat *spec = G_PARAM_SPEC_FLOAT (pspec); copy = g_param_spec_float (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), spec->minimum, spec->maximum, spec->default_value, flags); } else if (GEGL_IS_PARAM_SPEC_INT (pspec)) { GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec); GParamSpecInt *spec = G_PARAM_SPEC_INT (pspec); copy = gegl_param_spec_int (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), spec->minimum, spec->maximum, spec->default_value, gspec->ui_minimum, gspec->ui_maximum, gspec->ui_gamma, flags); } else if (GEGL_IS_PARAM_SPEC_SEED (pspec)) { copy = gegl_param_spec_seed (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), pspec->flags | GIMP_CONFIG_PARAM_SERIALIZE); } else if (G_IS_PARAM_SPEC_INT (pspec)) { GParamSpecInt *spec = G_PARAM_SPEC_INT (pspec); copy = g_param_spec_int (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), spec->minimum, spec->maximum, spec->default_value, flags); } else if (G_IS_PARAM_SPEC_UINT (pspec)) { GParamSpecUInt *spec = G_PARAM_SPEC_UINT (pspec); copy = g_param_spec_uint (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), spec->minimum, spec->maximum, spec->default_value, flags); } else if (GIMP_IS_PARAM_SPEC_RGB (pspec)) { GValue value = G_VALUE_INIT; GimpRGB color; g_value_init (&value, GIMP_TYPE_RGB); g_param_value_set_default (pspec, &value); gimp_value_get_rgb (&value, &color); g_value_unset (&value); copy = gimp_param_spec_rgb (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), gimp_param_spec_rgb_has_alpha (pspec), &color, flags); } else if (GEGL_IS_PARAM_SPEC_COLOR (pspec)) { GeglColor *gegl_color; GimpRGB gimp_color; gdouble r = 0.0; gdouble g = 0.0; gdouble b = 0.0; gdouble a = 1.0; GValue value = { 0, }; g_value_init (&value, GEGL_TYPE_COLOR); g_param_value_set_default (pspec, &value); gegl_color = g_value_get_object (&value); if (gegl_color) gegl_color_get_rgba (gegl_color, &r, &g, &b, &a); gimp_rgba_set (&gimp_color, r, g, b, a); g_value_unset (&value); copy = gimp_param_spec_rgb (pspec->name, g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), TRUE, &gimp_color, flags); } else if (G_IS_PARAM_SPEC_OBJECT (pspec) || G_IS_PARAM_SPEC_POINTER (pspec)) { /* silently ignore object properties */ } else { g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC, g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name); } if (copy) { GQuark quark = g_quark_from_static_string ("gegl-property-keys"); GHashTable *keys = g_param_spec_get_qdata (pspec, quark); if (keys) g_param_spec_set_qdata (copy, quark, g_hash_table_ref (keys)); } return copy; }
static void gimp_core_config_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpCoreConfig *core_config = GIMP_CORE_CONFIG (object); switch (property_id) { case PROP_LANGUAGE: g_free (core_config->language); core_config->language = g_value_dup_string (value); break; case PROP_INTERPOLATION_TYPE: core_config->interpolation_type = g_value_get_enum (value); break; case PROP_DEFAULT_THRESHOLD: core_config->default_threshold = g_value_get_int (value); break; case PROP_PLUG_IN_PATH: g_free (core_config->plug_in_path); core_config->plug_in_path = g_value_dup_string (value); break; case PROP_MODULE_PATH: g_free (core_config->module_path); core_config->module_path = g_value_dup_string (value); break; case PROP_INTERPRETER_PATH: g_free (core_config->interpreter_path); core_config->interpreter_path = g_value_dup_string (value); break; case PROP_ENVIRON_PATH: g_free (core_config->environ_path); core_config->environ_path = g_value_dup_string (value); break; case PROP_BRUSH_PATH: g_free (core_config->brush_path); core_config->brush_path = g_value_dup_string (value); break; case PROP_BRUSH_PATH_WRITABLE: g_free (core_config->brush_path_writable); core_config->brush_path_writable = g_value_dup_string (value); break; case PROP_DYNAMICS_PATH: g_free (core_config->dynamics_path); core_config->dynamics_path = g_value_dup_string (value); break; case PROP_DYNAMICS_PATH_WRITABLE: g_free (core_config->dynamics_path_writable); core_config->dynamics_path_writable = g_value_dup_string (value); break; case PROP_MYPAINT_BRUSH_PATH: g_free (core_config->mypaint_brush_path); core_config->mypaint_brush_path = g_value_dup_string (value); break; case PROP_MYPAINT_BRUSH_PATH_WRITABLE: g_free (core_config->mypaint_brush_path_writable); core_config->mypaint_brush_path_writable = g_value_dup_string (value); break; case PROP_PATTERN_PATH: g_free (core_config->pattern_path); core_config->pattern_path = g_value_dup_string (value); break; case PROP_PATTERN_PATH_WRITABLE: g_free (core_config->pattern_path_writable); core_config->pattern_path_writable = g_value_dup_string (value); break; case PROP_PALETTE_PATH: g_free (core_config->palette_path); core_config->palette_path = g_value_dup_string (value); break; case PROP_PALETTE_PATH_WRITABLE: g_free (core_config->palette_path_writable); core_config->palette_path_writable = g_value_dup_string (value); break; case PROP_GRADIENT_PATH: g_free (core_config->gradient_path); core_config->gradient_path = g_value_dup_string (value); break; case PROP_GRADIENT_PATH_WRITABLE: g_free (core_config->gradient_path_writable); core_config->gradient_path_writable = g_value_dup_string (value); break; case PROP_TOOL_PRESET_PATH: g_free (core_config->tool_preset_path); core_config->tool_preset_path = g_value_dup_string (value); break; case PROP_TOOL_PRESET_PATH_WRITABLE: g_free (core_config->tool_preset_path_writable); core_config->tool_preset_path_writable = g_value_dup_string (value); break; case PROP_FONT_PATH: g_free (core_config->font_path); core_config->font_path = g_value_dup_string (value); break; case PROP_FONT_PATH_WRITABLE: g_free (core_config->font_path_writable); core_config->font_path_writable = g_value_dup_string (value); break; case PROP_DEFAULT_BRUSH: g_free (core_config->default_brush); core_config->default_brush = g_value_dup_string (value); break; case PROP_DEFAULT_DYNAMICS: g_free (core_config->default_dynamics); core_config->default_dynamics = g_value_dup_string (value); break; case PROP_DEFAULT_MYPAINT_BRUSH: g_free (core_config->default_mypaint_brush); core_config->default_mypaint_brush = g_value_dup_string (value); break; case PROP_DEFAULT_PATTERN: g_free (core_config->default_pattern); core_config->default_pattern = g_value_dup_string (value); break; case PROP_DEFAULT_PALETTE: g_free (core_config->default_palette); core_config->default_palette = g_value_dup_string (value); break; case PROP_DEFAULT_GRADIENT: g_free (core_config->default_gradient); core_config->default_gradient = g_value_dup_string (value); break; case PROP_DEFAULT_TOOL_PRESET: g_free (core_config->default_tool_preset); core_config->default_tool_preset = g_value_dup_string (value); break; case PROP_DEFAULT_FONT: g_free (core_config->default_font); core_config->default_font = g_value_dup_string (value); break; case PROP_GLOBAL_BRUSH: core_config->global_brush = g_value_get_boolean (value); break; case PROP_GLOBAL_DYNAMICS: core_config->global_dynamics = g_value_get_boolean (value); break; case PROP_GLOBAL_PATTERN: core_config->global_pattern = g_value_get_boolean (value); break; case PROP_GLOBAL_PALETTE: core_config->global_palette = g_value_get_boolean (value); break; case PROP_GLOBAL_GRADIENT: core_config->global_gradient = g_value_get_boolean (value); break; case PROP_GLOBAL_FONT: core_config->global_font = g_value_get_boolean (value); break; case PROP_DEFAULT_IMAGE: if (g_value_get_object (value)) gimp_config_sync (g_value_get_object (value) , G_OBJECT (core_config->default_image), 0); break; case PROP_DEFAULT_GRID: if (g_value_get_object (value)) gimp_config_sync (g_value_get_object (value), G_OBJECT (core_config->default_grid), 0); break; case PROP_FILTER_HISTORY_SIZE: core_config->filter_history_size = g_value_get_int (value); break; case PROP_UNDO_LEVELS: core_config->levels_of_undo = g_value_get_int (value); break; case PROP_UNDO_SIZE: core_config->undo_size = g_value_get_uint64 (value); break; case PROP_UNDO_PREVIEW_SIZE: core_config->undo_preview_size = g_value_get_enum (value); break; case PROP_PLUGINRC_PATH: g_free (core_config->plug_in_rc_path); core_config->plug_in_rc_path = g_value_dup_string (value); break; case PROP_LAYER_PREVIEWS: core_config->layer_previews = g_value_get_boolean (value); break; case PROP_GROUP_LAYER_PREVIEWS: core_config->group_layer_previews = g_value_get_boolean (value); break; case PROP_LAYER_PREVIEW_SIZE: core_config->layer_preview_size = g_value_get_enum (value); break; case PROP_THUMBNAIL_SIZE: core_config->thumbnail_size = g_value_get_enum (value); break; case PROP_THUMBNAIL_FILESIZE_LIMIT: core_config->thumbnail_filesize_limit = g_value_get_uint64 (value); break; case PROP_COLOR_MANAGEMENT: if (g_value_get_object (value)) gimp_config_sync (g_value_get_object (value), G_OBJECT (core_config->color_management), 0); break; case PROP_SAVE_DOCUMENT_HISTORY: core_config->save_document_history = g_value_get_boolean (value); break; case PROP_QUICK_MASK_COLOR: gimp_value_get_rgb (value, &core_config->quick_mask_color); break; case PROP_IMPORT_PROMOTE_FLOAT: core_config->import_promote_float = g_value_get_boolean (value); break; case PROP_IMPORT_PROMOTE_DITHER: core_config->import_promote_dither = g_value_get_boolean (value); break; case PROP_IMPORT_ADD_ALPHA: core_config->import_add_alpha = g_value_get_boolean (value); break; case PROP_IMPORT_RAW_PLUG_IN: g_free (core_config->import_raw_plug_in); core_config->import_raw_plug_in = g_value_dup_string (value); break; case PROP_EXPORT_FILE_TYPE: core_config->export_file_type = g_value_get_enum (value); break; case PROP_EXPORT_COLOR_PROFILE: core_config->export_color_profile = g_value_get_boolean (value); break; case PROP_EXPORT_METADATA_EXIF: core_config->export_metadata_exif = g_value_get_boolean (value); break; case PROP_EXPORT_METADATA_XMP: core_config->export_metadata_xmp = g_value_get_boolean (value); break; case PROP_EXPORT_METADATA_IPTC: core_config->export_metadata_iptc = g_value_get_boolean (value); break; case PROP_DEBUG_POLICY: core_config->debug_policy = g_value_get_enum (value); break; case PROP_INSTALL_COLORMAP: case PROP_MIN_COLORS: /* ignored */ break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }