Merge lp:~cimi/overlay-scrollbar/animated-colorization into lp:overlay-scrollbar

[Andrea Cimitan]

Fade animation to colorize the pager

[Ted Gould (ted)]

For animations of this kind you really need to not do them with frames
but have them be final end and beginning time based. This is because
the timers aren't guaranteed to be at particular times, so you need to
be robust to that and still ensure the animation doesn't take too long.

  review needsfixing

review: Needs Fixing

[lp:~cimi/overlay-scrollbar/animated-colorization]

187. By Andrea Cimitan on 2011-04-01

Use fade_id and g_source_remove to avoid crashes on dispose, use g_get_monotonic_time

188. By Andrea Cimitan on 2011-04-01

Remove g_object_ref and use just g_source_remove

189. By Andrea Cimitan on 2011-04-01

Using os-animation.c, new animation API by Loic Molinari

190. By Andrea Cimitan on 2011-04-01

start fixing os_pager_dispose ()

191. By Andrea Cimitan on 2011-04-01

remove some previous stuff, switching to the animation api

192. By Andrea Cimitan on 2011-04-01

Merged trunk

193. By Andrea Cimitan on 2011-04-01

Fix initial animation

194. By Andrea Cimitan on 2011-04-01

restore end_func optional call for animation

195. By Andrea Cimitan on 2011-04-04

OsAnimation is now a GObject, thanks Loic for the help

196. By Andrea Cimitan on 2011-04-04

updated timeout fade with the new code

197. By Andrea Cimitan on 2011-04-04

add os_animation_set_duration

198. By Andrea Cimitan on 2011-04-04

Use set_duration

199. By Andrea Cimitan on 2011-04-04

Fixes crashes due to references

200. By Andrea Cimitan on 2011-04-04

check for priv->animation != NULL is os_pager_dispose ()

201. By Andrea Cimitan on 2011-04-04

set source_id to 0 after g_source_remove

[Loïc Molinari (loic.molinari)]

review: Approve

=== modified file 'os/Makefile.am'
--- os/Makefile.am	2011-03-03 15:58:07 +0000
+++ os/Makefile.am	2011-04-04 16:19:33 +0000
@@ -9,6 +9,7 @@
 source_c = \
 	$(srcdir)/os-log.c \
 	$(srcdir)/os-utils.c \
+	$(srcdir)/os-animation.c \
 	$(srcdir)/os-pager.c \
 	$(srcdir)/os-thumb.c \
 	$(srcdir)/os-scrollbar.c

