[gimp/gimp-2-10] app: turn GimpSamplePoint into a GObject, just like GimpGuide



commit 3c9de4b59ef212944f6fbc205edea51f61f5d572
Author: Michael Natterer <mitch gimp org>
Date:   Sun Jul 15 15:58:24 2018 +0200

    app: turn GimpSamplePoint into a GObject, just like GimpGuide
    
    In fact, they are so similar now, they should get a common abstract
    parent class.
    
    (cherry picked from commit b4c244b8392ba3393786f560e95d786e23bf21fc)

 app/core/core-types.h              |   2 +-
 app/core/gimpimage-sample-points.c |  17 ++--
 app/core/gimpimage-undo-push.c     |   2 +-
 app/core/gimpimage.c               |  20 ++--
 app/core/gimpsamplepoint.c         | 200 +++++++++++++++++++++++++++++--------
 app/core/gimpsamplepoint.h         |  34 +++++--
 app/core/gimpsamplepointundo.c     |  20 ++--
 app/tools/gimpsamplepointtool.c    |   5 +-
 8 files changed, 219 insertions(+), 81 deletions(-)
---
diff --git a/app/core/core-types.h b/app/core/core-types.h
index ed42ecfffa..cab9f626cd 100644
--- a/app/core/core-types.h
+++ b/app/core/core-types.h
@@ -185,6 +185,7 @@ typedef struct _GimpObjectQueue                 GimpObjectQueue;
 typedef struct _GimpParasiteList                GimpParasiteList;
 typedef struct _GimpPdbProgress                 GimpPdbProgress;
 typedef struct _GimpProjection                  GimpProjection;
+typedef struct _GimpSamplePoint                 GimpSamplePoint;
 typedef struct _GimpSettings                    GimpSettings;
 typedef struct _GimpSubProgress                 GimpSubProgress;
 typedef struct _GimpTag                         GimpTag;
@@ -209,7 +210,6 @@ typedef struct _GimpBoundSeg                    GimpBoundSeg;
 typedef struct _GimpCoords                      GimpCoords;
 typedef struct _GimpGradientSegment             GimpGradientSegment;
 typedef struct _GimpPaletteEntry                GimpPaletteEntry;
-typedef struct _GimpSamplePoint                 GimpSamplePoint;
 typedef struct _GimpScanConvert                 GimpScanConvert;
 typedef struct _GimpTempBuf                     GimpTempBuf;
 typedef         guint32                         GimpTattoo;
diff --git a/app/core/gimpimage-sample-points.c b/app/core/gimpimage-sample-points.c
index 403e37588f..dd2a35bad3 100644
--- a/app/core/gimpimage-sample-points.c
+++ b/app/core/gimpimage-sample-points.c
@@ -53,7 +53,7 @@ gimp_image_add_sample_point_at_pos (GimpImage *image,
                                        sample_point);
 
   gimp_image_add_sample_point (image, sample_point, x, y);
-  gimp_sample_point_unref (sample_point);
+  g_object_unref (sample_point);
 
   return sample_point;
 }
@@ -67,14 +67,14 @@ gimp_image_add_sample_point (GimpImage       *image,
   GimpImagePrivate *private;
 
   g_return_if_fail (GIMP_IS_IMAGE (image));
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
 
   private = GIMP_IMAGE_GET_PRIVATE (image);
 
   private->sample_points = g_list_append (private->sample_points, sample_point);
 
   gimp_sample_point_set_position (sample_point, x, y);
-  gimp_sample_point_ref (sample_point);
+  g_object_ref (sample_point);
 
   gimp_image_sample_point_added (image, sample_point);
 }
