static void
grid_dialog_response (GtkWidget *widget,
gint response_id,
GtkWidget *dialog)
{
GimpImage *image;
GimpImage *grid;
GimpGrid *grid_backup;
image = g_object_get_data (G_OBJECT (dialog), "image");
grid = g_object_get_data (G_OBJECT (dialog), "grid");
grid_backup = g_object_get_data (G_OBJECT (dialog), "grid-backup");
switch (response_id)
{
case GRID_RESPONSE_RESET:
gimp_config_sync (G_OBJECT (image->gimp->config->default_grid),
G_OBJECT (grid), 0);
break;
case GTK_RESPONSE_OK:
if (! gimp_config_is_equal_to (GIMP_CONFIG (grid_backup),
GIMP_CONFIG (grid)))
{
gimp_image_undo_push_image_grid (image, _("Grid"), grid_backup);
}
gtk_widget_destroy (dialog);
break;
default:
gimp_image_set_grid (GIMP_IMAGE (image), grid_backup, FALSE);
gtk_widget_destroy (dialog);
}
}
static gboolean
gimp_config_iface_copy (GimpConfig *src,
GimpConfig *dest,
GParamFlags flags)
{
return gimp_config_sync (G_OBJECT (src), G_OBJECT (dest), flags);
}
static GimpItem *
gimp_text_layer_duplicate (GimpItem *item,
GType new_type)
{
GimpItem *new_item;
g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_DRAWABLE), NULL);
new_item = GIMP_ITEM_CLASS (parent_class)->duplicate (item, new_type);
if (GIMP_IS_TEXT_LAYER (new_item))
{
GimpTextLayer *layer = GIMP_TEXT_LAYER (item);
GimpTextLayer *new_layer = GIMP_TEXT_LAYER (new_item);
gimp_config_sync (G_OBJECT (layer), G_OBJECT (new_layer), 0);
if (layer->text)
{
GimpText *text = gimp_config_duplicate (GIMP_CONFIG (layer->text));
gimp_text_layer_set_text (new_layer, text);
g_object_unref (text);
}
/* this is just the parasite name, not a pointer to the parasite */
if (layer->text_parasite)
new_layer->text_parasite = layer->text_parasite;
}
return new_item;
}
void
tool_presets_save_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpToolPreset *preset;
GimpToolInfo *tool_info;
context = gimp_container_view_get_context (editor->view);
preset = gimp_context_get_tool_preset (context);
tool_info = gimp_context_get_tool (gimp_get_user_context (context->gimp));
if (tool_info && preset)
{
GimpToolInfo *preset_tool;
preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options));
if (tool_info != preset_tool)
{
gimp_message (context->gimp,
G_OBJECT (editor), GIMP_MESSAGE_WARNING,
_("Can't save '%s' tool options to an "
"existing '%s' tool preset."),
tool_info->blurb,
preset_tool->blurb);
return;
}
gimp_config_sync (G_OBJECT (tool_info->tool_options),
G_OBJECT (preset->tool_options), 0);
}
}
GimpContext *
gimp_pdb_context_new (Gimp *gimp,
GimpContext *parent,
gboolean set_parent)
{
GimpContext *context;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (parent), NULL);
context = g_object_new (GIMP_TYPE_PDB_CONTEXT,
"gimp", gimp,
"name", "PDB Context",
NULL);
gimp_config_sync (G_OBJECT (parent), G_OBJECT (context), 0);
if (set_parent)
{
gimp_context_define_properties (context,
GIMP_CONTEXT_ALL_PROPS_MASK, FALSE);
gimp_context_set_parent (context, parent);
}
return context;
}
static GimpConfig *
gimp_rc_duplicate (GimpConfig *config)
{
GimpConfig *dup = g_object_new (GIMP_TYPE_RC, NULL);
gimp_config_sync (G_OBJECT (config), G_OBJECT (dup), 0);
gimp_rc_foreach_unknown_token (config,
gimp_rc_duplicate_unknown_token, dup);
return dup;
}
GimpContext *
gimp_pdb_context_new (Gimp *gimp,
GimpContext *parent,
gboolean set_parent)
{
GimpPDBContext *context;
GList *list;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (parent), NULL);
context = g_object_new (GIMP_TYPE_PDB_CONTEXT,
"gimp", gimp,
"name", "PDB Context",
NULL);
gimp_config_sync (G_OBJECT (parent), G_OBJECT (context), 0);
if (set_parent)
{
gimp_context_define_properties (GIMP_CONTEXT (context),
GIMP_CONTEXT_ALL_PROPS_MASK, FALSE);
gimp_context_set_parent (GIMP_CONTEXT (context), parent);
for (list = gimp_get_paint_info_iter (gimp);
list;
list = g_list_next (list))
{
GimpPaintInfo *info = list->data;
gimp_container_add (context->paint_options_list,
GIMP_OBJECT (info->paint_options));
}
}
else
{
for (list = GIMP_LIST (GIMP_PDB_CONTEXT (parent)->paint_options_list)->list;
list;
list = g_list_next (list))
{
GimpPaintOptions *options = gimp_config_duplicate (list->data);
gimp_container_add (context->paint_options_list,
GIMP_OBJECT (options));
g_object_unref (options);
}
}
return GIMP_CONTEXT (context);
}
static GimpConfig *
gimp_config_iface_duplicate (GimpConfig *config)
{
GObject *object = G_OBJECT (config);
GObjectClass *klass = G_OBJECT_GET_CLASS (object);
GParamSpec **property_specs;
guint n_property_specs;
GParameter *construct_params = NULL;
gint n_construct_params = 0;
guint i;
GObject *dup;
property_specs = g_object_class_list_properties (klass, &n_property_specs);
construct_params = g_new0 (GParameter, n_property_specs);
for (i = 0; i < n_property_specs; i++)
{
GParamSpec *prop_spec = property_specs[i];
if ((prop_spec->flags & G_PARAM_READABLE) &&
(prop_spec->flags & G_PARAM_WRITABLE) &&
(prop_spec->flags & G_PARAM_CONSTRUCT_ONLY))
{
GParameter *construct_param;
construct_param = &construct_params[n_construct_params++];
construct_param->name = prop_spec->name;
g_value_init (&construct_param->value, prop_spec->value_type);
g_object_get_property (object,
prop_spec->name, &construct_param->value);
}
}
g_free (property_specs);
dup = g_object_newv (G_TYPE_FROM_INSTANCE (object),
n_construct_params, construct_params);
for (i = 0; i < n_construct_params; i++)
g_value_unset (&construct_params[i].value);
g_free (construct_params);
gimp_config_sync (object, dup, 0);
return GIMP_CONFIG (dup);
}
static gboolean
gimp_curve_config_copy (GimpConfig *src,
GimpConfig *dest,
GParamFlags flags)
{
GimpCurve *src_curve = GIMP_CURVE (src);
GimpCurve *dest_curve = GIMP_CURVE (dest);
gimp_config_sync (G_OBJECT (src), G_OBJECT (dest), flags);
dest_curve->identity = src_curve->identity;
gimp_data_dirty (GIMP_DATA (dest));
return TRUE;
}
void
tool_options_save_preset_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpEditor *editor = GIMP_EDITOR (data);
Gimp *gimp = gimp_editor_get_ui_manager (editor)->gimp;
GimpContext *context = gimp_get_user_context (gimp);
GimpToolInfo *tool_info = gimp_context_get_tool (context);
GimpToolPreset *preset;
preset = (GimpToolPreset *)
gimp_container_get_child_by_index (tool_info->presets, value);
if (preset)
{
gimp_config_sync (G_OBJECT (tool_info->tool_options),
G_OBJECT (preset->tool_options), 0);
tool_options_show_preset_editor (gimp, editor, preset);
}
}
/* This function could live in gimptexttool.c also.
* But it takes some bloat out of that file...
*/
void
gimp_text_options_connect_text (GimpTextOptions *options,
GimpText *text)
{
GimpContext *context;
GimpRGB color;
g_return_if_fail (GIMP_IS_TEXT_OPTIONS (options));
g_return_if_fail (GIMP_IS_TEXT (text));
context = GIMP_CONTEXT (options);
gimp_context_get_foreground (context, &color);
gimp_config_sync (G_OBJECT (options), G_OBJECT (text), 0);
g_object_set (text,
"color", &color,
"font", gimp_context_get_font_name (context),
NULL);
gimp_config_connect (G_OBJECT (options), G_OBJECT (text), NULL);
g_signal_connect_object (options, "notify::font",
G_CALLBACK (gimp_text_options_notify_font),
text, 0);
g_signal_connect_object (text, "notify::font",
G_CALLBACK (gimp_text_options_notify_text_font),
options, 0);
g_signal_connect_object (options, "notify::foreground",
G_CALLBACK (gimp_text_options_notify_color),
text, 0);
g_signal_connect_object (text, "notify::color",
G_CALLBACK (gimp_text_options_notify_text_color),
options, 0);
}
static void
gimp_text_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpTextUndo *text_undo = GIMP_TEXT_UNDO (undo);
GimpTextLayer *layer = GIMP_TEXT_LAYER (GIMP_ITEM_UNDO (undo)->item);
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
switch (undo->undo_type)
{
case GIMP_UNDO_TEXT_LAYER:
if (text_undo->pspec)
{
GValue *value;
g_return_if_fail (layer->text != NULL);
value = g_slice_new0 (GValue);
g_value_init (value, text_undo->pspec->value_type);
g_object_get_property (G_OBJECT (layer->text),
text_undo->pspec->name, value);
g_object_set_property (G_OBJECT (layer->text),
text_undo->pspec->name, text_undo->value);
g_value_unset (text_undo->value);
g_slice_free (GValue, text_undo->value);
text_undo->value = value;
}
else
{
GimpText *text;
text = (layer->text ?
gimp_config_duplicate (GIMP_CONFIG (layer->text)) : NULL);
if (layer->text && text_undo->text)
gimp_config_sync (G_OBJECT (text_undo->text),
G_OBJECT (layer->text), 0);
else
gimp_text_layer_set_text (layer, text_undo->text);
if (text_undo->text)
g_object_unref (text_undo->text);
text_undo->text = text;
}
break;
case GIMP_UNDO_TEXT_LAYER_MODIFIED:
{
gboolean modified;
#if 0
g_print ("setting layer->modified from %s to %s\n",
layer->modified ? "TRUE" : "FALSE",
text_undo->modified ? "TRUE" : "FALSE");
#endif
modified = layer->modified;
g_object_set (layer, "modified", text_undo->modified, NULL);
text_undo->modified = modified;
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer));
}
break;
case GIMP_UNDO_TEXT_LAYER_CONVERT:
{
const Babl *format;
format = gimp_drawable_get_format (GIMP_DRAWABLE (layer));
gimp_drawable_convert_type (GIMP_DRAWABLE (layer),
gimp_item_get_image (GIMP_ITEM (layer)),
gimp_babl_format_get_base_type (text_undo->format),
gimp_babl_format_get_precision (text_undo->format),
0, 0, FALSE);
text_undo->format = format;
}
break;
default:
g_assert_not_reached ();
}
}
GtkWidget *
stroke_dialog_new (GimpItem *item,
GimpContext *context,
const gchar *title,
const gchar *stock_id,
const gchar *help_id,
GtkWidget *parent)
{
GimpStrokeDesc *desc;
GimpStrokeDesc *saved_desc;
GimpImage *image;
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *radio_box;
GtkWidget *libart_radio;
GtkWidget *paint_radio;
GSList *group;
GtkWidget *frame;
g_return_val_if_fail (GIMP_IS_ITEM (item), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (stock_id != NULL, NULL);
g_return_val_if_fail (help_id != NULL, NULL);
g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), NULL);
image = gimp_item_get_image (item);
desc = gimp_stroke_desc_new (context->gimp, context);
saved_desc = g_object_get_data (G_OBJECT (context->gimp),
"saved-stroke-desc");
if (saved_desc)
gimp_config_sync (G_OBJECT (saved_desc), G_OBJECT (desc), 0);
dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (item), context,
title, "gimp-stroke-options",
stock_id,
_("Choose Stroke Style"),
parent,
gimp_standard_help_func,
help_id,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
stock_id, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
g_signal_connect (dialog, "response",
G_CALLBACK (stroke_dialog_response),
dialog);
g_object_set_data (G_OBJECT (dialog), "gimp-item", item);
g_object_set_data_full (G_OBJECT (dialog), "gimp-stroke-desc", desc,
(GDestroyNotify) g_object_unref);
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
gtk_widget_show (main_vbox);
radio_box = gimp_prop_enum_radio_box_new (G_OBJECT (desc), "method", -1, -1);
group = gtk_radio_button_get_group (g_object_get_data (G_OBJECT (radio_box),
"radio-button"));
libart_radio = g_object_ref (group->next->data);
gtk_container_remove (GTK_CONTAINER (radio_box), libart_radio);
paint_radio = g_object_ref (group->data);
gtk_container_remove (GTK_CONTAINER (radio_box), paint_radio);
g_object_ref_sink (radio_box);
g_object_unref (radio_box);
{
PangoFontDescription *font_desc;
font_desc = pango_font_description_new ();
pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD);
gtk_widget_modify_font (gtk_bin_get_child (GTK_BIN (libart_radio)),
font_desc);
gtk_widget_modify_font (gtk_bin_get_child (GTK_BIN (paint_radio)),
font_desc);
pango_font_description_free (font_desc);
}
/* the stroke frame */
frame = gimp_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
gtk_frame_set_label_widget (GTK_FRAME (frame), libart_radio);
g_object_unref (libart_radio);
g_signal_connect (libart_radio, "toggled",
G_CALLBACK (gimp_toggle_button_sensitive_update),
NULL);
{
GtkWidget *stroke_editor;
gdouble xres;
gdouble yres;
gimp_image_get_resolution (image, &xres, &yres);
stroke_editor = gimp_stroke_editor_new (desc->stroke_options, yres);
gtk_container_add (GTK_CONTAINER (frame), stroke_editor);
gtk_widget_show (stroke_editor);
gtk_widget_set_sensitive (stroke_editor,
desc->method == GIMP_STROKE_METHOD_LIBART);
g_object_set_data (G_OBJECT (libart_radio), "set_sensitive", stroke_editor);
}
/* the paint tool frame */
frame = gimp_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
gtk_frame_set_label_widget (GTK_FRAME (frame), paint_radio);
g_object_unref (paint_radio);
g_signal_connect (paint_radio, "toggled",
G_CALLBACK (gimp_toggle_button_sensitive_update),
NULL);
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *button;
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
gtk_widget_set_sensitive (vbox,
desc->method == GIMP_STROKE_METHOD_PAINT_CORE);
g_object_set_data (G_OBJECT (paint_radio), "set_sensitive", vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Paint tool:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gimp_container_combo_box_new (image->gimp->paint_info_list,
context,
16, 0);
gimp_container_view_select_item (GIMP_CONTAINER_VIEW (combo),
GIMP_VIEWABLE (desc->paint_info));
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
gtk_widget_show (combo);
g_signal_connect (combo, "select-item",
G_CALLBACK (stroke_dialog_paint_info_selected),
desc);
g_object_set_data (G_OBJECT (dialog), "gimp-tool-menu", combo);
button = gimp_prop_check_button_new (G_OBJECT (desc),
"emulate-brush-dynamics",
_("_Emulate brush dynamics"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
return dialog;
}
static void
stroke_dialog_response (GtkWidget *widget,
gint response_id,
GtkWidget *dialog)
{
GimpStrokeDesc *desc;
GimpItem *item;
GimpImage *image;
GimpContext *context;
item = g_object_get_data (G_OBJECT (dialog), "gimp-item");
desc = g_object_get_data (G_OBJECT (dialog), "gimp-stroke-desc");
image = gimp_item_get_image (item);
context = GIMP_VIEWABLE_DIALOG (dialog)->context;
switch (response_id)
{
case RESPONSE_RESET:
{
GimpToolInfo *tool_info = gimp_context_get_tool (context);
GtkWidget *combo = g_object_get_data (G_OBJECT (dialog),
"gimp-tool-menu");;
gimp_config_reset (GIMP_CONFIG (desc));
gimp_container_view_select_item (GIMP_CONTAINER_VIEW (combo),
GIMP_VIEWABLE (tool_info->paint_info));
}
break;
case GTK_RESPONSE_OK:
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
GimpStrokeDesc *saved_desc;
GError *error = NULL;
if (! drawable)
{
gimp_message (context->gimp, G_OBJECT (widget),
GIMP_MESSAGE_WARNING,
_("There is no active layer or channel "
"to stroke to."));
return;
}
saved_desc = g_object_get_data (G_OBJECT (context->gimp),
"saved-stroke-desc");
if (saved_desc)
g_object_ref (saved_desc);
else
saved_desc = gimp_stroke_desc_new (context->gimp, context);
gimp_config_sync (G_OBJECT (desc), G_OBJECT (saved_desc), 0);
g_object_set_data_full (G_OBJECT (context->gimp), "saved-stroke-desc",
saved_desc,
(GDestroyNotify) g_object_unref);
if (! gimp_item_stroke (item, drawable, context, desc, FALSE, NULL,
&error))
{
gimp_message (context->gimp,
G_OBJECT (widget),
GIMP_MESSAGE_WARNING,
"%s",
error ? error->message : "NULL");
g_clear_error (&error);
return;
}
gimp_image_flush (image);
}
/* fallthrough */
default:
gtk_widget_destroy (dialog);
break;
}
}
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;
}
}