=== added file 'os/os-animation.c'
--- os/os-animation.c	1970-01-01 00:00:00 +0000
+++ os/os-animation.c	2011-04-04 16:19:33 +0000
@@ -0,0 +1,237 @@
+/* overlay-scrollbar
+ *
+ * Copyright © 2011 Canonical Ltd
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA
+ *
+ * Authored by Andrea Cimitan <[e-mail]>
+ *             Loïc Molinari <[e-mail]>
+ */
+
+#ifndef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include "os-private.h"
+
+struct _OsAnimationPrivate {
+  OsAnimationUpdateFunc update_func;
+  OsAnimationEndFunc end_func;
+  gpointer user_data;
+  gint64 start_time;
+  gint64 duration;
+  gint32 rate;
+  guint32 source_id;
+};
+
+static gboolean os_animation_update_cb (gpointer user_data);
+static void os_animation_dispose (GObject* object);
+static void os_animation_finalize (GObject* object);
+
+/* Private functions. */
+
+static gboolean
+os_animation_update_cb (gpointer user_data)
+{
+  OsAnimation *animation = OS_ANIMATION (user_data);
+  OsAnimationPrivate *priv = animation->priv;
+  const gint64 current_time = g_get_monotonic_time ();
+  const gint64 end_time = priv->start_time + priv->duration;
+
+  if (current_time < end_time)
+    {
+      /* On-going animation. */
+      const gfloat diff_time = current_time - priv->start_time;
+      const gfloat weight = diff_time / priv->duration;
+
+      priv->update_func (weight, priv->user_data);
+
+      return TRUE;
+    }
+  else
+    {
+      /* Animation ended. */
+      priv->update_func (1.0f, priv->user_data);
+      priv->source_id = 0;
+
+      if (priv->end_func != NULL)
+        priv->end_func (priv->user_data);
+
+      return FALSE;
+    }
+}
+
+/* Type definition. */
+
+G_DEFINE_TYPE (OsAnimation, os_animation, G_TYPE_OBJECT);
+
+static void
+os_animation_class_init (OsAnimationClass *class)
+{
+  GObjectClass *gobject_class;
+
+  gobject_class = G_OBJECT_CLASS (class);
+
+  gobject_class->dispose  = os_animation_dispose;
+  gobject_class->finalize = os_animation_finalize;
+
+  g_type_class_add_private (gobject_class, sizeof (OsAnimationPrivate));
+}
+
+static void
+os_animation_init (OsAnimation *animation)
+{
+  OsAnimationPrivate *priv;
+
+  animation->priv = G_TYPE_INSTANCE_GET_PRIVATE (animation,
+                                                 OS_TYPE_ANIMATION,
+                                                 OsAnimationPrivate);
+  priv = animation->priv;
+
+  priv->source_id = 0;
+}
+
+static void
+os_animation_dispose (GObject* object)
+{
+  OsAnimation *animation;
+  OsAnimationPrivate *priv;
+
+  animation = OS_ANIMATION (object);
+  priv = animation->priv;
+
+  if (priv->source_id != 0)
+    {
+      g_source_remove (priv->source_id);
+      priv->source_id = 0;
+    }
+
+  G_OBJECT_CLASS (os_animation_parent_class)->dispose (object);
+}
+
+static void
+os_animation_finalize (GObject* object)
+{
+  G_OBJECT_CLASS (os_animation_parent_class)->finalize (object);
+}
+
+/* Public functions. */
+
+/**
+ * os_animation_new:
+ * @rate: rate of the update
+ * @duration: duration of the animation
+ * @update_func: function to call on update
+ * @end_func: function to call at the end
+ * @user_data: pointer to the user data
+ *
+ * Creates a new OsAnimation
+ *
+ * Returns: the pointer to the #OsAnimation
+ */
+OsAnimation*
+os_animation_new (gint32 rate,
+                  gint32 duration,
+                  OsAnimationUpdateFunc update_func,
+                  OsAnimationEndFunc end_func,
+                  gpointer user_data)
+{
+  OsAnimation* animation;
+  OsAnimationPrivate* priv;
+
+  g_return_val_if_fail (rate != 0, NULL);
+  g_return_val_if_fail (duration != 0, NULL);
+  g_return_val_if_fail (update_func != NULL, NULL);
+
+  animation = g_object_new (OS_TYPE_ANIMATION, NULL);
+  priv = animation->priv;
+
+  priv->update_func = update_func;
+  priv->end_func = end_func;
+  priv->user_data = user_data;
+  priv->duration = (gint64) duration * G_GINT64_CONSTANT (1000);
+  priv->rate = 1000 / rate;
+
+  return animation;
+}
+
+/**
+ * os_animation_set_duration:
+ * @animation: a #OsAnimation
+ * @duration: the new duration
+ *
+ * Sets the new duration of the animation
+ **/
+void
+os_animation_set_duration (OsAnimation* animation,
+                           gint32 duration)
+{
+  OsAnimationPrivate* priv;
+
+  g_return_if_fail (animation != NULL);
+  g_return_if_fail (duration != 0);
+
+  priv = animation->priv;
+
+  priv->duration = (gint64) duration * G_GINT64_CONSTANT (1000);
+}
+
+/**
+ * os_animation_start:
+ * @animation: a #OsAnimation
+ *
+ * Starts the animation
+ **/
+void
+os_animation_start (OsAnimation* animation)
+{
+  OsAnimationPrivate* priv;
+
+  g_return_if_fail (animation != NULL);
+
+  priv = animation->priv;
+
+  if (priv->source_id == 0)
+    {
+      priv->start_time = g_get_monotonic_time ();
+      priv->source_id = g_timeout_add (priv->rate, os_animation_update_cb, animation);
+    }
+}
+
+/**
+ * os_animation_stop:
+ * @animation: a #OsAnimation
+ *
+ * Stops the animation
+ **/
+void
+os_animation_stop (OsAnimation* animation)
+{
+  OsAnimationPrivate* priv;
+
+  g_return_if_fail (animation != NULL);
+
+  priv = animation->priv;
+
+  if (priv->source_id != 0)
+    {
+      if (priv->end_func != NULL)
+        priv->end_func (priv->user_data);
+
+      g_source_remove (priv->source_id);
+      priv->source_id = 0;
+    }
+}