@@ -87,7 +87,7 @@ gimp_image_remove_sample_point (GimpImage       *image,
   GimpImagePrivate *private;
 
   g_return_if_fail (GIMP_IS_IMAGE (image));
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
 
   private = GIMP_IMAGE_GET_PRIVATE (image);
 
@@ -97,11 +97,14 @@ gimp_image_remove_sample_point (GimpImage       *image,
                                        sample_point);
 
   private->sample_points = g_list_remove (private->sample_points, sample_point);
+  gimp_sample_point_removed (sample_point);
 
   gimp_image_sample_point_removed (image, sample_point);
 
-  gimp_sample_point_set_position (sample_point, -1, -1);
-  gimp_sample_point_unref (sample_point);
+  gimp_sample_point_set_position (sample_point,
+                                  GIMP_SAMPLE_POINT_POSITION_UNDEFINED,
+                                  GIMP_SAMPLE_POINT_POSITION_UNDEFINED);
+  g_object_unref (sample_point);
 }
 
 void
@@ -112,7 +115,7 @@ gimp_image_move_sample_point (GimpImage       *image,
                               gboolean         push_undo)
 {
   g_return_if_fail (GIMP_IS_IMAGE (image));
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
   g_return_if_fail (x >= 0);
   g_return_if_fail (y >= 0);
   g_return_if_fail (x < gimp_image_get_width  (image));
diff --git a/app/core/gimpimage-undo-push.c b/app/core/gimpimage-undo-push.c
index 672fbf0c63..bb1de3b29b 100644
--- a/app/core/gimpimage-undo-push.c
+++ b/app/core/gimpimage-undo-push.c
@@ -228,7 +228,7 @@ gimp_image_undo_push_sample_point (GimpImage       *image,
                                    GimpSamplePoint *sample_point)
 {
   g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
-  g_return_val_if_fail (sample_point != NULL, NULL);
+  g_return_val_if_fail (GIMP_IS_SAMPLE_POINT (sample_point), NULL);
 
   return gimp_image_undo_push (image, GIMP_TYPE_SAMPLE_POINT_UNDO,
                                GIMP_UNDO_SAMPLE_POINT, undo_desc,
diff --git a/app/core/gimpimage.c b/app/core/gimpimage.c
index da7d8bc184..ad209ec9a7 100644
--- a/app/core/gimpimage.c
+++ b/app/core/gimpimage.c
@@ -486,9 +486,9 @@ gimp_image_class_init (GimpImageClass *klass)
                   G_SIGNAL_RUN_FIRST,
                   G_STRUCT_OFFSET (GimpImageClass, sample_point_added),
                   NULL, NULL,
-                  gimp_marshal_VOID__POINTER,
+                  gimp_marshal_VOID__OBJECT,
                   G_TYPE_NONE, 1,
-                  G_TYPE_POINTER);
+                  GIMP_TYPE_SAMPLE_POINT);
 
   gimp_image_signals[SAMPLE_POINT_REMOVED] =
     g_signal_new ("sample-point-removed",
@@ -496,9 +496,9 @@ gimp_image_class_init (GimpImageClass *klass)
                   G_SIGNAL_RUN_FIRST,
                   G_STRUCT_OFFSET (GimpImageClass, sample_point_removed),
                   NULL, NULL,
-                  gimp_marshal_VOID__POINTER,
+                  gimp_marshal_VOID__OBJECT,
                   G_TYPE_NONE, 1,
-                  G_TYPE_POINTER);
+                  GIMP_TYPE_SAMPLE_POINT);
 
   gimp_image_signals[SAMPLE_POINT_MOVED] =
     g_signal_new ("sample-point-moved",
@@ -506,9 +506,9 @@ gimp_image_class_init (GimpImageClass *klass)
                   G_SIGNAL_RUN_FIRST,
                   G_STRUCT_OFFSET (GimpImageClass, sample_point_moved),
                   NULL, NULL,
-                  gimp_marshal_VOID__POINTER,
+                  gimp_marshal_VOID__OBJECT,
                   G_TYPE_NONE, 1,
-                  G_TYPE_POINTER);
+                  GIMP_TYPE_SAMPLE_POINT);
 
   gimp_image_signals[PARASITE_ATTACHED] =
     g_signal_new ("parasite-attached",
@@ -1084,7 +1084,7 @@ gimp_image_finalize (GObject *object)
   if (private->sample_points)
     {
       g_list_free_full (private->sample_points,
-                        (GDestroyNotify) gimp_sample_point_unref);
+                        (GDestroyNotify) g_object_unref);
       private->sample_points = NULL;
     }
 
