[gimp] Move the quick mask members to GimpImagePrivate

[Michael Natterer <mitch src gnome org>]

commit 4c1ec79281c6ba83eea5e071c51619491a624de8
Author: Michael Natterer <mitch gimp org>
Date:   Thu Feb 4 09:49:45 2010 +0100

    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 |    8 +++-
 9 files changed, 88 insertions(+), 46 deletions(-)
---
diff --git a/app/actions/quick-mask-actions.c b/app/actions/quick-mask-actions.c
index f76aea8..2255143 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 42f9ce9..b30890d 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 ccc5fb2..3e8188b 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 f41bfe7..c08952a 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 8179c5d..46db050 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 2f2760e..f0d05cd 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 f16392d..d82b1c9 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 1454e4d..dd2bb57 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 52c15db..69b68e2 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);
 
+  quick_mask_state = gimp_image_get_quick_mask_state (image);
+
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (shell->quick_mask_button),
-                                image->quick_mask_state);
+                                quick_mask_state);
 
-  if (image->quick_mask_state)
+  if (quick_mask_state)
     gtk_image_set_from_stock (gtk_image, GIMP_STOCK_QUICK_MASK_ON,
                               GTK_ICON_SIZE_MENU);
   else