=== modified file 'os/os-pager.c'
--- os/os-pager.c	2011-03-31 17:05:54 +0000
+++ os/os-pager.c	2011-04-04 16:19:33 +0000
@@ -28,14 +28,24 @@
 #include <gdk/gdkx.h>
 #include "os-private.h"
 
+/* Rate of the fade */
+#define RATE_FADE 30
+
+/* Duration of the fade-in */
+#define DURATION_FADE_IN 200
+
+/* Duration of the fade-out */
+#define DURATION_FADE_OUT 400
 
 struct _OsPagerPrivate {
   GdkWindow *pager_window;
   GtkWidget *parent;
   GdkRectangle mask;
   GdkRectangle allocation;
+  OsAnimation *animation;
   gboolean active;
   gboolean visible;
+  gfloat weight;
   gint width;
   gint height;
 };
@@ -43,6 +53,7 @@
 static gboolean rectangle_changed (GdkRectangle rectangle1, GdkRectangle rectangle2);
 static void os_pager_dispose (GObject *object);
 static void os_pager_finalize (GObject *object);
+static void os_pager_change_state_cb (gfloat weight, gpointer user_data);
 static void os_pager_create (OsPager *pager);
 static void os_pager_draw (OsPager *pager);
 static void os_pager_mask (OsPager *pager);
@@ -100,22 +111,57 @@
     }
 }
 
+static void
+os_pager_change_state_cb (gfloat weight,
+                          gpointer user_data)
+{
+  OsPager *pager;
+  OsPagerPrivate *priv;
+
+  pager = OS_PAGER (user_data);
+
+  priv = pager->priv;
+
+  priv->weight = weight;
+
+  os_pager_draw (pager);
+}
+
 /* Draw on the pager. */
 static void
 os_pager_draw (OsPager *pager)
 {
-  OsPagerPrivate *priv;
+  GdkColor c1, c2, color;
   GtkStyle *style;
+  OsPagerPrivate *priv;
+  gfloat weight;
 
   priv = pager->priv;
 
   style = gtk_widget_get_style (priv->parent);
 
+  if (priv->active == FALSE)
+    {
+      c1 = style->base[GTK_STATE_INSENSITIVE];
+      c2 = style->base[GTK_STATE_SELECTED];
+    }
+  else
+    {
+      c1 = style->base[GTK_STATE_SELECTED];
+      c2 = style->base[GTK_STATE_INSENSITIVE];
+    }
+
+  weight = priv->weight;
+
+  color.red   = weight * c1.red   + (1.0 - weight) * c2.red;
+  color.green = weight * c1.green + (1.0 - weight) * c2.green;
+  color.blue  = weight * c1.blue  + (1.0 - weight) * c2.blue;
+
+  gdk_colormap_alloc_color (gdk_drawable_get_colormap (priv->pager_window), &color, FALSE, TRUE);
+
   gdk_window_invalidate_rect (gtk_widget_get_window (priv->parent), &priv->allocation, TRUE);
 
-  gdk_window_set_background (priv->pager_window,
-                             priv->active ? &style->base[GTK_STATE_SELECTED] :
-                                            &style->base[GTK_STATE_INSENSITIVE]);
+  gdk_window_set_background (priv->pager_window, &color);
 
   gdk_window_clear (priv->pager_window);
 }
@@ -177,11 +223,28 @@
 
   priv->active = FALSE;
   priv->visible = FALSE;
+
+  priv->weight = 1.0f;
+
+  priv->animation = os_animation_new (RATE_FADE, DURATION_FADE_OUT,
+                                      os_pager_change_state_cb, NULL, pager);
 }
 
 static void
 os_pager_dispose (GObject *object)
 {
+  OsPager *pager;
+  OsPagerPrivate *priv;
+
+  pager = OS_PAGER (object);
+  priv = pager->priv;
+
+  if (priv->animation != NULL)
+    {
+      g_object_unref (priv->animation);
+      priv->animation = NULL;
+    }
+
   G_OBJECT_CLASS (os_pager_parent_class)->dispose (object);
 }
 
