[gtk+/wip/cssvalue: 94/142] cssvalue: Add GtkCssEaseValue

[Benjamin Otte <otte src gnome org>]

commit dc525f5e2408d2edbb2f3a354dd49172d3023f7f
Author: Benjamin Otte <otte redhat com>
Date:   Sun Apr 1 06:20:48 2012 +0200

    cssvalue: Add GtkCssEaseValue
    
    This is supposed to hold the transition-easing-function and
    animation-easing-function values.

 gtk/Makefile.am              |    2 +
 gtk/gtkcsseasevalue.c        |  285 ++++++++++++++++++++++++++++++++++++++++++
 gtk/gtkcsseasevalueprivate.h |   41 ++++++
 3 files changed, 328 insertions(+), 0 deletions(-)
---
diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index 351545b..54faaa1 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -426,6 +426,7 @@ gtk_private_h_sources =		\
 	gtkcssarrayvalueprivate.h	\
 	gtkcsscomputedvaluesprivate.h \
 	gtkcsscustompropertyprivate.h \
+	gtkcsseasevalueprivate.h	\
 	gtkcssenumvalueprivate.h	\
 	gtkcssimagegradientprivate.h	\
 	gtkcssimagelinearprivate.h	\
@@ -631,6 +632,7 @@ gtk_base_c_sources = 		\
 	gtkcssarrayvalue.c	\
 	gtkcsscomputedvalues.c	\
 	gtkcsscustomproperty.c	\
+	gtkcsseasevalue.c	\
 	gtkcssenumvalue.c	\
 	gtkcssimage.c		\
 	gtkcssimagegradient.c	\
