From f18266cb04e0be26cf24a049330cb9d33a246e35 Mon Sep 17 00:00:00 2001 From: Jehan Date: Mon, 13 Nov 2023 23:29:20 +0100 Subject: [PATCH] app, libgimp, pdb, plug-ins: gimp_context_[gs]et_foreground() now using GeglColor. Also the color is internally stored as GeglColor, though there are still get APIs and signals using GimpRGB. The equivalent PDB functions are also changed to use GeglColor, same as app/ functions. --- app/actions/context-commands.c | 187 ++++++++++++++++----------- app/core/gimpcontext.c | 105 +++++++++------ app/core/gimpcontext.h | 8 +- app/core/gimpdrawable-bucket-fill.c | 6 +- app/core/gimpfilloptions.c | 19 ++- app/display/gimpdisplayshell-dnd.c | 5 +- app/pdb/context-cmds.c | 38 +++--- app/tools/gimpcolortool.c | 7 +- app/tools/gimptextoptions.c | 7 +- app/widgets/gimpcoloreditor.c | 39 ++++-- app/widgets/gimpcolormapeditor.c | 32 +++-- app/widgets/gimpdrawabletreeview.c | 12 +- app/widgets/gimpfgbgeditor.c | 7 +- app/widgets/gimpgradienteditor.c | 21 +-- app/widgets/gimppaletteeditor.c | 8 +- app/widgets/gimptoolbox-color-area.c | 14 +- libgimp/gimpcontext_pdb.c | 8 +- libgimp/gimpcontext_pdb.h | 4 +- pdb/groups/context.pdb | 12 +- plug-ins/common/border-average.c | 8 +- plug-ins/common/film.c | 9 +- plug-ins/gfig/gfig-style.c | 9 +- 22 files changed, 359 insertions(+), 206 deletions(-) diff --git a/app/actions/context-commands.c b/app/actions/context-commands.c index 5bd2899347..c1294ed753 100644 --- a/app/actions/context-commands.c +++ b/app/actions/context-commands.c @@ -110,16 +110,19 @@ context_##name##_##fgbg##ground_cmd_callback (GimpAction *action, \ gpointer data) \ { \ GimpContext *context; \ - GimpRGB color; \ + GimpRGB rgb; \ + GeglColor *color = gegl_color_new ("black"); \ GimpActionSelectType select_type; \ return_if_no_context (context, data); \ \ select_type = (GimpActionSelectType) g_variant_get_int32 (value); \ \ - gimp_context_get_##fgbg##ground (context, &color); \ - context_select_color (select_type, &color, \ + gimp_context_get_##fgbg##ground (context, &rgb); \ + context_select_color (select_type, &rgb, \ use_colormap, use_palette); \ - gimp_context_set_##fgbg##ground (context, &color); \ + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); \ + gimp_context_set_##fgbg##ground (context, color); \ + g_object_unref (color); \ } SELECT_COLOR_CMD_CALLBACK (palette, fore, FALSE, TRUE) @@ -135,18 +138,21 @@ context_foreground_red_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_foreground (context, &color); - color.r = action_select_value (select_type, - color.r, + gimp_context_get_foreground (context, &rgb); + rgb.r = action_select_value (select_type, + rgb.r, 0.0, 1.0, 1.0, 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); - gimp_context_set_foreground (context, &color); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_foreground (context, color); + g_object_unref (color); } void @@ -155,18 +161,21 @@ context_foreground_green_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_foreground (context, &color); - color.g = action_select_value (select_type, - color.g, - 0.0, 1.0, 1.0, - 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); - gimp_context_set_foreground (context, &color); + gimp_context_get_foreground (context, &rgb); + rgb.g = action_select_value (select_type, + rgb.g, + 0.0, 1.0, 1.0, + 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_foreground (context, color); + g_object_unref (color); } void @@ -175,18 +184,21 @@ context_foreground_blue_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_foreground (context, &color); - color.b = action_select_value (select_type, - color.b, - 0.0, 1.0, 1.0, - 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); - gimp_context_set_foreground (context, &color); + gimp_context_get_foreground (context, &rgb); + rgb.b = action_select_value (select_type, + rgb.b, + 0.0, 1.0, 1.0, + 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_foreground (context, color); + g_object_unref (color); } void @@ -195,18 +207,21 @@ context_background_red_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_background (context, &color); - color.r = action_select_value (select_type, - color.r, - 0.0, 1.0, 1.0, - 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); - gimp_context_set_background (context, &color); + gimp_context_get_background (context, &rgb); + rgb.r = action_select_value (select_type, + rgb.r, + 0.0, 1.0, 1.0, + 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_background (context, color); + g_object_unref (color); } void @@ -215,18 +230,21 @@ context_background_green_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_background (context, &color); - color.g = action_select_value (select_type, - color.g, - 0.0, 1.0, 1.0, - 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); - gimp_context_set_background (context, &color); + gimp_context_get_background (context, &rgb); + rgb.g = action_select_value (select_type, + rgb.g, + 0.0, 1.0, 1.0, + 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_background (context, color); + g_object_unref (color); } void @@ -235,18 +253,21 @@ context_background_blue_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_background (context, &color); - color.b = action_select_value (select_type, - color.b, - 0.0, 1.0, 1.0, - 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); - gimp_context_set_background (context, &color); + gimp_context_get_background (context, &rgb); + rgb.b = action_select_value (select_type, + rgb.b, + 0.0, 1.0, 1.0, + 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_background (context, color); + g_object_unref (color); } void @@ -255,21 +276,24 @@ context_foreground_hue_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpHSV hsv; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_foreground (context, &color); - gimp_rgb_to_hsv (&color, &hsv); + gimp_context_get_foreground (context, &rgb); + gimp_rgb_to_hsv (&rgb, &hsv); hsv.h = action_select_value (select_type, hsv.h, 0.0, 1.0, 1.0, 1.0 / 360.0, 0.01, 0.1, 0.0, FALSE); - gimp_hsv_to_rgb (&hsv, &color); - gimp_context_set_foreground (context, &color); + gimp_hsv_to_rgb (&hsv, &rgb); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_foreground (context, color); + g_object_unref (color); } void @@ -278,21 +302,24 @@ context_foreground_saturation_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpHSV hsv; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_foreground (context, &color); - gimp_rgb_to_hsv (&color, &hsv); + gimp_context_get_foreground (context, &rgb); + gimp_rgb_to_hsv (&rgb, &hsv); hsv.s = action_select_value (select_type, hsv.s, 0.0, 1.0, 1.0, 0.01, 0.01, 0.1, 0.0, FALSE); - gimp_hsv_to_rgb (&hsv, &color); - gimp_context_set_foreground (context, &color); + gimp_hsv_to_rgb (&hsv, &rgb); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_foreground (context, color); + g_object_unref (color); } void @@ -301,21 +328,24 @@ context_foreground_value_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpHSV hsv; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_foreground (context, &color); - gimp_rgb_to_hsv (&color, &hsv); + gimp_context_get_foreground (context, &rgb); + gimp_rgb_to_hsv (&rgb, &hsv); hsv.v = action_select_value (select_type, hsv.v, 0.0, 1.0, 1.0, 0.01, 0.01, 0.1, 0.0, FALSE); - gimp_hsv_to_rgb (&hsv, &color); - gimp_context_set_foreground (context, &color); + gimp_hsv_to_rgb (&hsv, &rgb); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_foreground (context, color); + g_object_unref (color); } void @@ -324,21 +354,24 @@ context_background_hue_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpHSV hsv; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_background (context, &color); - gimp_rgb_to_hsv (&color, &hsv); + gimp_context_get_background (context, &rgb); + gimp_rgb_to_hsv (&rgb, &hsv); hsv.h = action_select_value (select_type, hsv.h, 0.0, 1.0, 1.0, 1.0 / 360.0, 0.01, 0.1, 0.0, FALSE); - gimp_hsv_to_rgb (&hsv, &color); - gimp_context_set_background (context, &color); + gimp_hsv_to_rgb (&hsv, &rgb); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_background (context, color); + g_object_unref (color); } void @@ -347,21 +380,24 @@ context_background_saturation_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpHSV hsv; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_background (context, &color); - gimp_rgb_to_hsv (&color, &hsv); + gimp_context_get_background (context, &rgb); + gimp_rgb_to_hsv (&rgb, &hsv); hsv.s = action_select_value (select_type, hsv.s, 0.0, 1.0, 1.0, 0.01, 0.01, 0.1, 0.0, FALSE); - gimp_hsv_to_rgb (&hsv, &color); - gimp_context_set_background (context, &color); + gimp_hsv_to_rgb (&hsv, &rgb); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_background (context, color); + g_object_unref (color); } void @@ -370,21 +406,24 @@ context_background_value_cmd_callback (GimpAction *action, gpointer data) { GimpContext *context; - GimpRGB color; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; GimpHSV hsv; GimpActionSelectType select_type; return_if_no_context (context, data); select_type = (GimpActionSelectType) g_variant_get_int32 (value); - gimp_context_get_background (context, &color); - gimp_rgb_to_hsv (&color, &hsv); + gimp_context_get_background (context, &rgb); + gimp_rgb_to_hsv (&rgb, &hsv); hsv.v = action_select_value (select_type, hsv.v, 0.0, 1.0, 1.0, 0.01, 0.01, 0.1, 0.0, FALSE); - gimp_hsv_to_rgb (&hsv, &color); - gimp_context_set_background (context, &color); + gimp_hsv_to_rgb (&hsv, &rgb); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_background (context, color); + g_object_unref (color); } void diff --git a/app/core/gimpcontext.c b/app/core/gimpcontext.c index 963991fcb0..d98eaa9abb 100644 --- a/app/core/gimpcontext.c +++ b/app/core/gimpcontext.c @@ -153,11 +153,11 @@ static void gimp_context_real_set_paint_info (GimpContext *context, /* foreground */ static void gimp_context_real_set_foreground (GimpContext *context, - const GimpRGB *color); + GeglColor *color); /* background */ static void gimp_context_real_set_background (GimpContext *context, - const GimpRGB *color); + GeglColor *color); /* opacity */ static void gimp_context_real_set_opacity (GimpContext *context, @@ -826,6 +826,9 @@ gimp_context_init (GimpContext *context) context->line_art = NULL; context->line_art_timeout_id = 0; + + context->foreground = NULL; + context->background = NULL; } static void @@ -1023,6 +1026,8 @@ gimp_context_finalize (GObject *object) g_clear_pointer (&context->template_name, g_free); g_clear_object (&context->line_art); + g_clear_object (&context->foreground); + g_clear_object (&context->background); G_OBJECT_CLASS (parent_class)->finalize (object); } @@ -1053,10 +1058,24 @@ gimp_context_set_property (GObject *object, gimp_context_set_paint_info (context, g_value_get_object (value)); break; case GIMP_CONTEXT_PROP_FOREGROUND: - gimp_context_set_foreground (context, g_value_get_boxed (value)); + { + GeglColor *color = gegl_color_new ("black"); + GimpRGB *rgb = g_value_get_boxed (value); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); + gimp_context_set_foreground (context, color); + g_object_unref (color); + } break; case GIMP_CONTEXT_PROP_BACKGROUND: - gimp_context_set_background (context, g_value_get_boxed (value)); + { + GeglColor *color = gegl_color_new ("black"); + GimpRGB *rgb = g_value_get_boxed (value); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); + gimp_context_set_background (context, color); + g_object_unref (color); + } break; case GIMP_CONTEXT_PROP_OPACITY: gimp_context_set_opacity (context, g_value_get_double (value)); @@ -1664,11 +1683,11 @@ gimp_context_copy_property (GimpContext *src, break; case GIMP_CONTEXT_PROP_FOREGROUND: - gimp_context_real_set_foreground (dest, &src->foreground); + gimp_context_real_set_foreground (dest, src->foreground); break; case GIMP_CONTEXT_PROP_BACKGROUND: - gimp_context_real_set_background (dest, &src->background); + gimp_context_real_set_background (dest, src->background); break; case GIMP_CONTEXT_PROP_OPACITY: @@ -2290,17 +2309,17 @@ gimp_context_real_set_paint_info (GimpContext *context, void gimp_context_get_foreground (GimpContext *context, - GimpRGB *color) + GimpRGB *rgb) { g_return_if_fail (GIMP_IS_CONTEXT (context)); - g_return_if_fail (color != NULL); + g_return_if_fail (rgb != NULL); - *color = context->foreground; + gegl_color_get_rgba_with_space (context->foreground, &rgb->r, &rgb->g, &rgb->b, &rgb->a, NULL); } void -gimp_context_set_foreground (GimpContext *context, - const GimpRGB *color) +gimp_context_set_foreground (GimpContext *context, + GeglColor *color) { g_return_if_fail (GIMP_IS_CONTEXT (context)); g_return_if_fail (color != NULL); @@ -2321,14 +2340,16 @@ gimp_context_foreground_changed (GimpContext *context) } static void -gimp_context_real_set_foreground (GimpContext *context, - const GimpRGB *color) +gimp_context_real_set_foreground (GimpContext *context, + GeglColor *color) { - if (gimp_rgba_distance (&context->foreground, color) < RGBA_EPSILON) + if (context->foreground != NULL && + gimp_color_is_perceptually_identical (context->foreground, color)) return; - context->foreground = *color; - gimp_rgb_set_alpha (&context->foreground, GIMP_OPACITY_OPAQUE); + g_clear_object (&context->foreground); + context->foreground = gegl_color_duplicate (color); + gimp_color_set_alpha (context->foreground, GIMP_OPACITY_OPAQUE); g_object_notify (G_OBJECT (context), "foreground"); gimp_context_foreground_changed (context); @@ -2340,18 +2361,18 @@ gimp_context_real_set_foreground (GimpContext *context, void gimp_context_get_background (GimpContext *context, - GimpRGB *color) + GimpRGB *rgb) { g_return_if_fail (GIMP_IS_CONTEXT (context)); - g_return_if_fail (color != NULL); + g_return_if_fail (rgb != NULL); - *color = context->background; + gegl_color_get_rgba_with_space (context->background, &rgb->r, &rgb->g, &rgb->b, &rgb->a, NULL); } void -gimp_context_set_background (GimpContext *context, - const GimpRGB *color) +gimp_context_set_background (GimpContext *context, + GeglColor *color) { g_return_if_fail (GIMP_IS_CONTEXT (context)); g_return_if_fail (color != NULL); @@ -2372,14 +2393,16 @@ gimp_context_background_changed (GimpContext *context) } static void -gimp_context_real_set_background (GimpContext *context, - const GimpRGB *color) +gimp_context_real_set_background (GimpContext *context, + GeglColor *color) { - if (gimp_rgba_distance (&context->background, color) < RGBA_EPSILON) + if (context->background != NULL && + gimp_color_is_perceptually_identical (context->background, color)) return; - context->background = *color; - gimp_rgb_set_alpha (&context->background, GIMP_OPACITY_OPAQUE); + g_clear_object (&context->background); + context->background = gegl_color_duplicate (color); + gimp_color_set_alpha (context->background, GIMP_OPACITY_OPAQUE); g_object_notify (G_OBJECT (context), "background"); gimp_context_background_changed (context); @@ -2393,8 +2416,8 @@ void gimp_context_set_default_colors (GimpContext *context) { GimpContext *bg_context; - GimpRGB fg; - GimpRGB bg; + GeglColor *fg; + GeglColor *bg; g_return_if_fail (GIMP_IS_CONTEXT (context)); @@ -2403,19 +2426,22 @@ gimp_context_set_default_colors (GimpContext *context) context_find_defined (context, GIMP_CONTEXT_PROP_FOREGROUND); context_find_defined (bg_context, GIMP_CONTEXT_PROP_BACKGROUND); - gimp_rgba_set (&fg, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE); - gimp_rgba_set (&bg, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE); + fg = gegl_color_new ("black"); + bg = gegl_color_new ("white"); - gimp_context_real_set_foreground (context, &fg); - gimp_context_real_set_background (bg_context, &bg); + gimp_context_real_set_foreground (context, fg); + gimp_context_real_set_background (bg_context, bg); + + g_object_unref (fg); + g_object_unref (bg); } void gimp_context_swap_colors (GimpContext *context) { GimpContext *bg_context; - GimpRGB fg; - GimpRGB bg; + GeglColor *fg; + GeglColor *bg; g_return_if_fail (GIMP_IS_CONTEXT (context)); @@ -2424,11 +2450,14 @@ gimp_context_swap_colors (GimpContext *context) context_find_defined (context, GIMP_CONTEXT_PROP_FOREGROUND); context_find_defined (bg_context, GIMP_CONTEXT_PROP_BACKGROUND); - gimp_context_get_foreground (context, &fg); - gimp_context_get_background (bg_context, &bg); + fg = g_object_ref (context->foreground); + bg = g_object_ref (context->background); - gimp_context_real_set_foreground (context, &bg); - gimp_context_real_set_background (bg_context, &fg); + gimp_context_real_set_foreground (context, bg); + gimp_context_real_set_background (bg_context, fg); + + g_object_unref (fg); + g_object_unref (bg); } diff --git a/app/core/gimpcontext.h b/app/core/gimpcontext.h index 260d1b1b89..3651b29d99 100644 --- a/app/core/gimpcontext.h +++ b/app/core/gimpcontext.h @@ -64,8 +64,8 @@ struct _GimpContext GimpPaintInfo *paint_info; gchar *paint_name; - GimpRGB foreground; - GimpRGB background; + GeglColor *foreground; + GeglColor *background; gdouble opacity; GimpLayerMode paint_mode; @@ -249,7 +249,7 @@ void gimp_context_paint_info_changed (GimpContext *context); void gimp_context_get_foreground (GimpContext *context, GimpRGB *color); void gimp_context_set_foreground (GimpContext *context, - const GimpRGB *color); + GeglColor *color); void gimp_context_foreground_changed (GimpContext *context); @@ -257,7 +257,7 @@ void gimp_context_foreground_changed (GimpContext *context); void gimp_context_get_background (GimpContext *context, GimpRGB *color); void gimp_context_set_background (GimpContext *context, - const GimpRGB *color); + GeglColor *color); void gimp_context_background_changed (GimpContext *context); diff --git a/app/core/gimpdrawable-bucket-fill.c b/app/core/gimpdrawable-bucket-fill.c index 02732a4732..10b6aa4021 100644 --- a/app/core/gimpdrawable-bucket-fill.c +++ b/app/core/gimpdrawable-bucket-fill.c @@ -468,12 +468,12 @@ gimp_drawable_get_line_art_fill_buffer (GimpDrawable *drawable, GList *drawables; GimpContext *context = gimp_get_user_context (image->gimp); GError *error = NULL; - const GimpRGB white = {1.0, 1.0, 1.0, 1.0}; + GeglColor *white = gegl_color_new ("white"); context = gimp_config_duplicate (GIMP_CONFIG (context)); /* As we are stroking a mask, we need to set color to white. */ - gimp_context_set_foreground (GIMP_CONTEXT (context), - &white); + gimp_context_set_foreground (GIMP_CONTEXT (context), white); + g_object_unref (white); channel = gimp_channel_new_from_buffer (image, new_mask, NULL, NULL); stroked = gimp_channel_new_from_buffer (image, rendered_mask, NULL, NULL); diff --git a/app/core/gimpfilloptions.c b/app/core/gimpfilloptions.c index 51a5b07bad..1418cf0485 100644 --- a/app/core/gimpfilloptions.c +++ b/app/core/gimpfilloptions.c @@ -375,7 +375,8 @@ gimp_fill_options_set_by_fill_type (GimpFillOptions *options, GError **error) { GimpFillOptionsPrivate *private; - GimpRGB color; + GeglColor *color; + GimpRGB rgb; const gchar *undo_desc; g_return_val_if_fail (GIMP_IS_FILL_OPTIONS (options), FALSE); @@ -389,12 +390,12 @@ gimp_fill_options_set_by_fill_type (GimpFillOptions *options, switch (fill_type) { case GIMP_FILL_FOREGROUND: - gimp_context_get_foreground (context, &color); + gimp_context_get_foreground (context, &rgb); undo_desc = C_("undo-type", "Fill with Foreground Color"); break; case GIMP_FILL_BACKGROUND: - gimp_context_get_background (context, &color); + gimp_context_get_background (context, &rgb); undo_desc = C_("undo-type", "Fill with Background Color"); break; @@ -417,18 +418,18 @@ gimp_fill_options_set_by_fill_type (GimpFillOptions *options, babl_process (babl_fish (babl_format ("CIE Lab float"), format), cielab_pixel, pixel, 1); - gimp_rgba_set (&color, pixel[0], pixel[1], pixel[2], GIMP_OPACITY_OPAQUE); + gimp_rgba_set (&rgb, pixel[0], pixel[1], pixel[2], GIMP_OPACITY_OPAQUE); undo_desc = C_("undo-type", "Fill with Middle Gray (CIELAB) Color"); } break; case GIMP_FILL_WHITE: - gimp_rgba_set (&color, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE); + gimp_rgba_set (&rgb, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE); undo_desc = C_("undo-type", "Fill with White"); break; case GIMP_FILL_TRANSPARENT: - gimp_context_get_background (context, &color); + gimp_context_get_background (context, &rgb); gimp_context_set_paint_mode (GIMP_CONTEXT (options), GIMP_LAYER_MODE_ERASE); undo_desc = C_("undo-type", "Fill with Transparency"); @@ -459,9 +460,13 @@ gimp_fill_options_set_by_fill_type (GimpFillOptions *options, } gimp_fill_options_set_style (options, GIMP_FILL_STYLE_FG_COLOR); - gimp_context_set_foreground (GIMP_CONTEXT (options), &color); + color = gegl_color_new ("black"); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); + gimp_context_set_foreground (GIMP_CONTEXT (options), color); private->undo_desc = undo_desc; + g_object_unref (color); + return TRUE; } diff --git a/app/display/gimpdisplayshell-dnd.c b/app/display/gimpdisplayshell-dnd.c index 28c816e448..ff214cc96f 100644 --- a/app/display/gimpdisplayshell-dnd.c +++ b/app/display/gimpdisplayshell-dnd.c @@ -436,22 +436,25 @@ static void gimp_display_shell_drop_color (GtkWidget *widget, gint x, gint y, - const GimpRGB *color, + const GimpRGB *rgb, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpFillOptions *options = gimp_fill_options_new (shell->display->gimp, NULL, FALSE); + GeglColor *color = gegl_color_new ("black"); GIMP_LOG (DND, NULL); gimp_fill_options_set_style (options, GIMP_FILL_STYLE_FG_COLOR); + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); gimp_context_set_foreground (GIMP_CONTEXT (options), color); gimp_display_shell_dnd_fill (shell, options, C_("undo-type", "Drop color to layer")); g_object_unref (options); + g_object_unref (color); } static void diff --git a/app/pdb/context-cmds.c b/app/pdb/context-cmds.c index 6c51d3d354..c9a39416a5 100644 --- a/app/pdb/context-cmds.c +++ b/app/pdb/context-cmds.c @@ -269,14 +269,14 @@ context_set_foreground_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpRGB foreground; + GeglColor *foreground; - gimp_value_get_rgb (gimp_value_array_index (args, 0), &foreground); + foreground = g_value_get_object (gimp_value_array_index (args, 0)); if (success) { - gimp_rgb_set_alpha (&foreground, 1.0); - gimp_context_set_foreground (context, &foreground); + gimp_color_set_alpha (foreground, 1.0); + gimp_context_set_foreground (context, foreground); } return gimp_procedure_get_return_values (procedure, success, @@ -312,14 +312,14 @@ context_set_background_invoker (GimpProcedure *procedure, GError **error) { gboolean success = TRUE; - GimpRGB background; + GeglColor *background; - gimp_value_get_rgb (gimp_value_array_index (args, 0), &background); + background = g_value_get_object (gimp_value_array_index (args, 0)); if (success) { - gimp_rgb_set_alpha (&background, 1.0); - gimp_context_set_background (context, &background); + gimp_color_set_alpha (background, 1.0); + gimp_context_set_background (context, background); } return gimp_procedure_get_return_values (procedure, success, @@ -3282,12 +3282,11 @@ register_context_procs (GimpPDB *pdb) "Michael Natterer & Sven Neumann", "2004"); gimp_procedure_add_argument (procedure, - gimp_param_spec_rgb ("foreground", - "foreground", - "The foreground color", - FALSE, - NULL, - GIMP_PARAM_READWRITE)); + gegl_param_spec_color ("foreground", + "foreground", + "The foreground color", + NULL, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); @@ -3330,12 +3329,11 @@ register_context_procs (GimpPDB *pdb) "Michael Natterer & Sven Neumann", "2004"); gimp_procedure_add_argument (procedure, - gimp_param_spec_rgb ("background", - "background", - "The background color", - FALSE, - NULL, - GIMP_PARAM_READWRITE)); + gegl_param_spec_color ("background", + "background", + "The background color", + NULL, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/tools/gimpcolortool.c b/app/tools/gimpcolortool.c index 38efe4cf02..1ebb1679fe 100644 --- a/app/tools/gimpcolortool.c +++ b/app/tools/gimpcolortool.c @@ -492,7 +492,6 @@ gimp_color_tool_real_picked (GimpColorTool *color_tool, GimpImageWindow *image_window; GimpDialogFactory *dialog_factory; GimpContext *context; - GimpRGB rgb = { 0 }; g_return_if_fail (GEGL_IS_COLOR (color)); @@ -557,19 +556,17 @@ gimp_color_tool_real_picked (GimpColorTool *color_tool, } } - gegl_color_get_rgba_with_space (color, &rgb.r, &rgb.g, &rgb.b, &rgb.a, sample_format); switch (color_tool->pick_target) { case GIMP_COLOR_PICK_TARGET_NONE: break; case GIMP_COLOR_PICK_TARGET_FOREGROUND: - /* TODO: FG/BG colors should be stored as GeglColor. */ - gimp_context_set_foreground (context, &rgb); + gimp_context_set_foreground (context, color); break; case GIMP_COLOR_PICK_TARGET_BACKGROUND: - gimp_context_set_background (context, &rgb); + gimp_context_set_background (context, color); break; case GIMP_COLOR_PICK_TARGET_PALETTE: diff --git a/app/tools/gimptextoptions.c b/app/tools/gimptextoptions.c index 118a7f6648..b1d712c927 100644 --- a/app/tools/gimptextoptions.c +++ b/app/tools/gimptextoptions.c @@ -703,13 +703,18 @@ gimp_text_options_notify_text_color (GimpText *text, GParamSpec *pspec, GimpContext *context) { + GeglColor *color = gegl_color_new ("black"); + g_signal_handlers_block_by_func (context, gimp_text_options_notify_color, text); - gimp_context_set_foreground (context, &text->color); + gegl_color_set_rgba_with_space (color, text->color.r, text->color.g, text->color.b, text->color.a, NULL); + gimp_context_set_foreground (context, color); g_signal_handlers_unblock_by_func (context, gimp_text_options_notify_color, text); + + g_object_unref (color); } /* This function could live in gimptexttool.c also. diff --git a/app/widgets/gimpcoloreditor.c b/app/widgets/gimpcoloreditor.c index b9d66d8198..091c0f1fad 100644 --- a/app/widgets/gimpcoloreditor.c +++ b/app/widgets/gimpcoloreditor.c @@ -591,13 +591,16 @@ gimp_color_editor_color_changed (GimpColorSelector *selector, { if (editor->context) { + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); if (editor->edit_bg) { g_signal_handlers_block_by_func (editor->context, gimp_color_editor_bg_changed, editor); - gimp_context_set_background (editor->context, rgb); + gimp_context_set_background (editor->context, color); g_signal_handlers_unblock_by_func (editor->context, gimp_color_editor_bg_changed, @@ -609,12 +612,14 @@ gimp_color_editor_color_changed (GimpColorSelector *selector, gimp_color_editor_fg_changed, editor); - gimp_context_set_foreground (editor->context, rgb); + gimp_context_set_foreground (editor->context, color); g_signal_handlers_unblock_by_func (editor->context, gimp_color_editor_fg_changed, editor); } + + g_object_unref (color); } g_signal_handlers_block_by_func (editor->hex_entry, @@ -693,10 +698,16 @@ gimp_color_editor_color_picked (GtkWidget *widget, { if (editor->context) { + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); + if (editor->edit_bg) - gimp_context_set_background (editor->context, rgb); + gimp_context_set_background (editor->context, color); else - gimp_context_set_foreground (editor->context, rgb); + gimp_context_set_foreground (editor->context, color); + + g_object_unref (color); } } @@ -704,17 +715,21 @@ static void gimp_color_editor_entry_changed (GimpColorHexEntry *entry, GimpColorEditor *editor) { - GimpRGB rgb; + GeglColor *color = gegl_color_new ("black"); + GimpRGB rgb; gimp_color_hex_entry_get_color (entry, &rgb); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); if (editor->context) { if (editor->edit_bg) - gimp_context_set_background (editor->context, &rgb); + gimp_context_set_background (editor->context, color); else - gimp_context_set_foreground (editor->context, &rgb); + gimp_context_set_foreground (editor->context, color); } + + g_object_unref (color); } static void @@ -724,9 +739,15 @@ gimp_color_editor_history_selected (GimpColorHistory *history, { if (editor->context) { + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); + if (editor->edit_bg) - gimp_context_set_background (editor->context, rgb); + gimp_context_set_background (editor->context, color); else - gimp_context_set_foreground (editor->context, rgb); + gimp_context_set_foreground (editor->context, color); + + g_object_unref (color); } } diff --git a/app/widgets/gimpcolormapeditor.c b/app/widgets/gimpcolormapeditor.c index 17838a80af..29a04106e6 100644 --- a/app/widgets/gimpcolormapeditor.c +++ b/app/widgets/gimpcolormapeditor.c @@ -353,7 +353,7 @@ gimp_colormap_editor_max_index (GimpColormapEditor *editor) static void gimp_colormap_editor_color_update (GimpColorDialog *dialog, - const GimpRGB *color, + const GimpRGB *rgb, GimpColorDialogState state, GimpColormapEditor *editor) { @@ -364,12 +364,20 @@ gimp_colormap_editor_color_update (GimpColorDialog *dialog, switch (state) { case GIMP_COLOR_DIALOG_OK: - push_undo = TRUE; + { + GeglColor *color = gegl_color_new ("black"); - if (state & gimp_get_toggle_behavior_mask ()) - gimp_context_set_background (image_editor->context, color); - else - gimp_context_set_foreground (image_editor->context, color); + push_undo = TRUE; + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); + + if (state & gimp_get_toggle_behavior_mask ()) + gimp_context_set_background (image_editor->context, color); + else + gimp_context_set_foreground (image_editor->context, color); + + g_object_unref (color); + } /* Fall through */ case GIMP_COLOR_DIALOG_CANCEL: @@ -398,8 +406,7 @@ gimp_colormap_editor_color_update (GimpColorDialog *dialog, FALSE); } - gimp_image_set_colormap_entry (image, col_index, color, - push_undo); + gimp_image_set_colormap_entry (image, col_index, rgb, push_undo); if (push_undo) gimp_image_flush (image); @@ -448,11 +455,16 @@ gimp_colormap_editor_color_clicked (GimpColormapEditor *editor, GdkModifierType state) { GimpImageEditor *image_editor = GIMP_IMAGE_EDITOR (editor); + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, entry->color.r, entry->color.g, entry->color.b, entry->color.a, NULL); if (state & gimp_get_toggle_behavior_mask ()) - gimp_context_set_background (image_editor->context, &entry->color); + gimp_context_set_background (image_editor->context, color); else - gimp_context_set_foreground (image_editor->context, &entry->color); + gimp_context_set_foreground (image_editor->context, color); + + g_object_unref (color); } static void diff --git a/app/widgets/gimpdrawabletreeview.c b/app/widgets/gimpdrawabletreeview.c index 057f56fdfd..a895688c05 100644 --- a/app/widgets/gimpdrawabletreeview.c +++ b/app/widgets/gimpdrawabletreeview.c @@ -281,7 +281,7 @@ gimp_drawable_tree_view_drop_viewables (GimpContainerTreeView *view, static void gimp_drawable_tree_view_drop_color (GimpContainerTreeView *view, - const GimpRGB *color, + const GimpRGB *rgb, GimpViewable *dest_viewable, GtkTreeViewDropPosition drop_pos) { @@ -289,6 +289,9 @@ gimp_drawable_tree_view_drop_color (GimpContainerTreeView *view, { GimpImage *image = gimp_item_get_image (GIMP_ITEM (dest_viewable)); GimpFillOptions *options = gimp_fill_options_new (image->gimp, NULL, FALSE); + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); gimp_fill_options_set_style (options, GIMP_FILL_STYLE_FG_COLOR); gimp_context_set_foreground (GIMP_CONTEXT (options), color); @@ -298,6 +301,7 @@ gimp_drawable_tree_view_drop_color (GimpContainerTreeView *view, C_("undo-type", "Drop color to layer")); g_object_unref (options); + g_object_unref (color); gimp_image_flush (image); } @@ -387,12 +391,15 @@ static void gimp_drawable_tree_view_new_color_dropped (GtkWidget *widget, gint x, gint y, - const GimpRGB *color, + const GimpRGB *rgb, gpointer data) { GimpItemTreeView *view = GIMP_ITEM_TREE_VIEW (data); GimpImage *image = gimp_item_tree_view_get_image (view); GimpFillOptions *options = gimp_fill_options_new (image->gimp, NULL, FALSE); + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); gimp_fill_options_set_style (options, GIMP_FILL_STYLE_FG_COLOR); gimp_context_set_foreground (GIMP_CONTEXT (options), color); @@ -401,4 +408,5 @@ gimp_drawable_tree_view_new_color_dropped (GtkWidget *widget, C_("undo-type", "Drop color to layer")); g_object_unref (options); + g_object_unref (color); } diff --git a/app/widgets/gimpfgbgeditor.c b/app/widgets/gimpfgbgeditor.c index 3b8b9f9e04..ee6ae531b0 100644 --- a/app/widgets/gimpfgbgeditor.c +++ b/app/widgets/gimpfgbgeditor.c @@ -766,10 +766,13 @@ static void gimp_fg_bg_editor_drop_color (GtkWidget *widget, gint x, gint y, - const GimpRGB *color, + const GimpRGB *rgb, gpointer data) { GimpFgBgEditor *editor = GIMP_FG_BG_EDITOR (widget); + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); if (editor->context) { @@ -791,6 +794,8 @@ gimp_fg_bg_editor_drop_color (GtkWidget *widget, break; } } + + g_object_unref (color); } static void diff --git a/app/widgets/gimpgradienteditor.c b/app/widgets/gimpgradienteditor.c index 29d3964d55..6c42b8a60d 100644 --- a/app/widgets/gimpgradienteditor.c +++ b/app/widgets/gimpgradienteditor.c @@ -1325,41 +1325,44 @@ view_pick_color (GimpGradientEditor *editor, gint x) { GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor); - GimpRGB color; + GimpRGB rgb; gdouble xpos; gchar *str2; gchar *str3; + GeglColor *color = gegl_color_new ("black"); xpos = control_calc_g_pos (editor, x); gimp_gradient_get_color_at (GIMP_GRADIENT (data_editor->data), data_editor->context, NULL, - xpos, FALSE, FALSE, &color); + xpos, FALSE, FALSE, &rgb); - gimp_color_area_set_color (GIMP_COLOR_AREA (editor->current_color), &color); + gimp_color_area_set_color (GIMP_COLOR_AREA (editor->current_color), &rgb); str2 = g_strdup_printf (_("RGB (%d, %d, %d)"), - (gint) (color.r * 255.0), - (gint) (color.g * 255.0), - (gint) (color.b * 255.0)); + (gint) (rgb.r * 255.0), + (gint) (rgb.g * 255.0), + (gint) (rgb.b * 255.0)); - str3 = g_strdup_printf ("(%0.3f, %0.3f, %0.3f)", color.r, color.g, color.b); + str3 = g_strdup_printf ("(%0.3f, %0.3f, %0.3f)", rgb.r, rgb.g, rgb.b); + gegl_color_set_rgba_with_space (color, rgb.r, rgb.g, rgb.b, rgb.a, NULL); if (pick_target == GIMP_COLOR_PICK_TARGET_FOREGROUND) { - gimp_context_set_foreground (data_editor->context, &color); + gimp_context_set_foreground (data_editor->context, color); gradient_editor_set_hint (editor, _("Foreground color set to:"), str2, str3, NULL); } else { - gimp_context_set_background (data_editor->context, &color); + gimp_context_set_background (data_editor->context, color); gradient_editor_set_hint (editor, _("Background color set to:"), str2, str3, NULL); } + g_object_unref (color); g_free (str2); g_free (str3); } diff --git a/app/widgets/gimppaletteeditor.c b/app/widgets/gimppaletteeditor.c index f37cf10445..08d4d64064 100644 --- a/app/widgets/gimppaletteeditor.c +++ b/app/widgets/gimppaletteeditor.c @@ -774,11 +774,15 @@ palette_editor_entry_clicked (GimpPaletteView *view, if (entry) { GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor); + GeglColor *color = gegl_color_new ("black"); + gegl_color_set_rgba_with_space (color, entry->color.r, entry->color.g, entry->color.b, entry->color.a, NULL); if (state & gimp_get_toggle_behavior_mask ()) - gimp_context_set_background (data_editor->context, &entry->color); + gimp_context_set_background (data_editor->context, color); else - gimp_context_set_foreground (data_editor->context, &entry->color); + gimp_context_set_foreground (data_editor->context, color); + + g_object_unref (color); } } diff --git a/app/widgets/gimptoolbox-color-area.c b/app/widgets/gimptoolbox-color-area.c index de93a1421c..9d107ca8e1 100644 --- a/app/widgets/gimptoolbox-color-area.c +++ b/app/widgets/gimptoolbox-color-area.c @@ -164,10 +164,14 @@ color_area_background_changed (GimpContext *context, static void color_area_dialog_update (GimpColorDialog *dialog, - const GimpRGB *color, + const GimpRGB *rgb, GimpColorDialogState state, GimpContext *context) { + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, rgb->r, rgb->g, rgb->b, rgb->a, NULL); + switch (state) { case GIMP_COLOR_DIALOG_OK: @@ -205,13 +209,17 @@ color_area_dialog_update (GimpColorDialog *dialog, case GIMP_COLOR_DIALOG_CANCEL: gtk_widget_hide (color_dialog); color_dialog_active = FALSE; - gimp_context_set_foreground (context, &revert_fg); - gimp_context_set_background (context, &revert_bg); + gegl_color_set_rgba_with_space (color, revert_fg.r, revert_fg.g, revert_fg.b, revert_fg.a, NULL); + gimp_context_set_foreground (context, color); + gegl_color_set_rgba_with_space (color, revert_bg.r, revert_bg.g, revert_bg.b, revert_bg.a, NULL); + gimp_context_set_background (context, color); break; } if (gimp_context_get_display (context)) gimp_display_grab_focus (gimp_context_get_display (context)); + + g_object_unref (color); } static void diff --git a/libgimp/gimpcontext_pdb.c b/libgimp/gimpcontext_pdb.c index 8ebfca26e8..f59a64476d 100644 --- a/libgimp/gimpcontext_pdb.c +++ b/libgimp/gimpcontext_pdb.c @@ -380,14 +380,14 @@ gimp_context_get_foreground (GimpRGB *foreground) * Since: 2.2 **/ gboolean -gimp_context_set_foreground (const GimpRGB *foreground) +gimp_context_set_foreground (GeglColor *foreground) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_RGB, foreground, + GEGL_TYPE_COLOR, foreground, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), @@ -456,14 +456,14 @@ gimp_context_get_background (GimpRGB *background) * Since: 2.2 **/ gboolean -gimp_context_set_background (const GimpRGB *background) +gimp_context_set_background (GeglColor *background) { GimpValueArray *args; GimpValueArray *return_vals; gboolean success = TRUE; args = gimp_value_array_new_from_types (NULL, - GIMP_TYPE_RGB, background, + GEGL_TYPE_COLOR, background, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), diff --git a/libgimp/gimpcontext_pdb.h b/libgimp/gimpcontext_pdb.h index 4f69bc3d1d..b5a7e7c51a 100644 --- a/libgimp/gimpcontext_pdb.h +++ b/libgimp/gimpcontext_pdb.h @@ -41,9 +41,9 @@ gboolean gimp_context_set_paint_method (const GimpStrokeMethod gimp_context_get_stroke_method (void); gboolean gimp_context_set_stroke_method (GimpStrokeMethod stroke_method); gboolean gimp_context_get_foreground (GimpRGB *foreground); -gboolean gimp_context_set_foreground (const GimpRGB *foreground); +gboolean gimp_context_set_foreground (GeglColor *foreground); gboolean gimp_context_get_background (GimpRGB *background); -gboolean gimp_context_set_background (const GimpRGB *background); +gboolean gimp_context_set_background (GeglColor *background); gboolean gimp_context_set_default_colors (void); gboolean gimp_context_swap_colors (void); gdouble gimp_context_get_opacity (void); diff --git a/pdb/groups/context.pdb b/pdb/groups/context.pdb index b7e8acc2ec..a8d9c2125d 100644 --- a/pdb/groups/context.pdb +++ b/pdb/groups/context.pdb @@ -275,15 +275,15 @@ HELP &pdb_misc; @inargs = ( - { name => 'foreground', type => 'color', void_ret => 1, + { name => 'foreground', type => 'geglcolor', void_ret => 1, desc => 'The foreground color' } ); %invoke = ( code => <<'CODE' { - gimp_rgb_set_alpha (&foreground, 1.0); - gimp_context_set_foreground (context, &foreground); + gimp_color_set_alpha (foreground, 1.0); + gimp_context_set_foreground (context, foreground); } CODE ); @@ -327,15 +327,15 @@ HELP &pdb_misc; @inargs = ( - { name => 'background', type => 'color', void_ret => 1, + { name => 'background', type => 'geglcolor', void_ret => 1, desc => 'The background color' } ); %invoke = ( code => <<'CODE' { - gimp_rgb_set_alpha (&background, 1.0); - gimp_context_set_background (context, &background); + gimp_color_set_alpha (background, 1.0); + gimp_context_set_background (context, background); } CODE ); diff --git a/plug-ins/common/border-average.c b/plug-ins/common/border-average.c index 09d6c81f77..d760412594 100644 --- a/plug-ins/common/border-average.c +++ b/plug-ins/common/border-average.c @@ -209,7 +209,13 @@ border_average_run (GimpProcedure *procedure, borderaverage (G_OBJECT (config), buffer, drawable, &result_color); if (run_mode != GIMP_RUN_NONINTERACTIVE) - gimp_context_set_foreground (&result_color); + { + GeglColor *color = gegl_color_new ("black"); + + gegl_color_set_rgba_with_space (color, result_color.r, result_color.g, result_color.b, result_color.a, NULL); + gimp_context_set_foreground (color); + g_object_unref (color); + } } else { diff --git a/plug-ins/common/film.c b/plug-ins/common/film.c index 37497a76c6..8e630f8a21 100644 --- a/plug-ins/common/film.c +++ b/plug-ins/common/film.c @@ -418,6 +418,7 @@ film (GimpProcedureConfig *config) gint picture_count; GimpRGB *number_color; GimpRGB *film_color; + GeglColor *color; gboolean keep_height; gdouble f; GimpImage *image_dst; @@ -456,8 +457,12 @@ film (GimpProcedureConfig *config) return NULL; gimp_context_push (); - gimp_context_set_foreground (number_color); - gimp_context_set_background (film_color); + color = gegl_color_new ("black"); + gegl_color_set_rgba_with_space (color, number_color->r, number_color->g, number_color->b, number_color->a, NULL); + gimp_context_set_foreground (color); + gegl_color_set_rgba_with_space (color, film_color->r, film_color->g, film_color->b, film_color->a, NULL); + gimp_context_set_background (color); + g_object_unref (color); if (keep_height) /* Search maximum picture height */ { diff --git a/plug-ins/gfig/gfig-style.c b/plug-ins/gfig/gfig-style.c index 9941cdd575..a79d033b5b 100644 --- a/plug-ins/gfig/gfig-style.c +++ b/plug-ins/gfig/gfig-style.c @@ -610,12 +610,17 @@ gfig_style_copy (Style *style1, void gfig_style_apply (Style *style) { + GeglColor *color = gegl_color_new ("black"); + if (gfig_context->debug_styles) g_printerr ("Applying style '%s' -- ", style->name); - gimp_context_set_foreground (&style->foreground); + gegl_color_set_rgba_with_space (color, style->foreground.r, style->foreground.g, style->foreground.b, style->foreground.a, NULL); + gimp_context_set_foreground (color); - gimp_context_set_background (&style->background); + gegl_color_set_rgba_with_space (color, style->background.r, style->background.g, style->background.b, style->background.a, NULL); + gimp_context_set_background (color); + g_object_unref (color); if (! gimp_context_set_brush (style->brush)) g_message ("Style apply: Failed to set brush to '%s' in style '%s'",