From 4c1ec79281c6ba83eea5e071c51619491a624de8 Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Thu, 4 Feb 2010 09:49:45 +0100 Subject: [PATCH] Move the quick mask members to GimpImagePrivate and add API to access the "inverted" state. --- app/actions/quick-mask-actions.c | 20 +++++++-- app/actions/quick-mask-commands.c | 2 +- app/core/gimpimage-duplicate.c | 9 +++-- app/core/gimpimage-private.h | 4 ++ app/core/gimpimage-quick-mask.c | 54 ++++++++++++++++--------- app/core/gimpimage-quick-mask.h | 19 ++++----- app/core/gimpimage.c | 11 +++-- app/core/gimpimage.h | 7 ++-- app/display/gimpdisplayshell-handlers.c | 10 +++-- 9 files changed, 89 insertions(+), 47 deletions(-) diff --git a/app/actions/quick-mask-actions.c b/app/actions/quick-mask-actions.c index f76aea84cb..2255143044 100644 --- a/app/actions/quick-mask-actions.c +++ b/app/actions/quick-mask-actions.c @@ -25,6 +25,7 @@ #include "actions-types.h" #include "core/gimpimage.h" +#include "core/gimpimage-quick-mask.h" #include "widgets/gimpactiongroup.h" #include "widgets/gimphelp-ids.h" @@ -95,7 +96,18 @@ void quick_mask_actions_update (GimpActionGroup *group, gpointer data) { - GimpImage *image = action_data_get_image (data); + GimpImage *image = action_data_get_image (data); + gboolean quick_mask_state = FALSE; + gboolean quick_mask_inverted = FALSE; + GimpRGB quick_mask_color; + + 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); + } #define SET_SENSITIVE(action,sensitive) \ gimp_action_group_set_action_sensitive (group, action, (sensitive) != 0) @@ -105,12 +117,12 @@ quick_mask_actions_update (GimpActionGroup *group, gimp_action_group_set_action_color (group, action, (color), FALSE) SET_SENSITIVE ("quick-mask-toggle", image); - SET_ACTIVE ("quick-mask-toggle", image && image->quick_mask_state); + SET_ACTIVE ("quick-mask-toggle", quick_mask_state); SET_SENSITIVE ("quick-mask-invert-on", image); SET_SENSITIVE ("quick-mask-invert-off", image); - if (image && image->quick_mask_inverted) + if (quick_mask_inverted) SET_ACTIVE ("quick-mask-invert-on", TRUE); else SET_ACTIVE ("quick-mask-invert-off", TRUE); @@ -118,7 +130,7 @@ quick_mask_actions_update (GimpActionGroup *group, SET_SENSITIVE ("quick-mask-configure", image); if (image) - SET_COLOR ("quick-mask-configure", &image->quick_mask_color); + SET_COLOR ("quick-mask-configure", &quick_mask_color); #undef SET_SENSITIVE #undef SET_ACTIVE diff --git a/app/actions/quick-mask-commands.c b/app/actions/quick-mask-commands.c index 42f9ce9945..b30890d7a3 100644 --- a/app/actions/quick-mask-commands.c +++ b/app/actions/quick-mask-commands.c @@ -77,7 +77,7 @@ quick_mask_invert_cmd_callback (GtkAction *action, value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action)); - if (value != image->quick_mask_inverted) + if (value != gimp_image_get_quick_mask_inverted (image)) { gimp_image_quick_mask_invert (image); gimp_image_flush (image); diff --git a/app/core/gimpimage-duplicate.c b/app/core/gimpimage-duplicate.c index ccc5fb21a4..3e8188bfc9 100644 --- a/app/core/gimpimage-duplicate.c +++ b/app/core/gimpimage-duplicate.c @@ -430,9 +430,12 @@ static void gimp_image_duplicate_quick_mask (GimpImage *image, GimpImage *new_image) { - new_image->quick_mask_state = image->quick_mask_state; - new_image->quick_mask_inverted = image->quick_mask_inverted; - new_image->quick_mask_color = image->quick_mask_color; + GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); + GimpImagePrivate *new_private = GIMP_IMAGE_GET_PRIVATE (new_image); + + new_private->quick_mask_state = private->quick_mask_state; + new_private->quick_mask_inverted = private->quick_mask_inverted; + new_private->quick_mask_color = private->quick_mask_color; } static void diff --git a/app/core/gimpimage-private.h b/app/core/gimpimage-private.h index f41bfe7244..c08952a7a8 100644 --- a/app/core/gimpimage-private.h +++ b/app/core/gimpimage-private.h @@ -78,6 +78,10 @@ struct _GimpImagePrivate gboolean visible[MAX_CHANNELS]; /* visible channels */ gboolean active[MAX_CHANNELS]; /* active channels */ + + 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 */ }; #define GIMP_IMAGE_GET_PRIVATE(image) \ diff --git a/app/core/gimpimage-quick-mask.c b/app/core/gimpimage-quick-mask.c index 8179c5db63..46db050736 100644 --- a/app/core/gimpimage-quick-mask.c +++ b/app/core/gimpimage-quick-mask.c @@ -26,6 +26,7 @@ #include "gimp.h" #include "gimpchannel.h" #include "gimpimage.h" +#include "gimpimage-private.h" #include "gimpimage-quick-mask.h" #include "gimpimage-undo.h" #include "gimpimage-undo-push.h" @@ -45,30 +46,33 @@ void gimp_image_set_quick_mask_state (GimpImage *image, gboolean active) { - GimpChannel *selection; - GimpChannel *mask; - gboolean channel_was_active; + GimpImagePrivate *private; + GimpChannel *selection; + GimpChannel *mask; + gboolean channel_was_active; g_return_if_fail (GIMP_IS_IMAGE (image)); if (active == gimp_image_get_quick_mask_state (image)) return; + private = GIMP_IMAGE_GET_PRIVATE (image); + /* Keep track of the state so that we can make the right drawable * active again when deactiviting quick mask (see bug #134371). */ - if (image->quick_mask_state) - channel_was_active = (image->quick_mask_state & CHANNEL_WAS_ACTIVE) != 0; + if (private->quick_mask_state) + channel_was_active = (private->quick_mask_state & CHANNEL_WAS_ACTIVE) != 0; else channel_was_active = gimp_image_get_active_channel (image) != NULL; - /* Set image->quick_mask_state early so we can return early when + /* Set private->quick_mask_state early so we can return early when * being called recursively. */ - image->quick_mask_state = (active - ? TRUE | (channel_was_active ? - CHANNEL_WAS_ACTIVE : 0) - : FALSE); + private->quick_mask_state = (active + ? TRUE | (channel_was_active ? + CHANNEL_WAS_ACTIVE : 0) + : FALSE); selection = gimp_image_get_mask (image); mask = gimp_image_get_quick_mask (image); @@ -93,7 +97,7 @@ gimp_image_set_quick_mask_state (GimpImage *image, gimp_image_get_width (image), gimp_image_get_height (image), GIMP_IMAGE_QUICK_MASK_NAME, - &image->quick_mask_color); + &private->quick_mask_color); /* Clear the mask */ gimp_channel_clear (mask, NULL, FALSE); @@ -108,12 +112,12 @@ gimp_image_set_quick_mask_state (GimpImage *image, /* Clear the selection */ gimp_channel_clear (selection, NULL, TRUE); - gimp_channel_set_color (mask, &image->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); } - if (image->quick_mask_inverted) + if (private->quick_mask_inverted) gimp_channel_invert (mask, FALSE); gimp_image_add_channel (image, mask, NULL, 0, TRUE); @@ -130,7 +134,7 @@ gimp_image_set_quick_mask_state (GimpImage *image, gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_QUICK_MASK, _("Disable Quick Mask")); - if (image->quick_mask_inverted) + if (private->quick_mask_inverted) gimp_channel_invert (mask, TRUE); if (floating_sel && @@ -156,7 +160,7 @@ gimp_image_get_quick_mask_state (const GimpImage *image) { g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); - return image->quick_mask_state; + return GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_state; } void @@ -168,7 +172,7 @@ gimp_image_set_quick_mask_color (GimpImage *image, g_return_if_fail (GIMP_IS_IMAGE (image)); g_return_if_fail (color != NULL); - image->quick_mask_color = *color; + GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color = *color; quick_mask = gimp_image_get_quick_mask (image); if (quick_mask) @@ -182,7 +186,7 @@ gimp_image_get_quick_mask_color (const GimpImage *image, g_return_if_fail (GIMP_IS_IMAGE (image)); g_return_if_fail (color != NULL); - *color = image->quick_mask_color; + *color = GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color; } GimpChannel * @@ -196,9 +200,13 @@ gimp_image_get_quick_mask (const GimpImage *image) void gimp_image_quick_mask_invert (GimpImage *image) { + GimpImagePrivate *private; + g_return_if_fail (GIMP_IS_IMAGE (image)); - if (image->quick_mask_state) + private = GIMP_IMAGE_GET_PRIVATE (image); + + if (private->quick_mask_state) { GimpChannel *quick_mask = gimp_image_get_quick_mask (image); @@ -206,5 +214,13 @@ gimp_image_quick_mask_invert (GimpImage *image) gimp_channel_invert (quick_mask, TRUE); } - image->quick_mask_inverted = ! image->quick_mask_inverted; + private->quick_mask_inverted = ! private->quick_mask_inverted; +} + +gboolean +gimp_image_get_quick_mask_inverted (const GimpImage *image) +{ + g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); + + return GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_inverted; } diff --git a/app/core/gimpimage-quick-mask.h b/app/core/gimpimage-quick-mask.h index 2f2760e263..f0d05cd7e7 100644 --- a/app/core/gimpimage-quick-mask.h +++ b/app/core/gimpimage-quick-mask.h @@ -25,18 +25,19 @@ #define GIMP_IMAGE_QUICK_MASK_NAME "Qmask" -void gimp_image_set_quick_mask_state (GimpImage *image, - gboolean active); -gboolean gimp_image_get_quick_mask_state (const GimpImage *image); +void gimp_image_set_quick_mask_state (GimpImage *image, + gboolean active); +gboolean gimp_image_get_quick_mask_state (const GimpImage *image); -void gimp_image_set_quick_mask_color (GimpImage *image, - const GimpRGB *color); -void gimp_image_get_quick_mask_color (const GimpImage *image, - GimpRGB *color); +void gimp_image_set_quick_mask_color (GimpImage *image, + const GimpRGB *color); +void gimp_image_get_quick_mask_color (const GimpImage *image, + GimpRGB *color); -GimpChannel * gimp_image_get_quick_mask (const GimpImage *image); +GimpChannel * gimp_image_get_quick_mask (const GimpImage *image); -void gimp_image_quick_mask_invert (GimpImage *image); +void gimp_image_quick_mask_invert (GimpImage *image); +gboolean gimp_image_get_quick_mask_inverted (const GimpImage *image); #endif /* __GIMP_IMAGE_QUICK_MASK_H__ */ diff --git a/app/core/gimpimage.c b/app/core/gimpimage.c index f16392d803..d82b1c9d09 100644 --- a/app/core/gimpimage.c +++ b/app/core/gimpimage.c @@ -667,9 +667,9 @@ gimp_image_init (GimpImage *image) private->active[i] = TRUE; } - image->quick_mask_state = FALSE; - image->quick_mask_inverted = FALSE; - gimp_rgba_set (&image->quick_mask_color, 1.0, 0.0, 0.0, 0.5); + 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); image->undo_stack = gimp_undo_stack_new (image); image->redo_stack = gimp_undo_stack_new (image); @@ -1349,7 +1349,7 @@ gimp_image_channel_color_changed (GimpChannel *channel, if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME, gimp_object_get_name (channel))) { - image->quick_mask_color = channel->color; + GIMP_IMAGE_GET_PRIVATE (image)->quick_mask_color = channel->color; } } @@ -1885,6 +1885,9 @@ gimp_image_get_visible_array (const GimpImage *image, components[i] = private->visible[i]; } + +/* emitting image signals */ + void gimp_image_mode_changed (GimpImage *image) { diff --git a/app/core/gimpimage.h b/app/core/gimpimage.h index 1454e4d45c..dd2bb57804 100644 --- a/app/core/gimpimage.h +++ b/app/core/gimpimage.h @@ -105,10 +105,6 @@ struct _GimpImage Gimp *gimp; /* the GIMP the image belongs to*/ - 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 */ - /* Undo apparatus */ GimpUndoStack *undo_stack; /* stack for undo operations */ GimpUndoStack *redo_stack; /* stack for redo operations */ @@ -264,6 +260,9 @@ gboolean gimp_image_get_component_visible (const GimpImage *image, void gimp_image_get_visible_array (const GimpImage *image, gboolean *components); + +/* emitting image signals */ + void gimp_image_mode_changed (GimpImage *image); void gimp_image_alpha_changed (GimpImage *image); void gimp_image_invalidate (GimpImage *image, diff --git a/app/display/gimpdisplayshell-handlers.c b/app/display/gimpdisplayshell-handlers.c index 52c15db833..69b68e212e 100644 --- a/app/display/gimpdisplayshell-handlers.c +++ b/app/display/gimpdisplayshell-handlers.c @@ -33,6 +33,7 @@ #include "core/gimpcontainer.h" #include "core/gimpimage.h" #include "core/gimpimage-grid.h" +#include "core/gimpimage-quick-mask.h" #include "core/gimpitem.h" #include "core/gimptreehandler.h" @@ -484,6 +485,7 @@ gimp_display_shell_quick_mask_changed_handler (GimpImage *image, GimpDisplayShell *shell) { GtkImage *gtk_image; + gboolean quick_mask_state; gtk_image = GTK_IMAGE (gtk_bin_get_child (GTK_BIN (shell->quick_mask_button))); @@ -491,10 +493,12 @@ gimp_display_shell_quick_mask_changed_handler (GimpImage *image, gimp_display_shell_quick_mask_toggled, shell); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (shell->quick_mask_button), - image->quick_mask_state); + quick_mask_state = gimp_image_get_quick_mask_state (image); - if (image->quick_mask_state) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (shell->quick_mask_button), + quick_mask_state); + + if (quick_mask_state) gtk_image_set_from_stock (gtk_image, GIMP_STOCK_QUICK_MASK_ON, GTK_ICON_SIZE_MENU); else