diff --git a/gtk/gtkcsseasevalue.c b/gtk/gtkcsseasevalue.c
new file mode 100644
index 0000000..1ccc68c
--- /dev/null
+++ b/gtk/gtkcsseasevalue.c
@@ -0,0 +1,285 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2011 Red Hat, Inc.
+ *
+ * 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 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gtkcsseasevalueprivate.h"
+
+#include <math.h>
+
+typedef enum {
+  GTK_CSS_EASE_CUBIC_BEZIER,
+  GTK_CSS_EASE_STEPS
+} GtkCssEaseType;
+
+struct _GtkCssValue {
+  GTK_CSS_VALUE_BASE
+  GtkCssEaseType type;
+  union {
+    struct {
+      double x1;
+      double y1;
+      double x2;
+      double y2;
+    } cubic;
+    struct {
+      guint steps;
+      gboolean start;
+    } steps;
+  } u;
+};
+
+static void
+gtk_css_value_ease_free (GtkCssValue *value)
+{
+  g_slice_free (GtkCssValue, value);
+}
+
+static gboolean
+gtk_css_value_ease_equal (const GtkCssValue *ease1,
+                          const GtkCssValue *ease2)
+{
+  if (ease1->type != ease2->type)
+    return FALSE;
+  
+  switch (ease1->type)
+    {
+    case GTK_CSS_EASE_CUBIC_BEZIER:
+      return ease1->u.cubic.x1 == ease2->u.cubic.x1 &&
+             ease1->u.cubic.y1 == ease2->u.cubic.y1 &&
+             ease1->u.cubic.x2 == ease2->u.cubic.x2 &&
+             ease1->u.cubic.y2 == ease2->u.cubic.y2;
+    case GTK_CSS_EASE_STEPS:
+      return ease1->u.steps.steps == ease2->u.steps.steps &&
+             ease1->u.steps.start == ease2->u.steps.start;
+    default:
+      g_assert_not_reached ();
+      return FALSE;
+    }
+}
+
+static GtkCssValue *
+gtk_css_value_ease_transition (GtkCssValue *start,
+                               GtkCssValue *end,
+                               double       progress)
+{
+  return NULL;
+}
+
+static void
+gtk_css_value_ease_print (const GtkCssValue *ease,
+                          GString           *string)
+{
+  switch (ease->type)
+    {
+    case GTK_CSS_EASE_CUBIC_BEZIER:
+      if (ease->u.cubic.x1 == 0.25 && ease->u.cubic.y1 == 0.1 &&
+          ease->u.cubic.x2 == 0.25 && ease->u.cubic.y2 == 1.0)
+        g_string_append (string, "ease");
+      else if (ease->u.cubic.x1 == 0.0 && ease->u.cubic.y1 == 0.0 &&
+               ease->u.cubic.x2 == 1.0 && ease->u.cubic.y2 == 1.0)
+        g_string_append (string, "linear");
+      else if (ease->u.cubic.x1 == 0.42 && ease->u.cubic.y1 == 0.0 &&
+               ease->u.cubic.x2 == 1.0  && ease->u.cubic.y2 == 1.0)
+        g_string_append (string, "ease-in");
+      else if (ease->u.cubic.x1 == 0.0  && ease->u.cubic.y1 == 0.0 &&
+               ease->u.cubic.x2 == 0.58 && ease->u.cubic.y2 == 1.0)
+        g_string_append (string, "ease-out");
+      else if (ease->u.cubic.x1 == 0.42 && ease->u.cubic.y1 == 0.0 &&
+               ease->u.cubic.x2 == 0.58 && ease->u.cubic.y2 == 1.0)
+        g_string_append (string, "ease-in-out");
+      else
+        g_string_append_printf (string, "cubic-bezier(%g,%g,%g,%g)", 
+                                ease->u.cubic.x1, ease->u.cubic.y1,
+                                ease->u.cubic.x2, ease->u.cubic.y2);
+      break;
+    case GTK_CSS_EASE_STEPS:
+      if (ease->u.steps.steps == 1)
+        {
+          g_string_append (string, ease->u.steps.start ? "step-start" : "step-end");
+        }
+      else
+        {
+          g_string_append_printf (string, "steps(%u%s)", ease->u.steps.steps, ease->u.steps.start ? ",start" : "");
+        }
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+}
+
+static const GtkCssValueClass GTK_CSS_VALUE_EASE = {
+  gtk_css_value_ease_free,
+  gtk_css_value_ease_equal,
+  gtk_css_value_ease_transition,
+  gtk_css_value_ease_print
+};
+
+GtkCssValue *
+_gtk_css_ease_value_new_cubic_bezier (double x1,
+                                      double y1,
+                                      double x2,
+                                      double y2)
+{
+  GtkCssValue *value;
+
+  g_return_val_if_fail (x1 >= 0.0, NULL);
+  g_return_val_if_fail (x1 <= 1.0, NULL);
+  g_return_val_if_fail (x2 >= 0.0, NULL);
+  g_return_val_if_fail (x2 <= 1.0, NULL);
+
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_EASE);
+  
+  value->type = GTK_CSS_EASE_CUBIC_BEZIER;
+  value->u.cubic.x1 = x1;
+  value->u.cubic.y1 = y1;
+  value->u.cubic.x2 = x2;
+  value->u.cubic.y2 = y2;
+
+  return value;
+}
+
+static GtkCssValue *
+_gtk_css_ease_value_new_steps (guint n_steps,
+                               gboolean start)
+{
+  GtkCssValue *value;
+
+  g_return_val_if_fail (n_steps > 0, NULL);
+
+  value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_EASE);
+  
+  value->type = GTK_CSS_EASE_STEPS;
+  value->u.steps.steps = n_steps;
+  value->u.steps.start = start;
+
+  return value;
+}
+
+static const struct {
+  const char *name;
+  guint is_bezier :1;
+  guint needs_custom :1;
+  double values[4];
+} parser_values[] = {
+  { "linear",       TRUE,  FALSE, { 0.0,  0.0, 1.0,  1.0 } },
+  { "ease-in-out",  TRUE,  FALSE, { 0.42, 0.0, 0.58, 1.0 } },
+  { "ease-in",      TRUE,  FALSE, { 0.42, 0.0, 1.0,  1.0 } },
+  { "ease-out",     TRUE,  FALSE, { 0.0,  0.0, 0.58, 1.0 } },
+  { "ease",         TRUE,  FALSE, { 0.25, 0.1, 0.25, 1.0 } },
+  { "step-start",   FALSE, FALSE, { 1.0,  1.0, 0.0,  0.0 } },
+  { "step-end",     FALSE, FALSE, { 1.0,  0.0, 0.0,  0.0 } },
+  { "steps",        FALSE, TRUE,  { 0.0,  0.0, 0.0,  0.0 } },
+  { "cubic-bezier", TRUE,  TRUE,  { 0.0,  0.0, 0.0,  0.0 } }
+};
+
+gboolean
+_gtk_css_ease_value_can_parse (GtkCssParser *parser)
+{
+  guint i;
+
+  for (i = 0; i < G_N_ELEMENTS (parser_values); i++)
+    {
+      if (_gtk_css_parser_has_prefix (parser, parser_values[i].name))
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+GtkCssValue *
+_gtk_css_ease_value_parse (GtkCssParser *parser)
+{
+  g_return_val_if_fail (parser != NULL, NULL);
+
+  guint i;
+
+  for (i = 0; i < G_N_ELEMENTS (parser_values); i++)
+    {
+      if (_gtk_css_parser_try (parser, parser_values[i].name, TRUE))
+        {
+          g_assert (!parser_values[i].needs_custom);
+
+          if (parser_values[i].is_bezier)
+            return _gtk_css_ease_value_new_cubic_bezier (parser_values[i].values[0],
+                                                         parser_values[i].values[1],
+                                                         parser_values[i].values[2],
+                                                         parser_values[i].values[3]);
+          else
+            return _gtk_css_ease_value_new_steps (parser_values[i].values[0],
+                                                  parser_values[i].values[1] != 0.0);
+        }
+    }
+
+  _gtk_css_parser_error (parser, "Unknown value");
+  return NULL;
+}
+
+double
+_gtk_css_ease_value_transform (const GtkCssValue *ease,
+                               double             progress)
+{
+  g_return_val_if_fail (ease->class == &GTK_CSS_VALUE_EASE, 1.0);
+
+  if (progress <= 0)
+    return 0;
+  if (progress >= 1)
+    return 1;
+
+  switch (ease->type)
+    {
+    case GTK_CSS_EASE_CUBIC_BEZIER:
+      {
+        static const double epsilon = 0.00001;
+        double tmin, t, tmax;
+
+        tmin = 0.0;
+        tmax = 1.0;
+        t = progress;
+
+        while (tmin < tmax)
+          {
+             double sample;
+             sample = (((1.0 + 3 * ease->u.cubic.x1 - 3 * ease->u.cubic.x2) * t
+                       +      -6 * ease->u.cubic.x1 + 3 * ease->u.cubic.x2) * t
+                       +       3 * ease->u.cubic.x1                       ) * t;
+             if (fabs(sample - progress) < epsilon)
+               break;
+
+             if (progress > sample)
+               tmin = t;
+             else
+               tmax = t;
+             t = (tmax + tmin) * .5;
+          }
+
+        return (((1.0 + 3 * ease->u.cubic.y1 - 3 * ease->u.cubic.y2) * t
+                +      -6 * ease->u.cubic.y1 + 3 * ease->u.cubic.y2) * t
+                +       3 * ease->u.cubic.y1                       ) * t;
+      }
+    case GTK_CSS_EASE_STEPS:
+      progress *= ease->u.steps.steps;
+      progress = floor (progress) + ease->u.steps.start ? 0 : 1;
+      return progress / ease->u.steps.steps;
+    default:
+      g_assert_not_reached ();
+      return 1.0;
+    }
+}
+
+
diff --git a/gtk/gtkcsseasevalueprivate.h b/gtk/gtkcsseasevalueprivate.h
new file mode 100644
index 0000000..6b4dab3
--- /dev/null
+++ b/gtk/gtkcsseasevalueprivate.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright  2012 Red Hat Inc.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Alexander Larsson <alexl gnome org>
+ */
+
+#ifndef __GTK_CSS_EASE_VALUE_PRIVATE_H__
+#define __GTK_CSS_EASE_VALUE_PRIVATE_H__
+
+#include "gtkcssparserprivate.h"
+#include "gtkcssvalueprivate.h"
+
+G_BEGIN_DECLS
+
+GtkCssValue *   _gtk_css_ease_value_new_cubic_bezier  (double                x1,
+                                                       double                y1,
+                                                       double                x2,
+                                                       double                y2);
+gboolean        _gtk_css_ease_value_can_parse         (GtkCssParser         *parser);
+GtkCssValue *   _gtk_css_ease_value_parse             (GtkCssParser         *parser);
+
+double          _gtk_css_ease_value_transform         (const GtkCssValue    *ease,
+                                                       double                progress);
+
+
+G_END_DECLS
+
+#endif /* __GTK_CSS_EASE_VALUE_PRIVATE_H__ */