@@ -281,7 +344,12 @@
       if (priv->parent == NULL)
         return;
 
-      os_pager_draw (pager);
+      os_animation_stop (priv->animation);
+
+      os_animation_set_duration (priv->animation, priv->active ? DURATION_FADE_IN :
+                                                                 DURATION_FADE_OUT);
+
+      os_animation_start (priv->animation);
     }
 }
 
@@ -313,6 +381,8 @@
     {
       g_object_ref_sink (priv->parent);
 
+      priv->weight = 1.0f;
+
       os_pager_create (pager);
       os_pager_draw (pager);
       os_pager_mask (pager);

=== modified file 'os/os-private.h'
--- os/os-private.h	2011-03-28 16:17:49 +0000
+++ os/os-private.h	2011-04-04 16:19:33 +0000
@@ -93,6 +93,52 @@
 #define OS_DCHECK(cond)
 #endif
 
+/* os-animation.c */
+
+#define OS_TYPE_ANIMATION (os_animation_get_type ())
+#define OS_ANIMATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), OS_TYPE_ANIMATION, OsAnimation))
+#define OS_ANIMATION_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), OS_TYPE_ANIMATION, OsAnimationClass))
+#define OS_IS_ANIMATION(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), OS_TYPE_ANIMATION))
+#define OS_IS_ANIMATION_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), OS_TYPE_ANIMATION))
+#define OS_ANIMATION_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj),  OS_TYPE_ANIMATION, OsAnimationClass))
+
+typedef void (*OsAnimationUpdateFunc) (gfloat weight, gpointer user_data);
+typedef void (*OsAnimationEndFunc)    (gpointer user_data);
+
+typedef struct _OsAnimation OsAnimation;
+typedef struct _OsAnimationPrivate OsAnimationPrivate;
+typedef struct _OsAnimationClass OsAnimationClass;
+
+struct _OsAnimation {
+  GObject parent_instance;
+
+  OsAnimationPrivate *priv;
+};
+
+struct _OsAnimationClass {
+  GObjectClass parent_class;
+};
+
+GType        os_animation_get_type     (void);
+
+OsAnimation* os_animation_new          (gint32 rate,
+                                        gint32 duration,
+                                        OsAnimationUpdateFunc update_func,
+                                        OsAnimationEndFunc end_func,
+                                        gpointer user_data);
+
+void         os_animation_set_duration (OsAnimation* animation,
+                                        gint32 duration);
+
+void         os_animation_start        (OsAnimation* animation);
+
+void         os_animation_stop         (OsAnimation* animation);
+
 /* os-thumb.c */
 
 #define OS_TYPE_THUMB (os_thumb_get_type ())

=== modified file 'os/os-scrollbar.c'
--- os/os-scrollbar.c	2011-04-01 17:22:12 +0000
+++ os/os-scrollbar.c	2011-04-04 16:19:33 +0000
@@ -340,7 +340,7 @@
 
   priv = scrollbar->priv;
 
-  if (priv->can_deactivate_pager)
+  if (priv->pager != NULL && priv->can_deactivate_pager)
     os_pager_set_active (OS_PAGER (priv->pager), FALSE);
 }
 
@@ -1246,6 +1246,18 @@
 static void
 os_scrollbar_dispose (GObject *object)
 {
+  OsScrollbar *scrollbar;
+  OsScrollbarPrivate *priv;
+
+  scrollbar = OS_SCROLLBAR (object);
+  priv = scrollbar->priv;
+
+  if (priv->pager != NULL)
+    {
+      g_object_unref (priv->pager);
+      priv->pager = NULL;
+    }
+
   G_OBJECT_CLASS (os_scrollbar_parent_class)->dispose (object);
 }
 
@@ -1261,12 +1273,6 @@
   os_scrollbar_swap_adjustment (scrollbar, NULL);
   os_scrollbar_swap_thumb (scrollbar, NULL);
 
-  if (priv->pager != NULL)
-    {
-      g_object_unref (priv->pager);
-      priv->pager = NULL;
-    }
-
   G_OBJECT_CLASS (os_scrollbar_parent_class)->finalize (object);
 }