diff --git a/app/actions/channels-commands.c b/app/actions/channels-commands.c index b8b572980b..015c0aaba9 100644 --- a/app/actions/channels-commands.c +++ b/app/actions/channels-commands.c @@ -65,7 +65,7 @@ static void channels_new_callback (GtkWidget *dialog, GimpChannel *channel, GimpContext *context, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean save_selection, gboolean channel_visible, GimpColorTag channel_color_tag, @@ -78,7 +78,7 @@ static void channels_edit_attributes_callback (GtkWidget *dialog, GimpChannel *channel, GimpContext *context, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean save_selection, gboolean channel_visible, GimpColorTag channel_color_tag, @@ -127,7 +127,7 @@ channels_edit_attributes_cmd_callback (GimpAction *action, _("_Fill opacity:"), FALSE, gimp_object_get_name (channel), - &channel->color, + channel->color, gimp_item_get_visible (item), gimp_item_get_color_tag (item), gimp_item_get_lock_content (item), @@ -173,7 +173,7 @@ channels_new_cmd_callback (GimpAction *action, _("_Fill opacity:"), TRUE, config->channel_new_name, - &config->channel_new_color, + config->channel_new_color, TRUE, GIMP_COLOR_TAG_NONE, FALSE, @@ -204,7 +204,7 @@ channels_new_last_vals_cmd_callback (GimpAction *action, gimp_image_get_width (image), gimp_image_get_height (image), config->channel_new_name, - &config->channel_new_color); + config->channel_new_color); gimp_drawable_fill (GIMP_DRAWABLE (channel), action_data_get_context (data), @@ -613,7 +613,7 @@ channels_new_callback (GtkWidget *dialog, GimpChannel *channel, GimpContext *context, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean save_selection, gboolean channel_visible, GimpColorTag channel_color_tag, @@ -638,7 +638,7 @@ channels_new_callback (GtkWidget *dialog, gimp_object_set_name (GIMP_OBJECT (channel), config->channel_new_name); - gimp_channel_set_color (channel, &config->channel_new_color, FALSE); + gimp_channel_set_color (channel, config->channel_new_color, FALSE); } else { @@ -646,7 +646,7 @@ channels_new_callback (GtkWidget *dialog, gimp_image_get_width (image), gimp_image_get_height (image), config->channel_new_name, - &config->channel_new_color); + config->channel_new_color); gimp_drawable_fill (GIMP_DRAWABLE (channel), context, GIMP_FILL_TRANSPARENT); @@ -671,7 +671,7 @@ channels_edit_attributes_callback (GtkWidget *dialog, GimpChannel *channel, GimpContext *context, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean save_selection, gboolean channel_visible, GimpColorTag channel_color_tag, @@ -682,12 +682,12 @@ channels_edit_attributes_callback (GtkWidget *dialog, { GimpItem *item = GIMP_ITEM (channel); - if (strcmp (channel_name, gimp_object_get_name (channel)) || - gimp_rgba_distance (channel_color, &channel->color) > RGBA_EPSILON || - channel_visible != gimp_item_get_visible (item) || - channel_color_tag != gimp_item_get_color_tag (item) || - channel_lock_content != gimp_item_get_lock_content (item) || - channel_lock_position != gimp_item_get_lock_position (item) || + if (strcmp (channel_name, gimp_object_get_name (channel)) || + ! gimp_color_is_perceptually_identical (channel_color, channel->color) || + channel_visible != gimp_item_get_visible (item) || + channel_color_tag != gimp_item_get_color_tag (item) || + channel_lock_content != gimp_item_get_lock_content (item) || + channel_lock_position != gimp_item_get_lock_position (item) || channel_lock_visibility != gimp_item_get_lock_visibility (item)) { gimp_image_undo_group_start (image, @@ -697,7 +697,7 @@ channels_edit_attributes_callback (GtkWidget *dialog, if (strcmp (channel_name, gimp_object_get_name (channel))) gimp_item_rename (GIMP_ITEM (channel), channel_name, NULL); - if (gimp_rgba_distance (channel_color, &channel->color) > RGBA_EPSILON) + if (! gimp_color_is_perceptually_identical (channel_color, channel->color)) gimp_channel_set_color (channel, channel_color, TRUE); if (channel_visible != gimp_item_get_visible (item)) diff --git a/app/actions/quick-mask-actions.c b/app/actions/quick-mask-actions.c index c4ddce7a29..74e278fa9b 100644 --- a/app/actions/quick-mask-actions.c +++ b/app/actions/quick-mask-actions.c @@ -95,14 +95,14 @@ quick_mask_actions_update (GimpActionGroup *group, GimpImage *image = action_data_get_image (data); gboolean quick_mask_state = FALSE; gboolean quick_mask_inverted = FALSE; - GimpRGB quick_mask_color; + GeglColor *quick_mask_color = NULL; if (image) { quick_mask_state = gimp_image_get_quick_mask_state (image); quick_mask_inverted = gimp_image_get_quick_mask_inverted (image); - gimp_image_get_quick_mask_color (image, &quick_mask_color); + quick_mask_color = gimp_image_get_quick_mask_color (image); } #define SET_SENSITIVE(action,sensitive) \ @@ -126,7 +126,12 @@ quick_mask_actions_update (GimpActionGroup *group, SET_SENSITIVE ("quick-mask-configure", image); if (image) - SET_COLOR ("quick-mask-configure", &quick_mask_color); + { + GimpRGB rgb; + + gegl_color_get_pixel (quick_mask_color, babl_format ("R'G'B'A double"), &rgb); + SET_COLOR ("quick-mask-configure", &rgb); + } #undef SET_SENSITIVE #undef SET_ACTIVE diff --git a/app/actions/quick-mask-commands.c b/app/actions/quick-mask-commands.c index 4191e0d884..dc19f13b5e 100644 --- a/app/actions/quick-mask-commands.c +++ b/app/actions/quick-mask-commands.c @@ -52,7 +52,7 @@ static void quick_mask_configure_callback (GtkWidget *dialog, GimpChannel *channel, GimpContext *context, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean save_selection, gboolean channel_visible, GimpColorTag channel_color_tag, @@ -117,9 +117,9 @@ quick_mask_configure_cmd_callback (GimpAction *action, if (! dialog) { - GimpRGB color; + GeglColor *color; - gimp_image_get_quick_mask_color (image, &color); + color = gimp_image_get_quick_mask_color (image); dialog = channel_options_dialog_new (image, NULL, action_data_get_context (data), @@ -133,7 +133,7 @@ quick_mask_configure_cmd_callback (GimpAction *action, _("_Mask opacity:"), FALSE, NULL, - &color, + color, FALSE, GIMP_COLOR_TAG_NONE, FALSE, @@ -159,7 +159,7 @@ quick_mask_configure_callback (GtkWidget *dialog, GimpChannel *channel, GimpContext *context, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean save_selection, gboolean channel_visible, GimpColorTag channel_color_tag, @@ -168,11 +168,11 @@ quick_mask_configure_callback (GtkWidget *dialog, gboolean channel_lock_visibility, gpointer user_data) { - GimpRGB old_color; + GeglColor *old_color; - gimp_image_get_quick_mask_color (image, &old_color); + old_color = gimp_image_get_quick_mask_color (image); - if (gimp_rgba_distance (&old_color, channel_color) > RGBA_EPSILON) + if (! gimp_color_is_perceptually_identical (old_color, channel_color)) { gimp_image_set_quick_mask_color (image, channel_color); gimp_image_flush (image); diff --git a/app/actions/view-commands.c b/app/actions/view-commands.c index da3863e752..dabe8a467b 100644 --- a/app/actions/view-commands.c +++ b/app/actions/view-commands.c @@ -1051,13 +1051,13 @@ view_padding_color_cmd_callback (GimpAction *action, options->padding_mode_set = TRUE; gimp_display_shell_set_padding (shell, padding_mode, - &options->padding_color); + options->padding_color); break; case GIMP_CANVAS_PADDING_MODE_CUSTOM: { GtkWidget *dialog; - GimpRGB *old_color = g_new (GimpRGB, 1); + GeglColor *old_color; GimpCanvasPaddingMode old_padding_mode; dialog = dialogs_get_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY); @@ -1066,7 +1066,9 @@ view_padding_color_cmd_callback (GimpAction *action, { GimpImage *image = gimp_display_get_image (display); GimpDisplayShell *shell = gimp_display_get_shell (display); + GimpRGB rgb; + gegl_color_get_pixel (options->padding_color, babl_format ("R'G'B'A double"), &rgb); dialog = gimp_color_dialog_new (GIMP_VIEWABLE (image), action_data_get_context (data), @@ -1076,7 +1078,7 @@ view_padding_color_cmd_callback (GimpAction *action, _("Set Custom Canvas Padding Color"), GTK_WIDGET (shell), NULL, NULL, - &options->padding_color, + &rgb, TRUE, FALSE); g_signal_connect (dialog, "update", @@ -1086,10 +1088,10 @@ view_padding_color_cmd_callback (GimpAction *action, dialogs_attach_dialog (G_OBJECT (shell), PADDING_COLOR_DIALOG_KEY, dialog); } - *old_color = options->padding_color; + old_color = gegl_color_duplicate (options->padding_color); old_padding_mode = options->padding_mode; g_object_set_data_full (G_OBJECT (dialog), "old-color", - old_color, g_free); + old_color, g_object_unref); g_object_set_data (G_OBJECT (dialog), "old-padding-mode", GINT_TO_POINTER (old_padding_mode)); @@ -1112,7 +1114,7 @@ view_padding_color_cmd_callback (GimpAction *action, gimp_display_shell_set_padding (shell, default_options->padding_mode, - &default_options->padding_color); + default_options->padding_color); gimp_display_shell_set_padding_in_show_all (shell, default_options->padding_in_show_all); } @@ -1174,16 +1176,20 @@ view_fullscreen_cmd_callback (GimpAction *action, static void view_padding_color_dialog_update (GimpColorDialog *dialog, - const GimpRGB *color, + const GimpRGB *rgb, GimpColorDialogState state, GimpDisplayShell *shell) { GimpImageWindow *window; GimpDisplayOptions *options; - GimpRGB *old_color; + GeglColor *color; + GeglColor *old_color; GimpCanvasPaddingMode old_padding_mode; gboolean fullscreen; + color = gegl_color_new (NULL); + gegl_color_set_pixel (color, babl_format ("R'G'B'A double"), rgb); + window = gimp_display_shell_get_window (shell); old_color = g_object_get_data (G_OBJECT (dialog), "old-color"); old_padding_mode = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), "old-padding-mode")); @@ -1225,4 +1231,6 @@ view_padding_color_dialog_update (GimpColorDialog *dialog, default: break; } + + g_object_unref (color); } diff --git a/app/config/gimpcoreconfig.c b/app/config/gimpcoreconfig.c index 382f4e7796..82bcf02f3a 100644 --- a/app/config/gimpcoreconfig.c +++ b/app/config/gimpcoreconfig.c @@ -170,9 +170,11 @@ gimp_core_config_class_init (GimpCoreConfigClass *klass) GObjectClass *object_class = G_OBJECT_CLASS (klass); gchar *path; gchar *mypaint_brushes; - GimpRGB red = { 1.0, 0, 0, 0.5 }; + GeglColor *red = gegl_color_new ("red"); guint64 undo_size; + gimp_color_set_alpha (red, 0.5); + object_class->finalize = gimp_core_config_finalize; object_class->set_property = gimp_core_config_set_property; object_class->get_property = gimp_core_config_get_property; @@ -704,12 +706,12 @@ gimp_core_config_class_init (GimpCoreConfigClass *klass) TRUE, GIMP_PARAM_STATIC_STRINGS); - GIMP_CONFIG_PROP_RGB (object_class, PROP_QUICK_MASK_COLOR, - "quick-mask-color", - "Quick mask color", - QUICK_MASK_COLOR_BLURB, - TRUE, &red, - GIMP_PARAM_STATIC_STRINGS); + GIMP_CONFIG_PROP_COLOR (object_class, PROP_QUICK_MASK_COLOR, + "quick-mask-color", + "Quick mask color", + QUICK_MASK_COLOR_BLURB, + red, + GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_IMPORT_PROMOTE_FLOAT, "import-promote-float", @@ -836,11 +838,18 @@ gimp_core_config_class_init (GimpCoreConfigClass *klass) 27, 256, 144, GIMP_PARAM_STATIC_STRINGS | GIMP_CONFIG_PARAM_IGNORE); + + g_object_unref (red); } static void gimp_core_config_init (GimpCoreConfig *config) { + GeglColor *red = gegl_color_new ("red"); + + gimp_color_set_alpha (red, 0.5); + config->quick_mask_color = red; + config->default_image = g_object_new (GIMP_TYPE_TEMPLATE, "name", "Default Image", "comment", GIMP_DEFAULT_COMMENT, @@ -907,6 +916,7 @@ gimp_core_config_finalize (GObject *object) g_clear_object (&core_config->default_image); g_clear_object (&core_config->default_grid); g_clear_object (&core_config->color_management); + g_clear_object (&core_config->quick_mask_color); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -1142,7 +1152,8 @@ gimp_core_config_set_property (GObject *object, 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); + g_clear_object (&core_config->quick_mask_color); + core_config->quick_mask_color = gegl_color_duplicate (g_value_get_object (value)); break; case PROP_IMPORT_PROMOTE_FLOAT: core_config->import_promote_float = g_value_get_boolean (value); @@ -1411,7 +1422,7 @@ gimp_core_config_get_property (GObject *object, g_value_set_boolean (value, core_config->save_document_history); break; case PROP_QUICK_MASK_COLOR: - gimp_value_set_rgb (value, &core_config->quick_mask_color); + g_value_set_object (value, core_config->quick_mask_color); break; case PROP_IMPORT_PROMOTE_FLOAT: g_value_set_boolean (value, core_config->import_promote_float); diff --git a/app/config/gimpcoreconfig.h b/app/config/gimpcoreconfig.h index 10afd86bb6..8ab57d6526 100644 --- a/app/config/gimpcoreconfig.h +++ b/app/config/gimpcoreconfig.h @@ -93,7 +93,7 @@ struct _GimpCoreConfig guint64 thumbnail_filesize_limit; GimpColorConfig *color_management; gboolean save_document_history; - GimpRGB quick_mask_color; + GeglColor *quick_mask_color; gboolean import_promote_float; gboolean import_promote_dither; gboolean import_add_alpha; diff --git a/app/config/gimpdialogconfig.c b/app/config/gimpdialogconfig.c index 412274404a..911980341b 100644 --- a/app/config/gimpdialogconfig.c +++ b/app/config/gimpdialogconfig.c @@ -155,7 +155,9 @@ static void gimp_dialog_config_class_init (GimpDialogConfigClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - GimpRGB half_transparent = { 0.0, 0.0, 0.0, 0.5 }; + GeglColor *half_transparent = gegl_color_new ("black"); + + gimp_color_set_alpha (half_transparent, 0.5); object_class->constructed = gimp_dialog_config_constructed; object_class->finalize = gimp_dialog_config_finalize; @@ -416,13 +418,12 @@ gimp_dialog_config_class_init (GimpDialogConfigClass *klass) _("Channel"), GIMP_PARAM_STATIC_STRINGS); - GIMP_CONFIG_PROP_RGB (object_class, PROP_CHANNEL_NEW_COLOR, - "channel-new-color", - "Default new channel color and opacity", - CHANNEL_NEW_COLOR_BLURB, - TRUE, - &half_transparent, - GIMP_PARAM_STATIC_STRINGS); + GIMP_CONFIG_PROP_COLOR (object_class, PROP_CHANNEL_NEW_COLOR, + "channel-new-color", + "Default new channel color and opacity", + CHANNEL_NEW_COLOR_BLURB, + half_transparent, + GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_STRING (object_class, PROP_VECTORS_NEW_NAME, "path-new-name", @@ -540,11 +541,17 @@ gimp_dialog_config_class_init (GimpDialogConfigClass *klass) GIMP_TYPE_STROKE_OPTIONS, GIMP_PARAM_STATIC_STRINGS | GIMP_CONFIG_PARAM_AGGREGATE); + + g_object_unref (half_transparent); } static void gimp_dialog_config_init (GimpDialogConfig *config) { + GeglColor *half_transparent = gegl_color_new ("black"); + + gimp_color_set_alpha (half_transparent, 0.5); + config->channel_new_color = half_transparent; } static void @@ -591,6 +598,7 @@ gimp_dialog_config_finalize (GObject *object) g_clear_object (&config->fill_options); g_clear_object (&config->stroke_options); + g_clear_object (&config->channel_new_color); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -723,7 +731,8 @@ gimp_dialog_config_set_property (GObject *object, config->channel_new_name = g_value_dup_string (value); break; case PROP_CHANNEL_NEW_COLOR: - gimp_value_get_rgb (value, &config->channel_new_color); + g_clear_object (&config->channel_new_color); + config->channel_new_color = gegl_color_duplicate (g_value_get_object (value)); break; case PROP_VECTORS_NEW_NAME: @@ -920,7 +929,7 @@ gimp_dialog_config_get_property (GObject *object, g_value_set_string (value, config->channel_new_name); break; case PROP_CHANNEL_NEW_COLOR: - gimp_value_set_rgb (value, &config->channel_new_color); + g_value_set_object (value, config->channel_new_color); break; case PROP_VECTORS_NEW_NAME: diff --git a/app/config/gimpdialogconfig.h b/app/config/gimpdialogconfig.h index 882576199b..5d4ca851b9 100644 --- a/app/config/gimpdialogconfig.h +++ b/app/config/gimpdialogconfig.h @@ -85,7 +85,7 @@ struct _GimpDialogConfig gboolean layer_merge_discard_invisible; gchar *channel_new_name; - GimpRGB channel_new_color; + GeglColor *channel_new_color; gchar *vectors_new_name; diff --git a/app/config/gimpdisplayoptions.c b/app/config/gimpdisplayoptions.c index 1451352de4..a89b2556bc 100644 --- a/app/config/gimpdisplayoptions.c +++ b/app/config/gimpdisplayoptions.c @@ -63,6 +63,7 @@ enum }; +static void gimp_display_options_finalize (GObject *object); static void gimp_display_options_set_property (GObject *object, guint property_id, const GValue *value, @@ -103,10 +104,9 @@ static void gimp_display_options_class_init (GimpDisplayOptionsClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - GimpRGB white; - - gimp_rgba_set (&white, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE); + GeglColor *white = gegl_color_new ("white"); + object_class->finalize = gimp_display_options_finalize; object_class->set_property = gimp_display_options_set_property; object_class->get_property = gimp_display_options_get_property; @@ -230,12 +230,12 @@ gimp_display_options_class_init (GimpDisplayOptionsClass *klass) GIMP_CANVAS_PADDING_MODE_DEFAULT, GIMP_PARAM_STATIC_STRINGS); - GIMP_CONFIG_PROP_RGB (object_class, PROP_PADDING_COLOR, - "padding-color", - "Padding color", - CANVAS_PADDING_COLOR_BLURB, - FALSE, &white, - GIMP_PARAM_STATIC_STRINGS); + GIMP_CONFIG_PROP_COLOR (object_class, PROP_PADDING_COLOR, + "padding-color", + "Padding color", + CANVAS_PADDING_COLOR_BLURB, + white, + GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_PADDING_IN_SHOW_ALL, "padding-in-show-all", @@ -243,16 +243,17 @@ gimp_display_options_class_init (GimpDisplayOptionsClass *klass) CANVAS_PADDING_IN_SHOW_ALL_BLURB, FALSE, GIMP_PARAM_STATIC_STRINGS); + + g_object_unref (white); } static void gimp_display_options_fullscreen_class_init (GimpDisplayOptionsFullscreenClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - GimpRGB black; - - gimp_rgba_set (&black, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE); + GeglColor *black = gegl_color_new ("black"); + object_class->finalize = gimp_display_options_finalize; object_class->set_property = gimp_display_options_set_property; object_class->get_property = gimp_display_options_get_property; @@ -376,12 +377,12 @@ gimp_display_options_fullscreen_class_init (GimpDisplayOptionsFullscreenClass *k GIMP_CANVAS_PADDING_MODE_CUSTOM, GIMP_PARAM_STATIC_STRINGS); - GIMP_CONFIG_PROP_RGB (object_class, PROP_PADDING_COLOR, - "padding-color", - "Padding color", - CANVAS_PADDING_COLOR_BLURB, - FALSE, &black, - GIMP_PARAM_STATIC_STRINGS); + GIMP_CONFIG_PROP_COLOR (object_class, PROP_PADDING_COLOR, + "padding-color", + "Padding color", + CANVAS_PADDING_COLOR_BLURB, + black, + GIMP_PARAM_STATIC_STRINGS); GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_PADDING_IN_SHOW_ALL, "padding-in-show-all", @@ -389,6 +390,8 @@ gimp_display_options_fullscreen_class_init (GimpDisplayOptionsFullscreenClass *k CANVAS_PADDING_IN_SHOW_ALL_BLURB, FALSE, GIMP_PARAM_STATIC_STRINGS); + + g_object_unref (black); } static void @@ -501,9 +504,33 @@ gimp_display_options_no_image_class_init (GimpDisplayOptionsNoImageClass *klass) static void gimp_display_options_init (GimpDisplayOptions *options) { + GeglColor *color; + + if (G_TYPE_CHECK_INSTANCE_TYPE ((options), GIMP_TYPE_DISPLAY_OPTIONS_FULLSCREEN)) + color = gegl_color_new ("black"); + else + color = gegl_color_new ("white"); + + gimp_color_set_alpha (color, GIMP_OPACITY_OPAQUE); + options->padding_color = color; options->padding_mode_set = FALSE; } +static void +gimp_display_options_finalize (GObject *object) +{ + GimpDisplayOptions *options = GIMP_DISPLAY_OPTIONS (object); + + g_clear_object (&options->padding_color); + + /* Since we share the finalize for both GimpDisplayOptions and its child + * GimpDisplayOptionsFullscreen, we run the (grand-)parent finalize() function + * directly. We don't want to end up in some infinite loop by recognizing the + * exact type of object. + */ + G_OBJECT_CLASS (gimp_display_options_parent_class)->finalize (object); +} + static void gimp_display_options_set_property (GObject *object, guint property_id, @@ -566,7 +593,8 @@ gimp_display_options_set_property (GObject *object, options->padding_mode = g_value_get_enum (value); break; case PROP_PADDING_COLOR: - options->padding_color = *(GimpRGB *) g_value_get_boxed (value); + g_clear_object (&options->padding_color); + options->padding_color = gegl_color_duplicate (g_value_get_object (value)); break; case PROP_PADDING_IN_SHOW_ALL: options->padding_in_show_all = g_value_get_boolean (value); @@ -640,7 +668,7 @@ gimp_display_options_get_property (GObject *object, g_value_set_enum (value, options->padding_mode); break; case PROP_PADDING_COLOR: - g_value_set_boxed (value, &options->padding_color); + g_value_set_object (value, options->padding_color); break; case PROP_PADDING_IN_SHOW_ALL: g_value_set_boolean (value, options->padding_in_show_all); diff --git a/app/config/gimpdisplayoptions.h b/app/config/gimpdisplayoptions.h index b04138167e..05b2ab2550 100644 --- a/app/config/gimpdisplayoptions.h +++ b/app/config/gimpdisplayoptions.h @@ -61,7 +61,7 @@ struct _GimpDisplayOptions gboolean snap_to_equidistance; GimpCanvasPaddingMode padding_mode; - GimpRGB padding_color; + GeglColor *padding_color; gboolean padding_mode_set; gboolean padding_in_show_all; }; diff --git a/app/config/gimpguiconfig.c b/app/config/gimpguiconfig.c index a3eb0d92f3..a8e84b1af1 100644 --- a/app/config/gimpguiconfig.c +++ b/app/config/gimpguiconfig.c @@ -20,6 +20,7 @@ #include "config.h" +#include #include #include "libgimpbase/gimpbase.h" diff --git a/app/core/gimpchannel.c b/app/core/gimpchannel.c index 828389dffd..a64cf4756f 100644 --- a/app/core/gimpchannel.c +++ b/app/core/gimpchannel.c @@ -304,7 +304,7 @@ gimp_channel_class_init (GimpChannelClass *klass) static void gimp_channel_init (GimpChannel *channel) { - gimp_rgba_set (&channel->color, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE); + channel->color = gegl_color_new ("black"); channel->show_masked = FALSE; @@ -335,6 +335,7 @@ gimp_channel_finalize (GObject *object) g_clear_pointer (&channel->segs_in, g_free); g_clear_pointer (&channel->segs_out, g_free); + g_clear_object (&channel->color); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -392,8 +393,7 @@ gimp_channel_get_node (GimpFilter *filter) "operation", "gegl:color", "format", color_format, NULL); - gimp_gegl_node_set_color (channel->color_node, - &channel->color, NULL); + gimp_gegl_node_set_color (channel->color_node, channel->color); g_warn_if_fail (channel->mask_node == NULL); @@ -496,7 +496,8 @@ gimp_channel_duplicate (GimpItem *item, GimpChannel *channel = GIMP_CHANNEL (item); GimpChannel *new_channel = GIMP_CHANNEL (new_item); - new_channel->color = channel->color; + g_clear_object (&new_channel->color); + new_channel->color = gegl_color_duplicate (channel->color); new_channel->show_masked = channel->show_masked; /* selection mask variables */ @@ -1513,11 +1514,11 @@ gimp_channel_buffer_changed (GeglBuffer *buffer, /* public functions */ GimpChannel * -gimp_channel_new (GimpImage *image, - gint width, - gint height, - const gchar *name, - const GimpRGB *color) +gimp_channel_new (GimpImage *image, + gint width, + gint height, + const gchar *name, + GeglColor *color) { GimpChannel *channel; @@ -1530,7 +1531,10 @@ gimp_channel_new (GimpImage *image, gimp_image_get_channel_format (image))); if (color) - channel->color = *color; + { + g_clear_object (&channel->color); + channel->color = gegl_color_duplicate (color); + } channel->show_masked = TRUE; @@ -1542,10 +1546,10 @@ gimp_channel_new (GimpImage *image, } GimpChannel * -gimp_channel_new_from_buffer (GimpImage *image, - GeglBuffer *buffer, - const gchar *name, - const GimpRGB *color) +gimp_channel_new_from_buffer (GimpImage *image, + GeglBuffer *buffer, + const gchar *name, + GeglColor *color) { GimpChannel *channel; GeglBuffer *dest; @@ -1565,10 +1569,10 @@ gimp_channel_new_from_buffer (GimpImage *image, } GimpChannel * -gimp_channel_new_from_alpha (GimpImage *image, - GimpDrawable *drawable, - const gchar *name, - const GimpRGB *color) +gimp_channel_new_from_alpha (GimpImage *image, + GimpDrawable *drawable, + const gchar *name, + GeglColor *color) { GimpChannel *channel; GeglBuffer *dest_buffer; @@ -1603,7 +1607,7 @@ GimpChannel * gimp_channel_new_from_component (GimpImage *image, GimpChannelType type, const gchar *name, - const GimpRGB *color) + GeglColor *color) { GimpChannel *channel; GeglBuffer *src_buffer; @@ -1644,14 +1648,14 @@ gimp_channel_get_parent (GimpChannel *channel) } void -gimp_channel_set_color (GimpChannel *channel, - const GimpRGB *color, - gboolean push_undo) +gimp_channel_set_color (GimpChannel *channel, + GeglColor *color, + gboolean push_undo) { g_return_if_fail (GIMP_IS_CHANNEL (channel)); - g_return_if_fail (color != NULL); + g_return_if_fail (GEGL_IS_COLOR (color)); - if (gimp_rgba_distance (&channel->color, color) > RGBA_EPSILON) + if (! gimp_color_is_perceptually_identical (channel->color, (GeglColor *) color)) { if (push_undo && gimp_item_is_attached (GIMP_ITEM (channel))) { @@ -1661,13 +1665,11 @@ gimp_channel_set_color (GimpChannel *channel, channel); } - channel->color = *color; + g_clear_object (&channel->color); + channel->color = gegl_color_duplicate (color); if (gimp_filter_peek_node (GIMP_FILTER (channel))) - { - gimp_gegl_node_set_color (channel->color_node, - &channel->color, NULL); - } + gimp_gegl_node_set_color (channel->color_node, channel->color); gimp_drawable_update (GIMP_DRAWABLE (channel), 0, 0, -1, -1); @@ -1675,22 +1677,24 @@ gimp_channel_set_color (GimpChannel *channel, } } -void -gimp_channel_get_color (GimpChannel *channel, - GimpRGB *color) +GeglColor * +gimp_channel_get_color (GimpChannel *channel) { - g_return_if_fail (GIMP_IS_CHANNEL (channel)); - g_return_if_fail (color != NULL); + g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL); - *color = channel->color; + return channel->color; } gdouble gimp_channel_get_opacity (GimpChannel *channel) { + gdouble opacity; + g_return_val_if_fail (GIMP_IS_CHANNEL (channel), GIMP_OPACITY_TRANSPARENT); - return channel->color.a; + gegl_color_get_rgba (channel->color, NULL, NULL, NULL, &opacity); + + return opacity; } void @@ -1698,11 +1702,14 @@ gimp_channel_set_opacity (GimpChannel *channel, gdouble opacity, gboolean push_undo) { + gdouble current_opacity; + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + gegl_color_get_rgba (channel->color, NULL, NULL, NULL, ¤t_opacity); opacity = CLAMP (opacity, GIMP_OPACITY_TRANSPARENT, GIMP_OPACITY_OPAQUE); - if (channel->color.a != opacity) + if (current_opacity != opacity) { if (push_undo && gimp_item_is_attached (GIMP_ITEM (channel))) { @@ -1712,13 +1719,10 @@ gimp_channel_set_opacity (GimpChannel *channel, channel); } - channel->color.a = opacity; + gimp_color_set_alpha (channel->color, opacity); if (gimp_filter_peek_node (GIMP_FILTER (channel))) - { - gimp_gegl_node_set_color (channel->color_node, - &channel->color, NULL); - } + gimp_gegl_node_set_color (channel->color_node, channel->color); gimp_drawable_update (GIMP_DRAWABLE (channel), 0, 0, -1, -1); diff --git a/app/core/gimpchannel.h b/app/core/gimpchannel.h index 63f95f543e..5882fee2c4 100644 --- a/app/core/gimpchannel.h +++ b/app/core/gimpchannel.h @@ -35,7 +35,7 @@ struct _GimpChannel { GimpDrawable parent_instance; - GimpRGB color; /* Also stores the opacity */ + GeglColor *color; /* Also stores the opacity */ gboolean show_masked; /* Show masked areas--as */ /* opposed to selected areas */ @@ -127,19 +127,19 @@ GimpChannel * gimp_channel_new (GimpImage *image, gint width, gint height, const gchar *name, - const GimpRGB *color); + GeglColor *color); GimpChannel * gimp_channel_new_from_buffer (GimpImage *image, GeglBuffer *buffer, const gchar *name, - const GimpRGB *color); + GeglColor *color); GimpChannel * gimp_channel_new_from_alpha (GimpImage *image, GimpDrawable *drawable, const gchar *name, - const GimpRGB *color); + GeglColor *color); GimpChannel * gimp_channel_new_from_component (GimpImage *image, GimpChannelType type, const gchar *name, - const GimpRGB *color); + GeglColor *color); GimpChannel * gimp_channel_get_parent (GimpChannel *channel); @@ -148,10 +148,9 @@ void gimp_channel_set_opacity (GimpChannel *channel, gdouble opacity, gboolean push_undo); -void gimp_channel_get_color (GimpChannel *channel, - GimpRGB *color); +GeglColor * gimp_channel_get_color (GimpChannel *channel); void gimp_channel_set_color (GimpChannel *channel, - const GimpRGB *color, + GeglColor *color, gboolean push_undo); gboolean gimp_channel_get_show_masked (GimpChannel *channel); diff --git a/app/core/gimpchannelpropundo.c b/app/core/gimpchannelpropundo.c index f140d28530..b3365db6da 100644 --- a/app/core/gimpchannelpropundo.c +++ b/app/core/gimpchannelpropundo.c @@ -30,6 +30,7 @@ static void gimp_channel_prop_undo_constructed (GObject *object); +static void gimp_channel_prop_undo_finalize (GObject *object); static void gimp_channel_prop_undo_pop (GimpUndo *undo, GimpUndoMode undo_mode, @@ -48,6 +49,7 @@ gimp_channel_prop_undo_class_init (GimpChannelPropUndoClass *klass) GimpUndoClass *undo_class = GIMP_UNDO_CLASS (klass); object_class->constructed = gimp_channel_prop_undo_constructed; + object_class->finalize = gimp_channel_prop_undo_finalize; undo_class->pop = gimp_channel_prop_undo_pop; } @@ -72,7 +74,7 @@ gimp_channel_prop_undo_constructed (GObject *object) switch (GIMP_UNDO (object)->undo_type) { case GIMP_UNDO_CHANNEL_COLOR: - gimp_channel_get_color (channel, &channel_prop_undo->color); + channel_prop_undo->color = gegl_color_duplicate (gimp_channel_get_color (channel)); break; default: @@ -80,6 +82,16 @@ gimp_channel_prop_undo_constructed (GObject *object) } } +static void +gimp_channel_prop_undo_finalize (GObject *object) +{ + GimpChannelPropUndo *channel_prop_undo = GIMP_CHANNEL_PROP_UNDO (object); + + g_clear_object (&channel_prop_undo->color); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + static void gimp_channel_prop_undo_pop (GimpUndo *undo, GimpUndoMode undo_mode, @@ -94,10 +106,11 @@ gimp_channel_prop_undo_pop (GimpUndo *undo, { case GIMP_UNDO_CHANNEL_COLOR: { - GimpRGB color; + GeglColor *color; - gimp_channel_get_color (channel, &color); - gimp_channel_set_color (channel, &channel_prop_undo->color, FALSE); + color = gegl_color_duplicate (gimp_channel_get_color (channel)); + gimp_channel_set_color (channel, channel_prop_undo->color, FALSE); + g_clear_object (&channel_prop_undo->color); channel_prop_undo->color = color; } break; diff --git a/app/core/gimpchannelpropundo.h b/app/core/gimpchannelpropundo.h index 2aa7ad5529..eb715a70da 100644 --- a/app/core/gimpchannelpropundo.h +++ b/app/core/gimpchannelpropundo.h @@ -37,7 +37,7 @@ struct _GimpChannelPropUndo { GimpItemUndo parent_instance; - GimpRGB color; + GeglColor *color; }; struct _GimpChannelPropUndoClass diff --git a/app/core/gimpimage-private.h b/app/core/gimpimage-private.h index 187d95ae5e..75e1ae411e 100644 --- a/app/core/gimpimage-private.h +++ b/app/core/gimpimage-private.h @@ -138,7 +138,7 @@ struct _GimpImagePrivate gboolean quick_mask_state; /* TRUE if quick mask is on */ gboolean quick_mask_inverted; /* TRUE if quick mask is inverted */ - GimpRGB quick_mask_color; /* rgba triplet of the color */ + GeglColor *quick_mask_color; /* rgba triplet of the color */ /* Undo apparatus */ GimpUndoStack *undo_stack; /* stack for undo operations */ diff --git a/app/core/gimpimage-quick-mask.c b/app/core/gimpimage-quick-mask.c index baff60dec5..f298110f8f 100644 --- a/app/core/gimpimage-quick-mask.c +++ b/app/core/gimpimage-quick-mask.c @@ -98,7 +98,7 @@ gimp_image_set_quick_mask_state (GimpImage *image, if (! gimp_channel_is_empty (selection)) gimp_channel_clear (selection, NULL, TRUE); - gimp_channel_set_color (mask, &private->quick_mask_color, FALSE); + gimp_channel_set_color (mask, private->quick_mask_color, FALSE); gimp_item_rename (GIMP_ITEM (mask), GIMP_IMAGE_QUICK_MASK_NAME, NULL); @@ -150,29 +150,28 @@ gimp_image_get_quick_mask_state (GimpImage *image) } void -gimp_image_set_quick_mask_color (GimpImage *image, - const GimpRGB *color) +gimp_image_set_quick_mask_color (GimpImage *image, + GeglColor *color) { GimpChannel *quick_mask; g_return_if_fail (GIMP_IS_IMAGE (image)); - g_return_if_fail (color != NULL); + g_return_if_fail (GEGL_IS_COLOR (color)); - GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color = *color; + g_clear_object (&(GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color)); + GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color = gegl_color_duplicate (color); quick_mask = gimp_image_get_quick_mask (image); if (quick_mask) gimp_channel_set_color (quick_mask, color, TRUE); } -void -gimp_image_get_quick_mask_color (GimpImage *image, - GimpRGB *color) +GeglColor * +gimp_image_get_quick_mask_color (GimpImage *image) { - g_return_if_fail (GIMP_IS_IMAGE (image)); - g_return_if_fail (color != NULL); + g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); - *color = GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color; + return GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color; } GimpChannel * diff --git a/app/core/gimpimage-quick-mask.h b/app/core/gimpimage-quick-mask.h index 0eca62e841..71c6516dc0 100644 --- a/app/core/gimpimage-quick-mask.h +++ b/app/core/gimpimage-quick-mask.h @@ -30,9 +30,8 @@ void gimp_image_set_quick_mask_state (GimpImage *image, gboolean gimp_image_get_quick_mask_state (GimpImage *image); void gimp_image_set_quick_mask_color (GimpImage *image, - const GimpRGB *color); -void gimp_image_get_quick_mask_color (GimpImage *image, - GimpRGB *color); + GeglColor *color); +GeglColor * gimp_image_get_quick_mask_color (GimpImage *image); GimpChannel * gimp_image_get_quick_mask (GimpImage *image); diff --git a/app/core/gimpimage.c b/app/core/gimpimage.c index d0e5f01791..dc263bfc4d 100644 --- a/app/core/gimpimage.c +++ b/app/core/gimpimage.c @@ -885,7 +885,9 @@ gimp_image_init (GimpImage *image) private->quick_mask_state = FALSE; private->quick_mask_inverted = FALSE; - gimp_rgba_set (&private->quick_mask_color, 1.0, 0.0, 0.0, 0.5); + /* Quick mask color set to sRGB red with half opacity by default. */ + private->quick_mask_color = gegl_color_new ("red"); + gimp_color_set_alpha (private->quick_mask_color, 0.5); private->undo_stack = gimp_undo_stack_new (image); private->redo_stack = gimp_undo_stack_new (image); @@ -923,7 +925,8 @@ gimp_image_constructed (GObject *object) private->grid = gimp_config_duplicate (GIMP_CONFIG (config->default_grid)); - private->quick_mask_color = config->quick_mask_color; + g_clear_object (&private->quick_mask_color); + private->quick_mask_color = gegl_color_duplicate (config->quick_mask_color); gimp_image_update_bounding_box (image); @@ -1170,6 +1173,7 @@ gimp_image_finalize (GObject *object) g_clear_object (&private->layers); g_clear_object (&private->channels); g_clear_object (&private->vectors); + g_clear_object (&private->quick_mask_color); if (private->layer_stack) { @@ -1829,7 +1833,8 @@ gimp_image_channel_color_changed (GimpChannel *channel, if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME, gimp_object_get_name (channel))) { - GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color = channel->color; + g_clear_object (&(GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color)); + GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color = gegl_color_duplicate (channel->color); } } diff --git a/app/core/gimplayermask.c b/app/core/gimplayermask.c index 4d2879f3e1..e1b3ba7187 100644 --- a/app/core/gimplayermask.c +++ b/app/core/gimplayermask.c @@ -247,14 +247,15 @@ gimp_layer_mask_new (GimpImage *image, gint width, gint height, const gchar *name, - const GimpRGB *color) + const GimpRGB *rgb) { GimpLayerMask *layer_mask; + GeglColor *color; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (width > 0, NULL); g_return_val_if_fail (height > 0, NULL); - g_return_val_if_fail (color != NULL, NULL); + g_return_val_if_fail (rgb != NULL, NULL); layer_mask = GIMP_LAYER_MASK (gimp_drawable_new (GIMP_TYPE_LAYER_MASK, @@ -263,6 +264,8 @@ gimp_layer_mask_new (GimpImage *image, gimp_image_get_mask_format (image))); /* set the layer_mask color and opacity */ + color = gegl_color_new (NULL); + gegl_color_set_pixel (color, babl_format ("R'G'B'A double"), rgb); gimp_channel_set_color (GIMP_CHANNEL (layer_mask), color, FALSE); gimp_channel_set_show_masked (GIMP_CHANNEL (layer_mask), TRUE); diff --git a/app/core/gimpselection.c b/app/core/gimpselection.c index c5224f9dea..6f4d468ac1 100644 --- a/app/core/gimpselection.c +++ b/app/core/gimpselection.c @@ -617,23 +617,26 @@ gimp_selection_new (GimpImage *image, gint width, gint height) { - GimpRGB black = { 0.0, 0.0, 0.0, 0.5 }; + GeglColor *black = gegl_color_new ("black"); GimpChannel *channel; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (width > 0 && height > 0, NULL); + gimp_color_set_alpha (black, 0.5); channel = GIMP_CHANNEL (gimp_drawable_new (GIMP_TYPE_SELECTION, image, NULL, 0, 0, width, height, gimp_image_get_mask_format (image))); - gimp_channel_set_color (channel, &black, FALSE); + gimp_channel_set_color (channel, black, FALSE); gimp_channel_set_show_masked (channel, TRUE); channel->x2 = width; channel->y2 = height; + g_object_unref (black); + return channel; } diff --git a/app/dialogs/channel-options-dialog.c b/app/dialogs/channel-options-dialog.c index e22e6f805f..640d95d7fb 100644 --- a/app/dialogs/channel-options-dialog.c +++ b/app/dialogs/channel-options-dialog.c @@ -86,7 +86,7 @@ channel_options_dialog_new (GimpImage *image, const gchar *opacity_label, gboolean show_from_sel, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean channel_visible, GimpColorTag channel_color_tag, gboolean channel_lock_content, @@ -99,6 +99,7 @@ channel_options_dialog_new (GimpImage *image, GtkWidget *dialog; GtkAdjustment *opacity_adj; GtkWidget *scale; + GimpRGB rgb; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (channel == NULL || GIMP_IS_CHANNEL (channel), NULL); @@ -109,7 +110,7 @@ channel_options_dialog_new (GimpImage *image, g_return_val_if_fail (icon_name != NULL, NULL); g_return_val_if_fail (desc != NULL, NULL); g_return_val_if_fail (help_id != NULL, NULL); - g_return_val_if_fail (channel_color != NULL, NULL); + g_return_val_if_fail (GEGL_IS_COLOR (channel_color), NULL); g_return_val_if_fail (color_label != NULL, NULL); g_return_val_if_fail (opacity_label != NULL, NULL); g_return_val_if_fail (callback != NULL, NULL); @@ -139,7 +140,8 @@ channel_options_dialog_new (GimpImage *image, g_object_weak_ref (G_OBJECT (dialog), (GWeakNotify) channel_options_dialog_free, private); - opacity_adj = gtk_adjustment_new (channel_color->a * 100.0, + gegl_color_get_pixel (channel_color, babl_format ("R'G'B'A double"), &rgb); + opacity_adj = gtk_adjustment_new (rgb.a * 100.0, 0.0, 100.0, 1.0, 10.0, 0); scale = gimp_spin_scale_new (opacity_adj, NULL, 1); gtk_widget_set_size_request (scale, 200, -1); @@ -147,7 +149,7 @@ channel_options_dialog_new (GimpImage *image, opacity_label, scale); private->color_panel = gimp_color_panel_new (color_label, - channel_color, + &rgb, GIMP_COLOR_AREA_LARGE_CHECKS, 24, 24); gimp_color_panel_set_context (GIMP_COLOR_PANEL (private->color_panel), @@ -199,11 +201,12 @@ channel_options_dialog_callback (GtkWidget *dialog, gpointer user_data) { ChannelOptionsDialog *private = user_data; - GimpRGB color; + GeglColor *color = gegl_color_new (NULL); + GimpRGB rgb; gboolean save_selection = FALSE; - gimp_color_button_get_color (GIMP_COLOR_BUTTON (private->color_panel), - &color); + gimp_color_button_get_color (GIMP_COLOR_BUTTON (private->color_panel), &rgb); + gegl_color_set_pixel (color, babl_format ("R'G'B'A double"), &rgb); if (private->save_sel_toggle) save_selection = @@ -214,7 +217,7 @@ channel_options_dialog_callback (GtkWidget *dialog, GIMP_CHANNEL (item), context, item_name, - &color, + color, save_selection, item_visible, item_color_tag, diff --git a/app/dialogs/channel-options-dialog.h b/app/dialogs/channel-options-dialog.h index f9cdbeb0df..e74b85b48f 100644 --- a/app/dialogs/channel-options-dialog.h +++ b/app/dialogs/channel-options-dialog.h @@ -24,7 +24,7 @@ typedef void (* GimpChannelOptionsCallback) (GtkWidget *dialog, GimpChannel *channel, GimpContext *context, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean save_selection, gboolean channel_visible, GimpColorTag channel_color_tag, @@ -47,7 +47,7 @@ GtkWidget * channel_options_dialog_new (GimpImage *image, const gchar *opacity_label, gboolean show_from_sel, const gchar *channel_name, - const GimpRGB *channel_color, + GeglColor *channel_color, gboolean channel_visible, GimpColorTag channel_color_tag, gboolean channel_lock_content, diff --git a/app/dialogs/preferences-dialog-utils.c b/app/dialogs/preferences-dialog-utils.c index 8358474103..569c58ab1a 100644 --- a/app/dialogs/preferences-dialog-utils.c +++ b/app/dialogs/preferences-dialog-utils.c @@ -228,20 +228,23 @@ prefs_color_button_add (GObject *config, { GtkWidget *button; GParamSpec *pspec; - gboolean has_alpha; + gboolean has_alpha = TRUE; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (config), property_name); - has_alpha = gimp_param_spec_rgb_has_alpha (pspec); + /* TODO: GimpRGB parameter specs had an "alpha" argument, unlike GeglColor + * space. We need to add back such an argument. + */ + /*has_alpha = gimp_param_spec_rgb_has_alpha (pspec);*/ - button = gimp_prop_color_button_new (config, property_name, - title, - PREFS_COLOR_BUTTON_WIDTH, - PREFS_COLOR_BUTTON_HEIGHT, - has_alpha ? - GIMP_COLOR_AREA_SMALL_CHECKS : - GIMP_COLOR_AREA_FLAT); + button = gimp_prop_gegl_color_button_new (config, property_name, + title, + PREFS_COLOR_BUTTON_WIDTH, + PREFS_COLOR_BUTTON_HEIGHT, + has_alpha ? + GIMP_COLOR_AREA_SMALL_CHECKS : + GIMP_COLOR_AREA_FLAT); if (button) { diff --git a/app/display/gimpdisplayshell-appearance.c b/app/display/gimpdisplayshell-appearance.c index e2bd73c4dc..573be2efee 100644 --- a/app/display/gimpdisplayshell-appearance.c +++ b/app/display/gimpdisplayshell-appearance.c @@ -94,7 +94,7 @@ gimp_display_shell_appearance_update (GimpDisplayShell *shell) options->show_sample_points); gimp_display_shell_set_padding (shell, options->padding_mode, - &options->padding_color); + options->padding_color); gimp_display_shell_set_padding_in_show_all (shell, options->padding_in_show_all); } @@ -510,18 +510,19 @@ gimp_display_shell_get_snap_to_equidistance (GimpDisplayShell *shell) void gimp_display_shell_set_padding (GimpDisplayShell *shell, GimpCanvasPaddingMode padding_mode, - const GimpRGB *padding_color) + GeglColor *padding_color) { GimpImageWindow *window; GimpMenuModel *model; GimpDisplayOptions *options; - GimpRGB color; + GeglColor *color; + GimpRGB rgb; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); - g_return_if_fail (padding_color != NULL); + g_return_if_fail (GEGL_IS_COLOR (padding_color)); options = appearance_get_options (shell); - color = *padding_color; + color = gegl_color_duplicate (padding_color); switch (padding_mode) { @@ -529,11 +530,11 @@ gimp_display_shell_set_padding (GimpDisplayShell *shell, break; case GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK: - color = *gimp_render_check_color1 (); + gegl_color_set_pixel (color, babl_format ("R'G'B'A double"), gimp_render_check_color1 ()); break; case GIMP_CANVAS_PADDING_MODE_DARK_CHECK: - color = *gimp_render_check_color2 (); + gegl_color_set_pixel (color, babl_format ("R'G'B'A double"), gimp_render_check_color2 ()); break; case GIMP_CANVAS_PADDING_MODE_CUSTOM: @@ -543,26 +544,28 @@ gimp_display_shell_set_padding (GimpDisplayShell *shell, g_object_set (options, "padding-mode", padding_mode, - "padding-color", &color, + "padding-color", color, NULL); + gegl_color_get_pixel (color, babl_format ("R'G'B'A double"), &rgb); gimp_canvas_set_padding (GIMP_CANVAS (shell->canvas), - padding_mode, &color); + padding_mode, &rgb); window = gimp_display_shell_get_window (shell); model = gimp_image_window_get_menubar_model (window); + gegl_color_get_pixel (options->padding_color, babl_format ("R'G'B'A double"), &rgb); if (padding_mode != GIMP_CANVAS_PADDING_MODE_DEFAULT) - gimp_menu_model_set_color (model, "/View/Padding color", - &options->padding_color); + gimp_menu_model_set_color (model, "/View/Padding color", &rgb); else - gimp_menu_model_set_color (model, "/View/Padding color", - NULL); + gimp_menu_model_set_color (model, "/View/Padding color", NULL); + + g_object_unref (color); } void -gimp_display_shell_get_padding (GimpDisplayShell *shell, - GimpCanvasPaddingMode *padding_mode, - GimpRGB *padding_color) +gimp_display_shell_get_padding (GimpDisplayShell *shell, + GimpCanvasPaddingMode *padding_mode, + GeglColor **padding_color) { GimpDisplayOptions *options; diff --git a/app/display/gimpdisplayshell-appearance.h b/app/display/gimpdisplayshell-appearance.h index c3db7c69c5..53d4a92aa3 100644 --- a/app/display/gimpdisplayshell-appearance.h +++ b/app/display/gimpdisplayshell-appearance.h @@ -88,10 +88,10 @@ gboolean gimp_display_shell_get_snap_to_equidistance (GimpDisplayShell * void gimp_display_shell_set_padding (GimpDisplayShell *shell, GimpCanvasPaddingMode mode, - const GimpRGB *color); + GeglColor *color); void gimp_display_shell_get_padding (GimpDisplayShell *shell, GimpCanvasPaddingMode *mode, - GimpRGB *color); + GeglColor **color); void gimp_display_shell_set_padding_in_show_all (GimpDisplayShell *shell, gboolean keep); gboolean gimp_display_shell_get_padding_in_show_all (GimpDisplayShell *shell); diff --git a/app/display/gimpdisplayshell-callbacks.c b/app/display/gimpdisplayshell-callbacks.c index 2c5db59fc4..83497514b4 100644 --- a/app/display/gimpdisplayshell-callbacks.c +++ b/app/display/gimpdisplayshell-callbacks.c @@ -85,13 +85,13 @@ gimp_display_shell_canvas_realize (GtkWidget *canvas, GimpDisplayShell *shell) { GimpCanvasPaddingMode padding_mode; - GimpRGB padding_color; + GeglColor *padding_color; GtkAllocation allocation; gtk_widget_grab_focus (canvas); gimp_display_shell_get_padding (shell, &padding_mode, &padding_color); - gimp_display_shell_set_padding (shell, padding_mode, &padding_color); + gimp_display_shell_set_padding (shell, padding_mode, padding_color); gtk_widget_get_allocation (canvas, &allocation); diff --git a/app/display/gimpdisplayshell-handlers.c b/app/display/gimpdisplayshell-handlers.c index eb9a69c3b6..e023e59281 100644 --- a/app/display/gimpdisplayshell-handlers.c +++ b/app/display/gimpdisplayshell-handlers.c @@ -1051,8 +1051,8 @@ gimp_display_shell_check_notify_handler (GObject *config, GParamSpec *param_spec, GimpDisplayShell *shell) { - GimpCanvasPaddingMode padding_mode; - GimpRGB padding_color; + GimpCanvasPaddingMode padding_mode; + GeglColor *padding_color; g_clear_pointer (&shell->checkerboard, cairo_pattern_destroy); @@ -1062,7 +1062,7 @@ gimp_display_shell_check_notify_handler (GObject *config, { case GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK: case GIMP_CANVAS_PADDING_MODE_DARK_CHECK: - gimp_display_shell_set_padding (shell, padding_mode, &padding_color); + gimp_display_shell_set_padding (shell, padding_mode, padding_color); break; default: @@ -1127,7 +1127,7 @@ gimp_display_shell_padding_notify_handler (GObject *config, GimpImageWindow *window; gboolean fullscreen; GimpCanvasPaddingMode padding_mode; - GimpRGB padding_color; + GeglColor *padding_color; display_config = shell->display->config; @@ -1146,7 +1146,7 @@ gimp_display_shell_padding_notify_handler (GObject *config, if (fullscreen) { - gimp_display_shell_set_padding (shell, padding_mode, &padding_color); + gimp_display_shell_set_padding (shell, padding_mode, padding_color); } else { @@ -1168,7 +1168,7 @@ gimp_display_shell_padding_notify_handler (GObject *config, } else { - gimp_display_shell_set_padding (shell, padding_mode, &padding_color); + gimp_display_shell_set_padding (shell, padding_mode, padding_color); } } } diff --git a/app/gegl/gimp-gegl-nodes.c b/app/gegl/gimp-gegl-nodes.c index de8747e509..2f4dcc4218 100644 --- a/app/gegl/gimp-gegl-nodes.c +++ b/app/gegl/gimp-gegl-nodes.c @@ -236,20 +236,13 @@ gimp_gegl_node_set_matrix (GeglNode *node, } void -gimp_gegl_node_set_color (GeglNode *node, - const GimpRGB *color, - const Babl *space) +gimp_gegl_node_set_color (GeglNode *node, + GeglColor *color) { - GeglColor *gegl_color; - g_return_if_fail (GEGL_IS_NODE (node)); - g_return_if_fail (color != NULL); - - gegl_color = gimp_gegl_color_new (color, space); + g_return_if_fail (GEGL_IS_COLOR (color)); gegl_node_set (node, - "value", gegl_color, + "value", color, NULL); - - g_object_unref (gegl_color); } diff --git a/app/gegl/gimp-gegl-nodes.h b/app/gegl/gimp-gegl-nodes.h index 67a191a253..8dc3f3dd1f 100644 --- a/app/gegl/gimp-gegl-nodes.h +++ b/app/gegl/gimp-gegl-nodes.h @@ -47,8 +47,7 @@ void gimp_gegl_mode_node_set_opacity (GeglNode *node, void gimp_gegl_node_set_matrix (GeglNode *node, const GimpMatrix3 *matrix); void gimp_gegl_node_set_color (GeglNode *node, - const GimpRGB *color, - const Babl *space); + GeglColor *color); #endif /* __GIMP_GEGL_NODES_H__ */ diff --git a/app/pdb/channel-cmds.c b/app/pdb/channel-cmds.c index 71e0b0f1f6..3ec5452c3b 100644 --- a/app/pdb/channel-cmds.c +++ b/app/pdb/channel-cmds.c @@ -61,7 +61,7 @@ channel_new_invoker (GimpProcedure *procedure, gint height; const gchar *name; gdouble opacity; - GimpRGB color; + GeglColor *color; GimpChannel *channel = NULL; image = g_value_get_object (gimp_value_array_index (args, 0)); @@ -69,14 +69,12 @@ channel_new_invoker (GimpProcedure *procedure, height = g_value_get_int (gimp_value_array_index (args, 2)); name = g_value_get_string (gimp_value_array_index (args, 3)); opacity = g_value_get_double (gimp_value_array_index (args, 4)); - gimp_value_get_rgb (gimp_value_array_index (args, 5), &color); + color = g_value_get_object (gimp_value_array_index (args, 5)); if (success) { - GimpRGB rgb_color = color; - - rgb_color.a = opacity / 100.0; - channel = gimp_channel_new (image, width, height, name, &rgb_color); + gimp_color_set_alpha (color, opacity / 100.0); + channel = gimp_channel_new (image, width, height, name, color); if (! channel) success = FALSE; @@ -324,21 +322,21 @@ channel_get_color_invoker (GimpProcedure *procedure, gboolean success = TRUE; GimpValueArray *return_vals; GimpChannel *channel; - GimpRGB color = { 0.0, 0.0, 0.0, 1.0 }; + GeglColor *color = NULL; channel = g_value_get_object (gimp_value_array_index (args, 0)); if (success) { - gimp_channel_get_color (channel, &color); - gimp_rgb_set_alpha (&color, 1.0); + color = gimp_channel_get_color (channel); + gimp_color_set_alpha (color, 1.0); } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) - gimp_value_set_rgb (gimp_value_array_index (return_vals, 1), &color); + g_value_take_object (gimp_value_array_index (return_vals, 1), color); return return_vals; } @@ -353,17 +351,18 @@ channel_set_color_invoker (GimpProcedure *procedure, { gboolean success = TRUE; GimpChannel *channel; - GimpRGB color; + GeglColor *color; channel = g_value_get_object (gimp_value_array_index (args, 0)); - gimp_value_get_rgb (gimp_value_array_index (args, 1), &color); + color = g_value_get_object (gimp_value_array_index (args, 1)); if (success) { - GimpRGB rgb_color = color; + gdouble alpha; - rgb_color.a = channel->color.a; - gimp_channel_set_color (channel, &rgb_color, TRUE); + gegl_color_get_rgba (channel->color, NULL, NULL, NULL, &alpha); + gimp_color_set_alpha (color, alpha); + gimp_channel_set_color (channel, color, TRUE); } return gimp_procedure_get_return_values (procedure, success, @@ -423,12 +422,11 @@ register_channel_procs (GimpPDB *pdb) 0, 100, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_rgb ("color", - "color", - "The channel compositing color", - FALSE, - NULL, - GIMP_PARAM_READWRITE)); + gegl_param_spec_color ("color", + "color", + "The channel compositing color", + NULL, + GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_channel ("channel", "channel", @@ -697,12 +695,11 @@ register_channel_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_rgb ("color", - "color", - "The channel compositing color", - FALSE, - NULL, - GIMP_PARAM_READWRITE)); + gegl_param_spec_color ("color", + "color", + "The channel compositing color", + NULL, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -727,12 +724,11 @@ register_channel_procs (GimpPDB *pdb) FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, - gimp_param_spec_rgb ("color", - "color", - "The new channel compositing color", - FALSE, - NULL, - GIMP_PARAM_READWRITE)); + gegl_param_spec_color ("color", + "color", + "The new channel compositing color", + NULL, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); } diff --git a/app/tests/test-xcf.c b/app/tests/test-xcf.c index 019077911c..cd01c796b5 100644 --- a/app/tests/test-xcf.c +++ b/app/tests/test-xcf.c @@ -378,14 +378,16 @@ gimp_create_mainimage (Gimp *gimp, GimpParasite *parasite = NULL; GimpGrid *grid = NULL; GimpChannel *channel = NULL; - GimpRGB channel_color = GIMP_MAINIMAGE_CHANNEL1_COLOR; + GeglColor *channel_color = gegl_color_new (NULL); GimpChannel *selection = NULL; GimpVectors *vectors = NULL; GimpCoords vectors1_coords[] = GIMP_MAINIMAGE_VECTORS1_COORDS; GimpCoords vectors2_coords[] = GIMP_MAINIMAGE_VECTORS2_COORDS; GimpStroke *stroke = NULL; GimpLayerMask *layer_mask = NULL; + gdouble rgb[4] = GIMP_MAINIMAGE_CHANNEL1_COLOR; + gegl_color_set_pixel (channel_color, babl_format ("R'G'B'A double"), &rgb); /* Image size and type */ image = gimp_image_new (gimp, GIMP_MAINIMAGE_WIDTH, @@ -504,7 +506,8 @@ gimp_create_mainimage (Gimp *gimp, GIMP_MAINIMAGE_CHANNEL1_WIDTH, GIMP_MAINIMAGE_CHANNEL1_HEIGHT, GIMP_MAINIMAGE_CHANNEL1_NAME, - &channel_color); + channel_color); + g_object_unref (channel_color); gimp_image_add_channel (image, channel, NULL, @@ -744,8 +747,9 @@ gimp_assert_mainimage (GimpImage *image, gdouble xspacing = 0.0; gdouble yspacing = 0.0; GimpChannel *channel = NULL; - GimpRGB expected_channel_color = GIMP_MAINIMAGE_CHANNEL1_COLOR; - GimpRGB actual_channel_color = { 0, }; + GeglColor *actual_channel_color; + gdouble expected_rgb_color[4] = GIMP_MAINIMAGE_CHANNEL1_COLOR; + gdouble rgb[4]; GimpChannel *selection = NULL; gint x = -1; gint y = -1; @@ -919,16 +923,15 @@ gimp_assert_mainimage (GimpImage *image, /* Channel */ channel = gimp_image_get_channel_by_name (image, GIMP_MAINIMAGE_CHANNEL1_NAME); - gimp_channel_get_color (channel, &actual_channel_color); + actual_channel_color = gimp_channel_get_color (channel); g_assert_cmpint (gimp_item_get_width (GIMP_ITEM (channel)), ==, GIMP_MAINIMAGE_CHANNEL1_WIDTH); g_assert_cmpint (gimp_item_get_height (GIMP_ITEM (channel)), ==, GIMP_MAINIMAGE_CHANNEL1_HEIGHT); - g_assert_true (memcmp (&expected_channel_color, - &actual_channel_color, - sizeof (GimpRGB)) == 0); + gegl_color_get_pixel (actual_channel_color, babl_format ("R'G'B'A double"), &rgb); + g_assert_true (memcmp (&expected_rgb_color, &rgb, sizeof (expected_rgb_color)) == 0); /* Selection, if the image contains unusual stuff it contains a * floating select, and when floating a selection, the selection diff --git a/app/widgets/gimpchanneltreeview.c b/app/widgets/gimpchanneltreeview.c index f0b25422d7..044dd1a4a9 100644 --- a/app/widgets/gimpchanneltreeview.c +++ b/app/widgets/gimpchanneltreeview.c @@ -320,17 +320,17 @@ static GimpItem * gimp_channel_tree_view_item_new (GimpImage *image) { GimpChannel *new_channel; - GimpRGB color; - - gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.5); + GeglColor *color = gegl_color_new ("black"); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, _("New Channel")); + gimp_color_set_alpha (color, 0.5); new_channel = gimp_channel_new (image, gimp_image_get_width (image), gimp_image_get_height (image), - _("Channel"), &color); + _("Channel"), color); + g_object_unref (color); gimp_image_add_channel (image, new_channel, GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE); diff --git a/app/xcf/xcf-load.c b/app/xcf/xcf-load.c index 686a2177ca..8edddce092 100644 --- a/app/xcf/xcf-load.c +++ b/app/xcf/xcf-load.c @@ -2278,7 +2278,7 @@ xcf_load_channel_props (XcfInfo *info, xcf_read_int8 (info, (guint8 *) col, 3); - gimp_rgb_set_uchar (&(*channel)->color, col[0], col[1], col[2]); + gegl_color_set_pixel ((*channel)->color, babl_format ("R'G'B' u8"), col); } break; @@ -2288,7 +2288,8 @@ xcf_load_channel_props (XcfInfo *info, xcf_read_float (info, col, 3); - gimp_rgb_set (&(*channel)->color, col[0], col[1], col[2]); + /* TODO: is the channel color in sRGB or in the image's color space? */ + gegl_color_set_pixel ((*channel)->color, babl_format ("R'G'B' float"), col); } break; @@ -3119,7 +3120,6 @@ xcf_load_channel (XcfInfo *info, gint height; gboolean is_fs_drawable; gchar *name; - GimpRGB color = { 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE }; goffset cur_offset; /* check and see if this is the drawable the floating selection @@ -3142,7 +3142,7 @@ xcf_load_channel (XcfInfo *info, width, height, name); /* create a new channel */ - channel = gimp_channel_new (image, width, height, name, &color); + channel = gimp_channel_new (image, width, height, name, NULL); g_free (name); if (!channel) return NULL; diff --git a/app/xcf/xcf-save.c b/app/xcf/xcf-save.c index e5e657463c..367b9e5b30 100644 --- a/app/xcf/xcf-save.c +++ b/app/xcf/xcf-save.c @@ -794,9 +794,9 @@ xcf_save_channel_props (XcfInfo *info, xcf_check_error (xcf_save_prop (info, image, PROP_SHOW_MASKED, error, gimp_channel_get_show_masked (channel)), ;); xcf_check_error (xcf_save_prop (info, image, PROP_COLOR, error, - &channel->color), ;); + channel->color), ;); xcf_check_error (xcf_save_prop (info, image, PROP_FLOAT_COLOR, error, - &channel->color), ;); + channel->color), ;); xcf_check_error (xcf_save_prop (info, image, PROP_TATTOO, error, gimp_item_get_tattoo (GIMP_ITEM (channel))), ;); @@ -1321,10 +1321,10 @@ xcf_save_prop (XcfInfo *info, case PROP_COLOR: { - GimpRGB *color = va_arg (args, GimpRGB *); - guchar col[3]; + GeglColor *color = va_arg (args, GeglColor *); + guchar col[3]; - gimp_rgb_get_uchar (color, &col[0], &col[1], &col[2]); + gegl_color_get_pixel (color, babl_format ("R'G'B' u8"), col); size = 3; @@ -1337,12 +1337,10 @@ xcf_save_prop (XcfInfo *info, case PROP_FLOAT_COLOR: { - GimpRGB *color = va_arg (args, GimpRGB *); - gfloat col[3]; + GeglColor *color = va_arg (args, GeglColor *); + gfloat col[3]; - col[0] = color->r; - col[1] = color->g; - col[2] = color->b; + gegl_color_get_pixel (color, babl_format ("R'G'B' float"), col); size = 3 * 4; diff --git a/libgimp/gimpchannel.c b/libgimp/gimpchannel.c index 7b5087891b..cdd955855c 100644 --- a/libgimp/gimpchannel.c +++ b/libgimp/gimpchannel.c @@ -87,12 +87,12 @@ gimp_channel_get_by_id (gint32 channel_id) * The object belongs to libgimp and you should not free it. */ GimpChannel * -gimp_channel_new (GimpImage *image, - const gchar *name, - guint width, - guint height, - gdouble opacity, - const GimpRGB *color) +gimp_channel_new (GimpImage *image, + const gchar *name, + guint width, + guint height, + gdouble opacity, + GeglColor *color) { return _gimp_channel_new (image, width, diff --git a/libgimp/gimpchannel.h b/libgimp/gimpchannel.h index fb5dd22d47..79867e8e1b 100644 --- a/libgimp/gimpchannel.h +++ b/libgimp/gimpchannel.h @@ -52,14 +52,14 @@ struct _GimpChannelClass }; -GimpChannel * gimp_channel_get_by_id (gint32 channel_id); +GimpChannel * gimp_channel_get_by_id (gint32 channel_id); -GimpChannel * gimp_channel_new (GimpImage *image, - const gchar *name, - guint width, - guint height, - gdouble opacity, - const GimpRGB *color); +GimpChannel * gimp_channel_new (GimpImage *image, + const gchar *name, + guint width, + guint height, + gdouble opacity, + GeglColor *color); G_END_DECLS diff --git a/libgimp/gimpchannel_pdb.c b/libgimp/gimpchannel_pdb.c index b914eccf8a..44cb78a21c 100644 --- a/libgimp/gimpchannel_pdb.c +++ b/libgimp/gimpchannel_pdb.c @@ -58,12 +58,12 @@ * Returns: (transfer none): The newly created channel. **/ GimpChannel * -_gimp_channel_new (GimpImage *image, - gint width, - gint height, - const gchar *name, - gdouble opacity, - const GimpRGB *color) +_gimp_channel_new (GimpImage *image, + gint width, + gint height, + const gchar *name, + gdouble opacity, + GeglColor *color) { GimpValueArray *args; GimpValueArray *return_vals; @@ -75,7 +75,7 @@ _gimp_channel_new (GimpImage *image, G_TYPE_INT, height, G_TYPE_STRING, name, G_TYPE_DOUBLE, opacity, - GIMP_TYPE_RGB, color, + GEGL_TYPE_COLOR, color, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), @@ -366,21 +366,19 @@ gimp_channel_set_opacity (GimpChannel *channel, /** * gimp_channel_get_color: * @channel: The channel. - * @color: (out caller-allocates): The channel compositing color. * * Get the compositing color of the specified channel. * * This procedure returns the specified channel's compositing color. * - * Returns: TRUE on success. + * Returns: (transfer full): The channel compositing color. **/ -gboolean -gimp_channel_get_color (GimpChannel *channel, - GimpRGB *color) +GeglColor * +gimp_channel_get_color (GimpChannel *channel) { GimpValueArray *args; GimpValueArray *return_vals; - gboolean success = TRUE; + GeglColor *color = NULL; args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_CHANNEL, channel, @@ -391,14 +389,12 @@ gimp_channel_get_color (GimpChannel *channel, args); gimp_value_array_unref (args); - success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS; - - if (success) - GIMP_VALUES_GET_RGB (return_vals, 1, &*color); + if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) + color = g_value_dup_object (gimp_value_array_index (return_vals, 1)); gimp_value_array_unref (return_vals); - return success; + return color; } /** @@ -413,8 +409,8 @@ gimp_channel_get_color (GimpChannel *channel, * Returns: TRUE on success. **/ gboolean -gimp_channel_set_color (GimpChannel *channel, - const GimpRGB *color) +gimp_channel_set_color (GimpChannel *channel, + GeglColor *color) { GimpValueArray *args; GimpValueArray *return_vals; @@ -422,7 +418,7 @@ gimp_channel_set_color (GimpChannel *channel, args = gimp_value_array_new_from_types (NULL, GIMP_TYPE_CHANNEL, channel, - GIMP_TYPE_RGB, color, + GEGL_TYPE_COLOR, color, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), diff --git a/libgimp/gimpchannel_pdb.h b/libgimp/gimpchannel_pdb.h index d963035a57..d6ad14d9ad 100644 --- a/libgimp/gimpchannel_pdb.h +++ b/libgimp/gimpchannel_pdb.h @@ -37,7 +37,7 @@ G_GNUC_INTERNAL GimpChannel* _gimp_channel_new (GimpImage *i gint height, const gchar *name, gdouble opacity, - const GimpRGB *color); + GeglColor *color); GimpChannel* gimp_channel_new_from_component (GimpImage *image, GimpChannelType component, const gchar *name); @@ -53,10 +53,9 @@ gboolean gimp_channel_set_show_masked (GimpChannel *c gdouble gimp_channel_get_opacity (GimpChannel *channel); gboolean gimp_channel_set_opacity (GimpChannel *channel, gdouble opacity); -gboolean gimp_channel_get_color (GimpChannel *channel, - GimpRGB *color); +GeglColor* gimp_channel_get_color (GimpChannel *channel); gboolean gimp_channel_set_color (GimpChannel *channel, - const GimpRGB *color); + GeglColor *color); G_END_DECLS diff --git a/pdb/groups/channel.pdb b/pdb/groups/channel.pdb index 0e163af437..60da102b40 100644 --- a/pdb/groups/channel.pdb +++ b/pdb/groups/channel.pdb @@ -46,7 +46,7 @@ HELP desc => 'The channel name' }, { name => 'opacity', type => '0 <= float <= 100', desc => 'The channel opacity' }, - { name => 'color', type => 'color', + { name => 'color', type => 'geglcolor', desc => 'The channel compositing color' } ); @@ -59,10 +59,8 @@ HELP %invoke = ( code => <<'CODE' { - GimpRGB rgb_color = color; - - rgb_color.a = opacity / 100.0; - channel = gimp_channel_new (image, width, height, name, &rgb_color); + gimp_color_set_alpha (color, opacity / 100.0); + channel = gimp_channel_new (image, width, height, name, color); if (! channel) success = FALSE; @@ -323,15 +321,15 @@ HELP ); @outargs = ( - { name => 'color', type => 'color', void_ret => 1, + { name => 'color', type => 'geglcolor', desc => 'The channel compositing color' } ); %invoke = ( code => <<'CODE' { - gimp_channel_get_color (channel, &color); - gimp_rgb_set_alpha (&color, 1.0); + color = gimp_channel_get_color (channel); + gimp_color_set_alpha (color, 1.0); } CODE ); @@ -349,24 +347,27 @@ HELP @inargs = ( { name => 'channel', type => 'channel', desc => 'The channel' }, - { name => 'color', type => 'color', + { name => 'color', type => 'geglcolor', desc => 'The new channel compositing color' } ); %invoke = ( code => <<'CODE' { - GimpRGB rgb_color = color; + gdouble alpha; - rgb_color.a = channel->color.a; - gimp_channel_set_color (channel, &rgb_color, TRUE); + gegl_color_get_rgba (channel->color, NULL, NULL, NULL, &alpha); + gimp_color_set_alpha (color, alpha); + gimp_channel_set_color (channel, color, TRUE); } CODE ); } -@headers = qw("libgimpbase/gimpbase.h"); +@headers = qw( + "libgimpbase/gimpbase.h" + "libgimpcolor/gimpcolor.h"); @procs = qw(channel_new channel_new_from_component diff --git a/plug-ins/file-psd/psd-image-res-load.c b/plug-ins/file-psd/psd-image-res-load.c index c1dd69f953..72bc66ebd2 100644 --- a/plug-ins/file-psd/psd-image-res-load.c +++ b/plug-ins/file-psd/psd-image-res-load.c @@ -680,9 +680,6 @@ load_resource_1007 (const PSDimageres *res_a, DisplayInfo dsp_info; CMColor ps_color; - GimpRGB gimp_rgb; - GimpHSV gimp_hsv; - GimpCMYK gimp_cmyk; gint16 tot_rec; gint cidx; @@ -695,6 +692,8 @@ load_resource_1007 (const PSDimageres *res_a, img_a->alpha_display_count = tot_rec; for (cidx = 0; cidx < tot_rec; ++cidx) { + GeglColor *color; + if (psd_read (input, &dsp_info.colorSpace, 2, error) < 2 || psd_read (input, &dsp_info.color, 8, error) < 8 || psd_read (input, &dsp_info.opacity, 2, error) < 2 || @@ -711,33 +710,49 @@ load_resource_1007 (const PSDimageres *res_a, ps_color.cmyk.black = GUINT16_FROM_BE (dsp_info.color[3]); dsp_info.opacity = GINT16_FROM_BE (dsp_info.opacity); + color = gegl_color_new ("red"); + switch (dsp_info.colorSpace) { case PSD_CS_RGB: - gimp_rgb_set (&gimp_rgb, ps_color.rgb.red / 65535.0, - ps_color.rgb.green / 65535.0, - ps_color.rgb.blue / 65535.0); + /* TODO: which space should we use? */ + gegl_color_set_rgba_with_space (color, + ps_color.rgb.red / 65535.0, + ps_color.rgb.green / 65535.0, + ps_color.rgb.blue / 65535.0, + 1.0, NULL); break; case PSD_CS_HSB: - gimp_hsv_set (&gimp_hsv, ps_color.hsv.hue / 65535.0, - ps_color.hsv.saturation / 65535.0, - ps_color.hsv.value / 65535.0); - gimp_hsv_to_rgb (&gimp_hsv, &gimp_rgb); - break; + { + gdouble hsv[3] = + { + ps_color.hsv.hue / 65535.0, + ps_color.hsv.saturation / 65535.0, + ps_color.hsv.value / 65535.0 + }; + + gegl_color_set_pixel (color, babl_format ("HSV double"), hsv); + } + break; case PSD_CS_CMYK: - gimp_cmyk_set (&gimp_cmyk, 1.0 - ps_color.cmyk.cyan / 65535.0, - 1.0 - ps_color.cmyk.magenta / 65535.0, - 1.0 - ps_color.cmyk.yellow / 65535.0, - 1.0 - ps_color.cmyk.black / 65535.0); - gimp_cmyk_to_rgb (&gimp_cmyk, &gimp_rgb); + /* TODO: again, which space? */ + gegl_color_set_cmyk (color, + 1.0 - ps_color.cmyk.cyan / 65535.0, + 1.0 - ps_color.cmyk.magenta / 65535.0, + 1.0 - ps_color.cmyk.yellow / 65535.0, + 1.0 - ps_color.cmyk.black / 65535.0, + 1.0, NULL); break; case PSD_CS_GRAYSCALE: - gimp_rgb_set (&gimp_rgb, ps_color.gray.gray / 10000.0, - ps_color.gray.gray / 10000.0, - ps_color.gray.gray / 10000.0); + { + gdouble gray = ps_color.gray.gray / 10000.0; + + /* TODO: which space? */ + gegl_color_set_pixel (color, babl_format_with_space ("Y' double", NULL), &gray); + } break; case PSD_CS_FOCOLTONE: @@ -752,22 +767,18 @@ load_resource_1007 (const PSDimageres *res_a, if (CONVERSION_WARNINGS) g_message ("Unsupported color space: %d", dsp_info.colorSpace); - gimp_rgb_set (&gimp_rgb, 1.0, 0.0, 0.0); } - gimp_rgb_set_alpha (&gimp_rgb, 1.0); - IFDBG(2) g_debug ("PS cSpace: %d, col: %d %d %d %d, opacity: %d, kind: %d", dsp_info.colorSpace, ps_color.cmyk.cyan, ps_color.cmyk.magenta, ps_color.cmyk.yellow, ps_color.cmyk.black, dsp_info.opacity, dsp_info.kind); - IFDBG(2) g_debug ("cSpace: %d, col: %g %g %g, opacity: %d, kind: %d", - dsp_info.colorSpace, gimp_rgb.r * 255 , gimp_rgb.g * 255, - gimp_rgb.b * 255, dsp_info.opacity, dsp_info.kind); + IFDBG(2) g_debug ("cSpace: %d, opacity: %d, kind: %d", + dsp_info.colorSpace, dsp_info.opacity, dsp_info.kind); img_a->alpha_display_info[cidx] = g_malloc0 (sizeof (PSDchanneldata)); - img_a->alpha_display_info[cidx]->gimp_color = gimp_rgb; + img_a->alpha_display_info[cidx]->gimp_color = color; img_a->alpha_display_info[cidx]->opacity = dsp_info.opacity; img_a->alpha_display_info[cidx]->ps_kind = dsp_info.kind; img_a->alpha_display_info[cidx]->ps_cspace = dsp_info.colorSpace; @@ -1400,9 +1411,6 @@ load_resource_1077 (const PSDimageres *res_a, DisplayInfoNew dsp_info; CMColor ps_color; - GimpRGB gimp_rgb; - GimpHSV gimp_hsv; - GimpCMYK gimp_cmyk; gint16 tot_rec; gint cidx; @@ -1421,6 +1429,8 @@ load_resource_1077 (const PSDimageres *res_a, img_a->alpha_display_count = tot_rec; for (cidx = 0; cidx < tot_rec; ++cidx) { + GeglColor *color; + if (psd_read (input, &dsp_info.colorSpace, 2, error) < 2 || psd_read (input, &dsp_info.color, 8, error) < 8 || psd_read (input, &dsp_info.opacity, 2, error) < 2 || @@ -1436,33 +1446,49 @@ load_resource_1077 (const PSDimageres *res_a, ps_color.cmyk.black = GUINT16_FROM_BE (dsp_info.color[3]); dsp_info.opacity = GINT16_FROM_BE (dsp_info.opacity); + color = gegl_color_new ("red"); + switch (dsp_info.colorSpace) { case PSD_CS_RGB: - gimp_rgb_set (&gimp_rgb, ps_color.rgb.red / 65535.0, - ps_color.rgb.green / 65535.0, - ps_color.rgb.blue / 65535.0); + /* TODO: which space? */ + gegl_color_set_rgba_with_space (color, + ps_color.rgb.red / 65535.0, + ps_color.rgb.green / 65535.0, + ps_color.rgb.blue / 65535.0, + 1.0, NULL); break; case PSD_CS_HSB: - gimp_hsv_set (&gimp_hsv, ps_color.hsv.hue / 65535.0, - ps_color.hsv.saturation / 65535.0, - ps_color.hsv.value / 65535.0); - gimp_hsv_to_rgb (&gimp_hsv, &gimp_rgb); + { + gdouble hsv[3] = + { + ps_color.hsv.hue / 65535.0, + ps_color.hsv.saturation / 65535.0, + ps_color.hsv.value / 65535.0 + }; + + gegl_color_set_pixel (color, babl_format ("HSV double"), hsv); + } break; case PSD_CS_CMYK: - gimp_cmyk_set (&gimp_cmyk, 1.0 - ps_color.cmyk.cyan / 65535.0, - 1.0 - ps_color.cmyk.magenta / 65535.0, - 1.0 - ps_color.cmyk.yellow / 65535.0, - 1.0 - ps_color.cmyk.black / 65535.0); - gimp_cmyk_to_rgb (&gimp_cmyk, &gimp_rgb); + /* TODO: which space? */ + gegl_color_set_cmyk (color, + 1.0 - ps_color.cmyk.cyan / 65535.0, + 1.0 - ps_color.cmyk.magenta / 65535.0, + 1.0 - ps_color.cmyk.yellow / 65535.0, + 1.0 - ps_color.cmyk.black / 65535.0, + 1.0, NULL); break; case PSD_CS_GRAYSCALE: - gimp_rgb_set (&gimp_rgb, ps_color.gray.gray / 10000.0, - ps_color.gray.gray / 10000.0, - ps_color.gray.gray / 10000.0); + { + gdouble gray = ps_color.gray.gray / 10000.0; + + /* TODO: which space? */ + gegl_color_set_pixel (color, babl_format_with_space ("Y' double", NULL), &gray); + } break; case PSD_CS_FOCOLTONE: @@ -1477,22 +1503,18 @@ load_resource_1077 (const PSDimageres *res_a, if (CONVERSION_WARNINGS) g_message ("Unsupported color space: %d", dsp_info.colorSpace); - gimp_rgb_set (&gimp_rgb, 1.0, 0.0, 0.0); } - gimp_rgb_set_alpha (&gimp_rgb, 1.0); - IFDBG(2) g_debug ("PS cSpace: %d, col: %d %d %d %d, opacity: %d, mode: %d", dsp_info.colorSpace, ps_color.cmyk.cyan, ps_color.cmyk.magenta, ps_color.cmyk.yellow, ps_color.cmyk.black, dsp_info.opacity, dsp_info.mode); - IFDBG(2) g_debug ("cSpace: %d, col: %g %g %g, opacity: %d, mode: %d", - dsp_info.colorSpace, gimp_rgb.r * 255 , gimp_rgb.g * 255, - gimp_rgb.b * 255, dsp_info.opacity, dsp_info.mode); + IFDBG(2) g_debug ("cSpace: %d, opacity: %d, mode: %d", + dsp_info.colorSpace, dsp_info.opacity, dsp_info.mode); img_a->alpha_display_info[cidx] = g_malloc0 (sizeof (PSDchanneldata)); - img_a->alpha_display_info[cidx]->gimp_color = gimp_rgb; + img_a->alpha_display_info[cidx]->gimp_color = color; img_a->alpha_display_info[cidx]->opacity = dsp_info.opacity; img_a->alpha_display_info[cidx]->ps_mode = dsp_info.mode; img_a->alpha_display_info[cidx]->ps_cspace = dsp_info.colorSpace; diff --git a/plug-ins/file-psd/psd-load.c b/plug-ins/file-psd/psd-load.c index e449bd2452..f3cc97c4a1 100644 --- a/plug-ins/file-psd/psd-load.c +++ b/plug-ins/file-psd/psd-load.c @@ -2577,7 +2577,7 @@ add_merged_image (GimpImage *image, gboolean original_mode_CMYK = FALSE; GeglBuffer *buffer; GimpImageType image_type; - GimpRGB alpha_rgb; + GeglColor *alpha_rgb; total_channels = img_a->channels; extra_channels = 0; @@ -2930,12 +2930,12 @@ add_merged_image (GimpImage *image, if (offset < img_a->alpha_display_count && i + offset <= img_a->alpha_display_count) { - alpha_rgb = img_a->alpha_display_info[i + offset]->gimp_color; + alpha_rgb = gegl_color_duplicate (img_a->alpha_display_info[i + offset]->gimp_color); alpha_opacity = img_a->alpha_display_info[i + offset]->opacity; } else { - gimp_rgba_set (&alpha_rgb, 1.0, 0.0, 0.0, 1.0); + alpha_rgb = gegl_color_new ("red"); alpha_opacity = 50; } @@ -2944,8 +2944,9 @@ add_merged_image (GimpImage *image, memcpy (pixels, chn_a[cidx].data, chn_a[cidx].columns * chn_a[cidx].rows * bps); channel = gimp_channel_new (image, alpha_name, chn_a[cidx].columns, chn_a[cidx].rows, - alpha_opacity, &alpha_rgb); + alpha_opacity, alpha_rgb); gimp_image_insert_channel (image, channel, NULL, i); + g_object_unref (alpha_rgb); g_free (alpha_name); buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)); if (alpha_id) @@ -2971,7 +2972,10 @@ add_merged_image (GimpImage *image, if (img_a->alpha_display_info) { for (cidx = 0; cidx < img_a->alpha_display_count; ++cidx) - g_free (img_a->alpha_display_info[cidx]); + { + g_clear_object (&img_a->alpha_display_info[cidx]->gimp_color); + g_free (img_a->alpha_display_info[cidx]); + } g_free (img_a->alpha_display_info); } } diff --git a/plug-ins/file-psd/psd-save.c b/plug-ins/file-psd/psd-save.c index 6708136fcc..ed5d8ce90f 100644 --- a/plug-ins/file-psd/psd-save.c +++ b/plug-ins/file-psd/psd-save.c @@ -802,19 +802,24 @@ save_resources (GOutputStream *output, for (iter = PSDImageData.lChannels; iter; iter = g_list_next (iter)) { GimpChannel *channel = iter->data; - GimpRGB color; + GeglColor *color; + gdouble rgb[3]; gdouble opacity; - gimp_channel_get_color (channel, &color); + color = gimp_channel_get_color (channel); opacity = gimp_channel_get_opacity (channel); - write_gint16 (output, PSD_CS_RGB, "channel color space"); - write_gint16 (output, DOUBLE_TO_INT16 (color.r), "channel color r"); - write_gint16 (output, DOUBLE_TO_INT16 (color.g), "channel color g"); - write_gint16 (output, DOUBLE_TO_INT16 (color.b), "channel color b"); - write_gint16 (output, 0, "channel color padding"); - write_gint16 (output, ROUND (opacity), "channel opacity"); - write_gchar (output, 1, "channel mode"); + gegl_color_get_pixel (color, babl_format ("R'G'B' double"), rgb); + + write_gint16 (output, PSD_CS_RGB, "channel color space"); + write_gint16 (output, DOUBLE_TO_INT16 (rgb[0]), "channel color r"); + write_gint16 (output, DOUBLE_TO_INT16 (rgb[1]), "channel color g"); + write_gint16 (output, DOUBLE_TO_INT16 (rgb[2]), "channel color b"); + write_gint16 (output, 0, "channel color padding"); + write_gint16 (output, ROUND (opacity), "channel opacity"); + write_gchar (output, 1, "channel mode"); + + g_object_unref (color); } #undef DOUBLE_TO_INT16 diff --git a/plug-ins/file-psd/psd.h b/plug-ins/file-psd/psd.h index 057c7bf018..9c41ca8bf1 100644 --- a/plug-ins/file-psd/psd.h +++ b/plug-ins/file-psd/psd.h @@ -642,7 +642,7 @@ typedef struct /* PSD Channel data structure */ typedef struct { - GimpRGB gimp_color; /* Gimp RGB color */ + GeglColor *gimp_color; /* Gimp RGB color */ gint16 opacity; /* Opacity */ guchar ps_mode; /* PS mode flag */ guchar ps_kind; /* PS type flag */ diff --git a/plug-ins/file-tiff/file-tiff-load.c b/plug-ins/file-tiff/file-tiff-load.c index f5d0951df2..98fb72c11d 100644 --- a/plug-ins/file-tiff/file-tiff-load.c +++ b/plug-ins/file-tiff/file-tiff-load.c @@ -1560,13 +1560,11 @@ load_image (GFile *file, /* Add extra channels as appropriate */ for (i = 1; i <= extra; i++) { - GimpRGB color; - - gimp_rgb_set (&color, 0.0, 0.0, 0.0); + GeglColor *color = gegl_color_new ("black"); channel[i].drawable = GIMP_DRAWABLE (gimp_channel_new (*image, _("TIFF Channel"), - cols, rows, - 100.0, &color)); + cols, rows, 100.0, color)); + g_object_unref (color); gimp_image_insert_channel (*image, GIMP_CHANNEL (channel[i].drawable), NULL, 0); channel[i].buffer = gimp_drawable_get_buffer (channel[i].drawable);