@@ -3146,7 +3146,7 @@ gimp_image_sample_point_added (GimpImage       *image,
                                GimpSamplePoint *sample_point)
 {
   g_return_if_fail (GIMP_IS_IMAGE (image));
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
 
   g_signal_emit (image, gimp_image_signals[SAMPLE_POINT_ADDED], 0,
                  sample_point);
@@ -3157,7 +3157,7 @@ gimp_image_sample_point_removed (GimpImage       *image,
                                  GimpSamplePoint *sample_point)
 {
   g_return_if_fail (GIMP_IS_IMAGE (image));
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
 
   g_signal_emit (image, gimp_image_signals[SAMPLE_POINT_REMOVED], 0,
                  sample_point);
@@ -3168,7 +3168,7 @@ gimp_image_sample_point_moved (GimpImage       *image,
                                GimpSamplePoint *sample_point)
 {
   g_return_if_fail (GIMP_IS_IMAGE (image));
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
 
   g_signal_emit (image, gimp_image_signals[SAMPLE_POINT_MOVED], 0,
                  sample_point);
diff --git a/app/core/gimpsamplepoint.c b/app/core/gimpsamplepoint.c
index 0246f0d3f1..43068a5609 100644
--- a/app/core/gimpsamplepoint.c
+++ b/app/core/gimpsamplepoint.c
@@ -17,68 +17,181 @@
 
 #include "config.h"
 
-#include <glib-object.h>
+#include <gio/gio.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpconfig/gimpconfig.h"
 
 #include "core-types.h"
 
+#include "gimpmarshal.h"
 #include "gimpsamplepoint.h"
 
 
-GType
-gimp_sample_point_get_type (void)
+enum
 {
-  static GType type = 0;
+  REMOVED,
+  LAST_SIGNAL
+};
 
-  if (! type)
-    type = g_boxed_type_register_static ("GimpSamplePoint",
-                                         (GBoxedCopyFunc) gimp_sample_point_ref,
-                                         (GBoxedFreeFunc) gimp_sample_point_unref);
+enum
+{
+  PROP_0,
+  PROP_ID,
+  PROP_POSITION_X,
+  PROP_POSITION_Y
+};
 
-  return type;
-}
 
-GimpSamplePoint *
-gimp_sample_point_new (guint32 sample_point_ID)
+struct _GimpSamplePointPrivate
 {
-  GimpSamplePoint *sample_point;
+  guint32  sample_point_ID;
+  gint     position_x;
+  gint     position_y;
+};
 
-  sample_point = g_slice_new0 (GimpSamplePoint);
 
-  sample_point->ref_count       = 1;
-  sample_point->sample_point_ID = sample_point_ID;
-  sample_point->x               = -1;
-  sample_point->y               = -1;
+static void   gimp_sample_point_get_property (GObject      *object,
+                                              guint         property_id,
+                                              GValue       *value,
+                                              GParamSpec   *pspec);
+static void   gimp_sample_point_set_property (GObject      *object,
+                                              guint         property_id,
+                                              const GValue *value,
+                                              GParamSpec   *pspec);
 
-  return sample_point;
-}
 
-GimpSamplePoint *
-gimp_sample_point_ref (GimpSamplePoint *sample_point)
-{
-  g_return_val_if_fail (sample_point != NULL, NULL);
+G_DEFINE_TYPE (GimpSamplePoint, gimp_sample_point, G_TYPE_OBJECT)
+
+static guint gimp_sample_point_signals[LAST_SIGNAL] = { 0 };
 
-  sample_point->ref_count++;
 
-  return sample_point;
+static void
+gimp_sample_point_class_init (GimpSamplePointClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  gimp_sample_point_signals[REMOVED] =
+    g_signal_new ("removed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (GimpSamplePointClass, removed),
+                  NULL, NULL,
+                  gimp_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+
+  object_class->get_property = gimp_sample_point_get_property;
+  object_class->set_property = gimp_sample_point_set_property;
+
+  klass->removed             = NULL;
+
+  g_object_class_install_property (object_class, PROP_ID,
+                                   g_param_spec_uint ("id", NULL, NULL,
+                                                      0, G_MAXUINT32, 0,
+                                                      G_PARAM_CONSTRUCT_ONLY |
+                                                      GIMP_PARAM_READWRITE));
+
+  GIMP_CONFIG_PROP_INT (object_class, PROP_POSITION_X,
+                        "position-x",
+                        NULL, NULL,
+                        GIMP_SAMPLE_POINT_POSITION_UNDEFINED,
+                        GIMP_MAX_IMAGE_SIZE,
+                        GIMP_SAMPLE_POINT_POSITION_UNDEFINED,
+                        0);
+
+  GIMP_CONFIG_PROP_INT (object_class, PROP_POSITION_Y,
+                        "position-y",
+                        NULL, NULL,
+                        GIMP_SAMPLE_POINT_POSITION_UNDEFINED,
+                        GIMP_MAX_IMAGE_SIZE,
+                        GIMP_SAMPLE_POINT_POSITION_UNDEFINED,
+                        0);
+
+  g_type_class_add_private (klass, sizeof (GimpSamplePointPrivate));
 }
 
-void
-gimp_sample_point_unref (GimpSamplePoint *sample_point)
+static void
+gimp_sample_point_init (GimpSamplePoint *sample_point)
+{
+  sample_point->priv = G_TYPE_INSTANCE_GET_PRIVATE (sample_point,
+                                                    GIMP_TYPE_SAMPLE_POINT,
+                                                    GimpSamplePointPrivate);
+}
+
+static void
+gimp_sample_point_get_property (GObject    *object,
+                                guint       property_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
 {
-  g_return_if_fail (sample_point != NULL);
+  GimpSamplePoint *sample_point = GIMP_SAMPLE_POINT (object);
+
+  switch (property_id)
+    {
+    case PROP_ID:
+      g_value_set_uint (value, sample_point->priv->sample_point_ID);
+      break;
+    case PROP_POSITION_X:
+      g_value_set_int (value, sample_point->priv->position_x);
+      break;
+    case PROP_POSITION_Y:
+      g_value_set_int (value, sample_point->priv->position_y);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
 
-  sample_point->ref_count--;
+static void
+gimp_sample_point_set_property (GObject      *object,
+                                guint         property_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  GimpSamplePoint *sample_point = GIMP_SAMPLE_POINT (object);
+
+  switch (property_id)
+    {
+    case PROP_ID:
+      sample_point->priv->sample_point_ID = g_value_get_uint (value);
+      break;
+    case PROP_POSITION_X:
+      sample_point->priv->position_x = g_value_get_int (value);
+      break;
+    case PROP_POSITION_Y:
+      sample_point->priv->position_y = g_value_get_int (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
 
-  if (sample_point->ref_count < 1)
-    g_slice_free (GimpSamplePoint, sample_point);
+GimpSamplePoint *
+gimp_sample_point_new (guint32 sample_point_ID)
+{
+  return g_object_new (GIMP_TYPE_SAMPLE_POINT,
+                       "id", sample_point_ID,
+                       NULL);
 }
 
 guint32
 gimp_sample_point_get_ID (GimpSamplePoint *sample_point)
 {
-  g_return_val_if_fail (sample_point != NULL, 0);
+  g_return_val_if_fail (GIMP_IS_SAMPLE_POINT (sample_point), 0);
+
+  return sample_point->priv->sample_point_ID;
+}
+
+void
+gimp_sample_point_removed (GimpSamplePoint *sample_point)
+{
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
 
-  return sample_point->sample_point_ID;
+  g_signal_emit (sample_point, gimp_sample_point_signals[REMOVED], 0);
 }
 
 void
@@ -86,12 +199,12 @@ gimp_sample_point_get_position (GimpSamplePoint *sample_point,
                                 gint            *position_x,
                                 gint            *position_y)
 {
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
   g_return_if_fail (position_x != NULL);
   g_return_if_fail (position_y != NULL);
 
-  *position_x = sample_point->x;
-  *position_y = sample_point->y;
+  *position_x = sample_point->priv->position_x;
+  *position_y = sample_point->priv->position_y;
 }
 
 void
@@ -99,8 +212,15 @@ gimp_sample_point_set_position (GimpSamplePoint *sample_point,
                                 gint             position_x,
                                 gint             position_y)
 {
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
+
+  sample_point->priv->position_x = position_x;
+  sample_point->priv->position_y = position_y;
+
+  g_object_freeze_notify (G_OBJECT (sample_point));
+
+  g_object_notify (G_OBJECT (sample_point), "position-x");
+  g_object_notify (G_OBJECT (sample_point), "position-y");
 
-  sample_point->x = position_x;
-  sample_point->y = position_y;
+  g_object_thaw_notify (G_OBJECT (sample_point));
 }
diff --git a/app/core/gimpsamplepoint.h b/app/core/gimpsamplepoint.h
index c2ab9667f6..fffb1fec5c 100644
--- a/app/core/gimpsamplepoint.h
+++ b/app/core/gimpsamplepoint.h
@@ -19,15 +19,33 @@
 #define __GIMP_SAMPLE_POINT_H__
 
 
-#define GIMP_TYPE_SAMPLE_POINT (gimp_sample_point_get_type ())
+#define GIMP_SAMPLE_POINT_POSITION_UNDEFINED G_MININT
 
 
+#define GIMP_TYPE_SAMPLE_POINT            (gimp_sample_point_get_type ())
+#define GIMP_SAMPLE_POINT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_SAMPLE_POINT, 
GimpSamplePoint))
+#define GIMP_SAMPLE_POINT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_SAMPLE_POINT, 
GimpSamplePointClass))
+#define GIMP_IS_SAMPLE_POINT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_SAMPLE_POINT))
+#define GIMP_IS_SAMPLE_POINT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_SAMPLE_POINT))
+#define GIMP_SAMPLE_POINT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_SAMPLE_POINT, 
GimpSamplePointClass))
+
+
+typedef struct _GimpSamplePointPrivate GimpSamplePointPrivate;
+typedef struct _GimpSamplePointClass   GimpSamplePointClass;
+
 struct _GimpSamplePoint
 {
-  gint     ref_count;
-  guint32  sample_point_ID;
-  gint     x;
-  gint     y;
+  GObject                 parent_instance;
+
+  GimpSamplePointPrivate *priv;
+};
+
+struct _GimpSamplePointClass
+{
+  GObjectClass  parent_class;
+
+  /*  signals  */
+  void (* removed) (GimpSamplePoint *sample_point);
 };
 
 
@@ -35,11 +53,10 @@ GType             gimp_sample_point_get_type (void) G_GNUC_CONST;
 
 GimpSamplePoint * gimp_sample_point_new          (guint32          sample_point_ID);
 
-GimpSamplePoint * gimp_sample_point_ref          (GimpSamplePoint *sample_point);
-void              gimp_sample_point_unref        (GimpSamplePoint *sample_point);
-
 guint32           gimp_sample_point_get_ID       (GimpSamplePoint *sample_point);
 
+void              gimp_sample_point_removed      (GimpSamplePoint *sample_point);
+
 void              gimp_sample_point_get_position (GimpSamplePoint *sample_point,
                                                   gint            *position_x,
                                                   gint            *position_y);
@@ -47,4 +64,5 @@ void              gimp_sample_point_set_position (GimpSamplePoint *sample_point,
                                                   gint             position_x,
                                                   gint             position_y);
 
+
 #endif /* __GIMP_SAMPLE_POINT_H__ */
diff --git a/app/core/gimpsamplepointundo.c b/app/core/gimpsamplepointundo.c
index 61c653932f..ccffc8413c 100644
--- a/app/core/gimpsamplepointundo.c
+++ b/app/core/gimpsamplepointundo.c
@@ -71,10 +71,10 @@ gimp_sample_point_undo_class_init (GimpSamplePointUndoClass *klass)
   undo_class->free           = gimp_sample_point_undo_free;
 
   g_object_class_install_property (object_class, PROP_SAMPLE_POINT,
-                                   g_param_spec_boxed ("sample-point", NULL, NULL,
-                                                       GIMP_TYPE_SAMPLE_POINT,
-                                                       GIMP_PARAM_READWRITE |
-                                                       G_PARAM_CONSTRUCT_ONLY));
+                                   g_param_spec_object ("sample-point", NULL, NULL,
+                                                        GIMP_TYPE_SAMPLE_POINT,
+                                                        GIMP_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
 }
 
 static void
@@ -89,7 +89,7 @@ gimp_sample_point_undo_constructed (GObject *object)
 
   G_OBJECT_CLASS (parent_class)->constructed (object);
 
-  gimp_assert (sample_point_undo->sample_point != NULL);
+  gimp_assert (GIMP_IS_SAMPLE_POINT (sample_point_undo->sample_point));
 
   gimp_sample_point_get_position (sample_point_undo->sample_point,
                                   &sample_point_undo->x,
@@ -107,7 +107,7 @@ gimp_sample_point_undo_set_property (GObject      *object,
   switch (property_id)
     {
     case PROP_SAMPLE_POINT:
-      sample_point_undo->sample_point = g_value_dup_boxed (value);
+      sample_point_undo->sample_point = g_value_dup_object (value);
       break;
 
     default:
@@ -127,7 +127,7 @@ gimp_sample_point_undo_get_property (GObject    *object,
   switch (property_id)
     {
     case PROP_SAMPLE_POINT:
-      g_value_set_boxed (value, sample_point_undo->sample_point);
+      g_value_set_object (value, sample_point_undo->sample_point);
       break;
 
     default:
@@ -149,14 +149,14 @@ gimp_sample_point_undo_pop (GimpUndo              *undo,
 
   gimp_sample_point_get_position (sample_point_undo->sample_point, &x, &y);
 
-  if (x == -1)
+  if (x == GIMP_SAMPLE_POINT_POSITION_UNDEFINED)
     {
       gimp_image_add_sample_point (undo->image,
                                    sample_point_undo->sample_point,
                                    sample_point_undo->x,
                                    sample_point_undo->y);
     }
-  else if (sample_point_undo->x == -1)
+  else if (sample_point_undo->x == GIMP_SAMPLE_POINT_POSITION_UNDEFINED)
     {
       gimp_image_remove_sample_point (undo->image,
                                       sample_point_undo->sample_point, FALSE);
@@ -181,7 +181,7 @@ gimp_sample_point_undo_free (GimpUndo     *undo,
 {
   GimpSamplePointUndo *sample_point_undo = GIMP_SAMPLE_POINT_UNDO (undo);
 
-  g_clear_pointer (&sample_point_undo->sample_point, gimp_sample_point_unref);
+  g_clear_object (&sample_point_undo->sample_point);
 
   GIMP_UNDO_CLASS (parent_class)->free (undo, undo_mode);
 }
diff --git a/app/tools/gimpsamplepointtool.c b/app/tools/gimpsamplepointtool.c
index ad98679f35..8d0c153f3d 100644
--- a/app/tools/gimpsamplepointtool.c
+++ b/app/tools/gimpsamplepointtool.c
@@ -41,9 +41,6 @@
 #include "gimp-intl.h"
 
 
-#define GIMP_SAMPLE_POINT_POSITION_UNDEFINED G_MININT
-
-
 /*  local function prototypes  */
 
 static void   gimp_sample_point_tool_button_release (GimpTool              *tool,
@@ -370,7 +367,7 @@ gimp_sample_point_tool_start_edit (GimpTool        *parent_tool,
 {
   g_return_if_fail (GIMP_IS_TOOL (parent_tool));
   g_return_if_fail (GIMP_IS_DISPLAY (display));
-  g_return_if_fail (sample_point != NULL);
+  g_return_if_fail (GIMP_IS_SAMPLE_POINT (sample_point));
 
   gimp_sample_point_tool_start (parent_tool, display, sample_point);
 }


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]