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

app, libgimp, pdb, plug-ins: move more code to GeglColor. 

In particular, I updated the channel and quick-mask colors, padding colors and
more.
This commit is contained in:
Jehan 2023-11-20 00:20:03 +01:00
parent 319150a3b1
commit 4879ab7b7f
45 changed files with 503 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
app/actions/channels-commands.c
View File

@ -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))

11
app/actions/quick-mask-actions.c
View File

@ -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

16
app/actions/quick-mask-commands.c
View File

@ -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);

24
app/actions/view-commands.c
View File

@ -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);
}

29
app/config/gimpcoreconfig.c
View File

@ -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);

2
app/config/gimpcoreconfig.h
View File

@ -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;

29
app/config/gimpdialogconfig.c
View File

@ -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:

2
app/config/gimpdialogconfig.h
View File

@ -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;

68
app/config/gimpdisplayoptions.c
View File

@ -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);

2
app/config/gimpdisplayoptions.h
View File

@ -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;
};

1
app/config/gimpguiconfig.c
View File

@ -20,6 +20,7 @@
#include "config.h"
#include <gegl.h>
#include <gio/gio.h>
#include "libgimpbase/gimpbase.h"

88
app/core/gimpchannel.c
View File

@ -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, &current_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);

15
app/core/gimpchannel.h
View File

@ -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);

21
app/core/gimpchannelpropundo.c
View File

@ -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;

2
app/core/gimpchannelpropundo.h
View File

@ -37,7 +37,7 @@ struct _GimpChannelPropUndo
{
GimpItemUndo parent_instance;
GimpRGB color;
GeglColor *color;
};
struct _GimpChannelPropUndoClass

2
app/core/gimpimage-private.h
View File

@ -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 */

21
app/core/gimpimage-quick-mask.c
View File

@ -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 *

5
app/core/gimpimage-quick-mask.h
View File

@ -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);

11
app/core/gimpimage.c
View File

@ -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);
}
}

7
app/core/gimplayermask.c
View File

@ -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);

7
app/core/gimpselection.c
View File

@ -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;
}

19
app/dialogs/channel-options-dialog.c
View File

@ -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,

4
app/dialogs/channel-options-dialog.h
View File

@ -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,

21
app/dialogs/preferences-dialog-utils.c
View File

@ -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)
{

35
app/display/gimpdisplayshell-appearance.c
View File

@ -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;

4
app/display/gimpdisplayshell-appearance.h
View File

@ -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);

4
app/display/gimpdisplayshell-callbacks.c
View File

@ -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);

12
app/display/gimpdisplayshell-handlers.c
View File

@ -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);
}
}
}

15
app/gegl/gimp-gegl-nodes.c
View File

@ -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);
}

3
app/gegl/gimp-gegl-nodes.h
View File

@ -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__ */

62
app/pdb/channel-cmds.c
View File

@ -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);
}

19
app/tests/test-xcf.c
View File

@ -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

8
app/widgets/gimpchanneltreeview.c
View File

@ -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);

8
app/xcf/xcf-load.c
View File

@ -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;

18
app/xcf/xcf-save.c
View File

@ -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;

12
libgimp/gimpchannel.c
View File

@ -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,

14
libgimp/gimpchannel.h
View File

@ -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

38
libgimp/gimpchannel_pdb.c
View File

@ -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 (),

7
libgimp/gimpchannel_pdb.h
View File

@ -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

27
pdb/groups/channel.pdb
View File

@ -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(<cairo.h>
"libgimpbase/gimpbase.h"
"libgimpcolor/gimpcolor.h");
@procs = qw(channel_new
channel_new_from_component

124
plug-ins/file-psd/psd-image-res-load.c
View File

@ -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;

14
plug-ins/file-psd/psd-load.c
View File

@ -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);
}
}

23
plug-ins/file-psd/psd-save.c
View File

@ -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

2
plug-ins/file-psd/psd.h
View File

@ -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 */

8
plug-ins/file-tiff/file-tiff-load.c
View File

@ -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);