GNOME.org
 

[gtk+/wip/baedert/gtkimageview: 2072/2075] imageview: Comments

commit 8853e35f8b575570c21ab074b77c17afe15a22fc
Author: Timm Bäder <mail baedert org>
Date:   Sat Mar 19 12:21:58 2016 +0100

    imageview: Comments

 gtk/gtkimageview.c |  158 +++++++++++++++++++++++++++++++++-------------------
 1 files changed, 100 insertions(+), 58 deletions(-)
---
diff --git a/gtk/gtkimageview.c b/gtk/gtkimageview.c
index 7989266..142ec45 100644
--- a/gtk/gtkimageview.c
+++ b/gtk/gtkimageview.c
@@ -39,7 +39,7 @@
  * the scale factor of the surface is taken instead). This scale factor can be interpreted
  * the same as the #GtkWidget:scale-factor property of #GtkWidget, but for the given image.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 
 #include "config.h"
@@ -52,6 +52,7 @@
 #include "gtkscrollable.h"
 #include "gtkadjustment.h"
 #include "gtkabstractimage.h"
+#include "gtkprogresstrackerprivate.h"
 #include <gdk/gdkcairo.h>
 #include <math.h>
 
@@ -83,6 +84,8 @@ typedef struct
 struct _GtkImageViewPrivate
 {
   GtkAbstractImage *image;
+  int image_width;
+  int image_height;
   GdkWindow *event_window;
 
   double   scale;
@@ -100,6 +103,9 @@ struct _GtkImageViewPrivate
   gboolean in_angle_transition : 1;
   gboolean in_scale_transition : 1;
 
+  GtkProgressTracker scale_tracker;
+  GtkProgressTracker angle_tracker;
+
   GtkGesture *rotate_gesture;
   double      gesture_start_angle;
   double      visible_angle;
@@ -121,11 +127,9 @@ struct _GtkImageViewPrivate
 
   /* Transitions */
   double transition_start_angle;
-  gint64 angle_transition_start;
   guint  angle_transition_id;
 
   double transition_start_scale;
-  gint64 scale_transition_start;
   guint  scale_transition_id;
 
   /* We cache the bounding box size so we don't have to
@@ -267,8 +271,24 @@ static void
 image_changed_cb (GtkAbstractImage *image, gpointer user_data)
 {
   GtkImageView *image_view = user_data;
+  GtkImageViewPrivate *priv = gtk_image_view_get_instance_private (image_view);
+  gboolean size_changed = FALSE;
 
-  gtk_widget_queue_draw (GTK_WIDGET (image_view));
+  if (gtk_abstract_image_get_width (image)  != priv->image_width ||
+      gtk_abstract_image_get_height (image) != priv->image_height)
+    {
+      size_changed = TRUE;
+      priv->size_valid = FALSE;
+      priv->image_width  = gtk_abstract_image_get_width (image);
+      priv->image_height = gtk_abstract_image_get_height (image);
+
+      gtk_image_view_update_adjustments (image_view);
+    }
+
+  if (priv->fit_allocation || !size_changed)
+    gtk_widget_queue_draw (GTK_WIDGET (image_view));
+  else
+    gtk_widget_queue_resize (GTK_WIDGET (image_view));
 }
 
 static gboolean
@@ -279,10 +299,13 @@ scale_frameclock_cb (GtkWidget     *widget,
   GtkImageView *image_view = GTK_IMAGE_VIEW (widget);
   GtkImageViewPrivate *priv = gtk_image_view_get_instance_private (image_view);
   State state;
-  gint64 now = gdk_frame_clock_get_frame_time (frame_clock);
+  double t;
+  double new_scale;
+
+  gtk_progress_tracker_advance_frame (&priv->scale_tracker, gdk_frame_clock_get_frame_time (frame_clock));
+  t = gtk_progress_tracker_get_ease_out_cubic (&priv->scale_tracker, FALSE);
 
-  double t = (now - priv->scale_transition_start) / TRANSITION_DURATION;
-  double new_scale = (priv->scale - priv->transition_start_scale) * t;
+  new_scale = (priv->scale - priv->transition_start_scale) * t;
 
   gtk_image_view_get_current_state (image_view, &state);
 
@@ -309,7 +332,7 @@ scale_frameclock_cb (GtkWidget     *widget,
   else
     gtk_widget_queue_resize (widget);
 
-  if (t >= 1.0)
+  if (gtk_progress_tracker_get_state (&priv->scale_tracker) == GTK_PROGRESS_STATE_AFTER)
     {
       priv->scale_transition_id = 0;
       return G_SOURCE_REMOVE;
@@ -330,8 +353,8 @@ gtk_image_view_animate_to_scale (GtkImageView *image_view)
   priv->in_scale_transition = TRUE;
   priv->visible_scale = priv->scale;
   priv->transition_start_scale = priv->scale;
-  priv->scale_transition_start = gdk_frame_clock_get_frame_time (gtk_widget_get_frame_clock (GTK_WIDGET 
(image_view)));
 
+  gtk_progress_tracker_start (&priv->scale_tracker, TRANSITION_DURATION, 0, 1.0);
   priv->scale_transition_id = gtk_widget_add_tick_callback (GTK_WIDGET (image_view),
                                                             scale_frameclock_cb,
                                                             NULL, NULL);
@@ -345,7 +368,8 @@ angle_frameclock_cb (GtkWidget     *widget,
   GtkImageView *image_view = GTK_IMAGE_VIEW (widget);
   GtkImageViewPrivate *priv = gtk_image_view_get_instance_private (image_view);
   int direction = GPOINTER_TO_INT (user_data);
-  gint64 now = gdk_frame_clock_get_frame_time (frame_clock);
+  double new_angle;
+  double t;
   State state;
   double target_angle = priv->angle;
 
@@ -354,8 +378,9 @@ angle_frameclock_cb (GtkWidget     *widget,
   else if (direction == 0 && target_angle > priv->transition_start_angle)
     target_angle -= 360.0;
 
-  double t = (now - priv->angle_transition_start) / TRANSITION_DURATION;
-  double new_angle = (target_angle - priv->transition_start_angle) * t;
+  gtk_progress_tracker_advance_frame (&priv->angle_tracker, gdk_frame_clock_get_frame_time (frame_clock));
+  t = gtk_progress_tracker_get_ease_out_cubic (&priv->angle_tracker, FALSE);
+  new_angle = (target_angle - priv->transition_start_angle) * t;
 
   gtk_image_view_get_current_state (image_view, &state);
 
@@ -382,7 +407,7 @@ angle_frameclock_cb (GtkWidget     *widget,
   else
     gtk_widget_queue_resize (widget);
 
-  if (t >= 1.0)
+  if (gtk_progress_tracker_get_state (&priv->angle_tracker) == GTK_PROGRESS_STATE_AFTER)
     {
       priv->angle_transition_id = 0;
       return G_SOURCE_REMOVE;
@@ -407,8 +432,8 @@ gtk_image_view_animate_to_angle (GtkImageView *image_view,
   priv->in_angle_transition = TRUE;
   priv->visible_angle = priv->angle;
   priv->transition_start_angle = priv->angle;
-  priv->angle_transition_start = gdk_frame_clock_get_frame_time (gtk_widget_get_frame_clock (GTK_WIDGET 
(image_view)));
 
+  gtk_progress_tracker_start (&priv->angle_tracker, TRANSITION_DURATION, 0, 1.0);
   priv->angle_transition_id = gtk_widget_add_tick_callback (GTK_WIDGET (image_view),
                                                             angle_frameclock_cb,
                                                             GINT_TO_POINTER (direction),
@@ -466,8 +491,8 @@ gtk_image_view_fix_anchor (GtkImageView *image_view,
   double hupper_delta_angle, vupper_delta_angle;
   double cur_scale = gtk_image_view_get_real_scale (image_view);
 
-  g_assert (old_state->hupper > 0);
-  g_assert (old_state->vupper > 0);
+  g_assert (old_state->hupper >= 0);
+  g_assert (old_state->vupper >= 0);
   g_assert (priv->hadjustment);
   g_assert (priv->vadjustment);
   g_assert (priv->size_valid);
@@ -598,8 +623,8 @@ gtk_image_view_compute_bounding_box (GtkImageView *image_view,
   if (scale_factor == 0)
     scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (image_view));
 
-  image_width = gtk_abstract_image_get_width (priv->image) / scale_factor;
-  image_height = gtk_abstract_image_get_height (priv->image) / scale_factor;
+  image_width  = priv->image_width / scale_factor;
+  image_height = priv->image_height/ scale_factor;
 
   upper_right_degrees = DEG_TO_RAD (angle) + atan (image_height / image_width);
   upper_left_degrees  = DEG_TO_RAD (angle) + atan (image_height / -image_width);
@@ -1012,11 +1037,14 @@ gtk_image_view_draw (GtkWidget *widget, cairo_t *ct)
     {
       int x = - gtk_adjustment_get_value (priv->hadjustment);
       int y = - gtk_adjustment_get_value (priv->vadjustment);
-      int w = gtk_adjustment_get_upper (priv->hadjustment);
-      int h = gtk_adjustment_get_upper (priv->vadjustment);
+      int w = MAX (gtk_adjustment_get_upper (priv->hadjustment), widget_width);
+      int h = MAX (gtk_adjustment_get_upper (priv->vadjustment), widget_height);
 
-      gtk_render_background (sc, ct, x, y, w, h);
-      gtk_render_frame (sc, ct, x, y, w, h);
+      if (w > 0 && h > 0)
+        {
+          gtk_render_background (sc, ct, x, y, w, h);
+          gtk_render_frame (sc, ct, x, y, w, h);
+        }
     }
   else
     {
@@ -1038,8 +1066,8 @@ gtk_image_view_draw (GtkWidget *widget, cairo_t *ct)
   if (scale_factor == 0)
     scale_factor = gtk_widget_get_scale_factor (widget);
 
-  image_width = gtk_abstract_image_get_width (priv->image) * scale / scale_factor;
-  image_height = gtk_abstract_image_get_height (priv->image) * scale / scale_factor;
+  image_width  = priv->image_width * scale / scale_factor;
+  image_height = priv->image_height* scale / scale_factor;
 
   if (priv->hadjustment && priv->vadjustment)
     {
@@ -1137,8 +1165,8 @@ gtk_image_view_set_vadjustment (GtkImageView  *image_view,
 
   if (vadjustment)
     {
-      g_signal_connect ((GObject *)vadjustment, "value-changed",
-                        (GCallback) adjustment_value_changed_cb, image_view);
+      g_signal_connect (G_OBJECT (vadjustment), "value-changed",
+                        G_CALLBACK (adjustment_value_changed_cb), image_view);
       priv->vadjustment = g_object_ref_sink (vadjustment);
     }
   else
@@ -1202,7 +1230,7 @@ gtk_image_view_set_vscroll_policy (GtkImageView        *image_view,
  * of the image is also the center of the scrolled window in case it is packed into
  * a #GtkScrolledWindow.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_scale (GtkImageView *image_view,
@@ -1265,7 +1293,7 @@ gtk_image_view_set_scale (GtkImageView *image_view,
  *
  * Returns: The current value of the #GtkImageView:scale property.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 double
 gtk_image_view_get_scale (GtkImageView *image_view)
@@ -1292,7 +1320,7 @@ gtk_image_view_get_scale (GtkImageView *image_view)
  * of the image is also the center of the scrolled window in case it is packed into
  * a #GtkScrolledWindow.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_angle (GtkImageView *image_view,
@@ -1353,7 +1381,7 @@ gtk_image_view_set_angle (GtkImageView *image_view,
  *
  * Returns: The current angle value.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 double
 gtk_image_view_get_angle (GtkImageView *image_view)
@@ -1374,7 +1402,7 @@ gtk_image_view_get_angle (GtkImageView *image_view)
  * be set to the closest 90° step, so e.g. using an angle of 40 will result
  * in an angle of 0, using 240 will result in 270, etc.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_snap_angle (GtkImageView *image_view,
@@ -1407,7 +1435,7 @@ gtk_image_view_set_snap_angle (GtkImageView *image_view,
  *
  * Returns: The current value of the #GtkImageView:snap-angle property.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 gboolean
 gtk_image_view_get_snap_angle (GtkImageView *image_view)
@@ -1433,7 +1461,7 @@ gtk_image_view_get_snap_angle (GtkImageView *image_view)
  * value is %FALSE, the scale will be reset to 1.0 and the #GtkImageView
  * will be resized to take at least the image's real size.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_fit_allocation (GtkImageView *image_view,
@@ -1474,7 +1502,7 @@ gtk_image_view_set_fit_allocation (GtkImageView *image_view,
  *
  * Returns: The current value of the #GtkImageView:fit-allocation property.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 gboolean
 gtk_image_view_get_fit_allocation (GtkImageView *image_view)
@@ -1493,7 +1521,7 @@ gtk_image_view_get_fit_allocation (GtkImageView *image_view)
  * Sets the value of the #GtkImageView:rotatable property to @rotatable. This controls whether
  * the user can change the angle of the displayed image using a two-finger gesture.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_rotatable (GtkImageView *image_view,
@@ -1519,7 +1547,7 @@ gtk_image_view_set_rotatable (GtkImageView *image_view,
  *
  * Returns: The current value of the #GtkImageView:rotatable property
  *
- * Since: 3.20
+ * Since: 3.22
  */
 gboolean
 gtk_image_view_get_rotatable (GtkImageView *image_view)
@@ -1538,7 +1566,7 @@ gtk_image_view_get_rotatable (GtkImageView *image_view)
  * Sets the new value of the #GtkImageView:zoomable property. This controls whether the user can
  * change the #GtkImageView:scale property using a two-finger gesture.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_zoomable (GtkImageView *image_view,
@@ -1564,7 +1592,7 @@ gtk_image_view_set_zoomable (GtkImageView *image_view,
  *
  * Returns: The current value of the #GtkImageView:zoomable property.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 gboolean
 gtk_image_view_get_zoomable (GtkImageView *image_view)
@@ -1584,7 +1612,7 @@ gtk_image_view_get_zoomable (GtkImageView *image_view)
  * Note that even if #GtkImageView:transitions-enabled is %TRUE, transitions will
  * not be used if #GtkSettings:gtk-enable-animations is %FALSE.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_transitions_enabled (GtkImageView *image_view,
@@ -1609,7 +1637,7 @@ gtk_image_view_set_transitions_enabled (GtkImageView *image_view,
  *
  * Returns: the current value of the #GtkImageView:transitions-enabled property.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 gboolean
 gtk_image_view_get_transitions_enabled (GtkImageView *image_view)
@@ -1626,7 +1654,7 @@ gtk_image_view_get_transitions_enabled (GtkImageView *image_view)
  *
  * Returns: the current value of the #GtkImageView:scale-set property.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 gboolean
 gtk_image_view_get_scale_set (GtkImageView *image_view)
@@ -1808,7 +1836,7 @@ gtk_image_view_scroll_event (GtkWidget       *widget,
 {
   GtkImageView *image_view = GTK_IMAGE_VIEW (widget);
   GtkImageViewPrivate *priv = gtk_image_view_get_instance_private (image_view);
-  double new_scale = priv->scale - (0.1 * event->delta_y);
+  double new_scale = MAX (0, priv->scale - (0.1 * event->delta_y));
   State state;
 
   if (!priv->image ||
@@ -1980,7 +2008,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
    * GtkImageView:scale:
    * The scale the internal surface gets drawn with.
    *
-   * Since: 3.20
+   * Since: 3.22
    */
   widget_props[PROP_SCALE] = g_param_spec_double ("scale",
                                                   P_("Scale"),
@@ -1996,7 +2024,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
    * e.g. when #GtkImageView:fit-allocation is true, which will change the scale
    * depending on the widget allocation.
    *
-   * Since: 3.20
+   * Since: 3.22
    */
   widget_props[PROP_SCALE_SET] = g_param_spec_boolean ("scale-set",
                                                        P_("Scale Set"),
@@ -2008,7 +2036,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
    * The angle the surface gets rotated about.
    * This is in degrees and we rotate clock-wise.
    *
-   * Since: 3.20
+   * Since: 3.22
    */
   widget_props[PROP_ANGLE] = g_param_spec_double ("angle",
                                                   P_("Angle"),
@@ -2021,7 +2049,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
    * GtkImageView:rotatable:
    * Whether or not the image can be rotated using a two-finger rotate gesture.
    *
-   * Since: 3.20
+   * Since: 3.22
    */
   widget_props[PROP_ROTATABLE] = g_param_spec_boolean ("rotatable",
                                                        P_("Rotatable"),
@@ -2033,7 +2061,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
    * Whether or not the image can be scaled using a two-finger zoom gesture, as well as
    * scrolling on the #GtkImageView.
    *
-   * Since: 3.20
+   * Since: 3.22
    */
   widget_props[PROP_ZOOMABLE] = g_param_spec_boolean ("zoomable",
                                                       P_("Zoomable"),
@@ -2047,7 +2075,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
    * set to the closest 90° step. If #GtkImageView:transitions-enabled is %TRUE,
    * the angle change from the current angle to the new angle will be interpolated.
    *
-   * Since: 3.20
+   * Since: 3.22
    */
   widget_props[PROP_SNAP_ANGLE] = g_param_spec_boolean ("snap-angle",
                                                         P_("Snap Angle"),
@@ -2061,7 +2089,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
    * widget allocation. The image will be scaled down to fit into the widget allocation,
    * but never scaled up. The aspect ratio of the image will be kept at all times.
    *
-   * Since: 3.20
+   * Since: 3.22
    */
   widget_props[PROP_FIT_ALLOCATION] = g_param_spec_boolean ("fit-allocation",
                                                             P_("Fit Allocation"),
@@ -2080,7 +2108,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
    *  set and instead interpolate between the visual angle/scale, so you cannot depend on
    *  getting 60 notify signal emissions per second.
    *
-   *  Since: 3.20
+   *  Since: 3.22
    */
   widget_props[PROP_TRANSITIONS_ENABLED] = g_param_spec_boolean ("transitions-enabled",
                                                                  P_("Transitions Enabled"),
@@ -2103,7 +2131,7 @@ gtk_image_view_class_init (GtkImageViewClass *view_class)
  *
  * Returns: A newly created #GtkImageView instance.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 GtkWidget *
 gtk_image_view_new ()
@@ -2120,6 +2148,9 @@ gtk_image_view_replace_image (GtkImageView     *image_view,
   if (priv->image)
     {
       g_signal_handlers_disconnect_by_func (priv->image, image_changed_cb, image_view);
+      if (GTK_IS_PLAYABLE (priv->image))
+        gtk_playable_stop (GTK_PLAYABLE (priv->image));
+
       g_object_unref (priv->image);
     }
 
@@ -2137,6 +2168,8 @@ gtk_image_view_replace_image (GtkImageView     *image_view,
     {
       g_object_ref (priv->image);
       g_signal_connect (priv->image, "changed", G_CALLBACK (image_changed_cb), image_view);
+      priv->image_width  = gtk_abstract_image_get_width (priv->image);
+      priv->image_height = gtk_abstract_image_get_height (priv->image);
     }
 
   if (GTK_IS_PLAYABLE (priv->image) && gtk_widget_get_mapped (GTK_WIDGET (image_view)))
@@ -2256,7 +2289,7 @@ gtk_image_view_load_from_input_stream (GTask        *task,
  *
  * Asynchronously loads an image from the given file.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_load_from_file_async (GtkImageView        *image_view,
@@ -2294,7 +2327,7 @@ gtk_image_view_load_from_file_async (GtkImageView        *image_view,
  * Returns: %TRUE if the operation succeeded, %FALSE otherwise,
  * in which case @error will be set.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 gboolean
 gtk_image_view_load_from_file_finish   (GtkImageView  *image_view,
@@ -2318,7 +2351,7 @@ gtk_image_view_load_from_file_finish   (GtkImageView  *image_view,
  *
  * Asynchronously loads an image from the given input stream.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_load_from_stream_async (GtkImageView        *image_view,
@@ -2355,7 +2388,7 @@ gtk_image_view_load_from_stream_async (GtkImageView        *image_view,
  *
  * Returns: %TRUE if the operation finished successfully, %FALSE otherwise.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 gboolean
 gtk_image_view_load_from_stream_finish (GtkImageView  *image_view,
@@ -2378,7 +2411,7 @@ gtk_image_view_load_from_stream_finish (GtkImageView  *image_view,
  * so it will not unref or free it in any way. If you want to unset the internal
  * image data, look at gtk_image_view_set_surface().
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_pixbuf (GtkImageView    *image_view,
@@ -2393,6 +2426,7 @@ gtk_image_view_set_pixbuf (GtkImageView    *image_view,
 
   image = gtk_surface_image_new_from_pixbuf (pixbuf, scale_factor);
 
+  /* Will ref the image */
   gtk_image_view_set_abstract_image (image_view, GTK_ABSTRACT_IMAGE (image));
 }
 
@@ -2405,7 +2439,7 @@ gtk_image_view_set_pixbuf (GtkImageView    *image_view,
  * Sets the internal surface to @surface. @image_view will assume ownership of this surface.
  * You can use this function to unset any internal image data by passing %NULL as @surface.
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_surface (GtkImageView    *image_view,
@@ -2417,6 +2451,7 @@ gtk_image_view_set_surface (GtkImageView    *image_view,
 
   image = gtk_surface_image_new (surface);
 
+  /* Will ref the image */
   gtk_image_view_replace_image (image_view, GTK_ABSTRACT_IMAGE (image));
 }
 
@@ -2431,7 +2466,7 @@ gtk_image_view_set_surface (GtkImageView    *image_view,
  * animation. This will also automatically start the animation. If you want
  * to unset the internal image data, look at gtk_image_view_set_surface().
  *
- * Since: 3.20
+ * Since: 3.22
  */
 void
 gtk_image_view_set_animation (GtkImageView       *image_view,
@@ -2447,6 +2482,11 @@ gtk_image_view_set_animation (GtkImageView       *image_view,
   gtk_image_view_set_abstract_image (image_view, GTK_ABSTRACT_IMAGE (image));
 }
 
+/**
+ * gtk_image_view_set_abstract_image:
+ *
+ *
+ */
 void
 gtk_image_view_set_abstract_image (GtkImageView     *image_view,
                                    GtkAbstractImage *abstract_image)
@@ -2454,5 +2494,7 @@ gtk_image_view_set_abstract_image (GtkImageView     *image_view,
   g_return_if_fail (GTK_IS_IMAGE_VIEW (image_view));
   g_return_if_fail (GTK_IS_ABSTRACT_IMAGE (abstract_image));
 
+  /* Will ref the image */
   gtk_image_view_replace_image (image_view, abstract_image);
+
 }
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]