gtkcssanimation.c 7.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * 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: Benjamin Otte <otte@gnome.org>
 */

#include "config.h"

#include "gtkcssanimationprivate.h"

#include "gtkcsseasevalueprivate.h"
25
#include "gtkprogresstrackerprivate.h"
26 27 28 29 30 31

#include <math.h>

G_DEFINE_TYPE (GtkCssAnimation, _gtk_css_animation, GTK_TYPE_STYLE_ANIMATION)

static gboolean
32
gtk_css_animation_is_executing (GtkCssAnimation *animation)
33
{
34 35
  GtkProgressState state = gtk_progress_tracker_get_state (&animation->tracker);

36 37 38
  switch (animation->fill_mode)
    {
    case GTK_CSS_FILL_NONE:
39
      return state == GTK_PROGRESS_STATE_DURING;
40
    case GTK_CSS_FILL_FORWARDS:
41
      return state != GTK_PROGRESS_STATE_BEFORE;
42
    case GTK_CSS_FILL_BACKWARDS:
43
      return state != GTK_PROGRESS_STATE_AFTER;
44 45 46 47 48 49 50 51
    case GTK_CSS_FILL_BOTH:
      return TRUE;
    default:
      g_return_val_if_reached (FALSE);
    }
}

static double
52
gtk_css_animation_get_progress (GtkCssAnimation *animation)
53
{
54 55 56
  gboolean reverse, odd_iteration;
  gint cycle = gtk_progress_tracker_get_iteration_cycle (&animation->tracker);
  odd_iteration = cycle % 2 > 0;
57 58 59 60

  switch (animation->direction)
    {
    case GTK_CSS_DIRECTION_NORMAL:
61
      reverse = FALSE;
62
      break;
63
    case GTK_CSS_DIRECTION_REVERSE:
64
      reverse = TRUE;
65
      break;
66
    case GTK_CSS_DIRECTION_ALTERNATE:
67
      reverse = odd_iteration;
68
      break;
69
    case GTK_CSS_DIRECTION_ALTERNATE_REVERSE:
70
      reverse = !odd_iteration;
71
      break;
72
    default:
73
      g_return_val_if_reached (0.0);
74
    }
75

76
  return gtk_progress_tracker_get_progress (&animation->tracker, reverse);
77 78
}

79
static GtkStyleAnimation *
80 81 82 83 84 85 86 87 88 89
gtk_css_animation_advance (GtkStyleAnimation    *style_animation,
                           gint64                timestamp)
{
  GtkCssAnimation *animation = GTK_CSS_ANIMATION (style_animation);

  return _gtk_css_animation_advance_with_play_state (animation,
                                                     timestamp,
                                                     animation->play_state);
}

90
static void
91 92
gtk_css_animation_apply_values (GtkStyleAnimation    *style_animation,
                                GtkCssAnimatedStyle  *style)
93 94
{
  GtkCssAnimation *animation = GTK_CSS_ANIMATION (style_animation);
95
  double progress;
96 97
  guint i;

98
  if (!gtk_css_animation_is_executing (animation))
99
    return;
100

101
  progress = gtk_css_animation_get_progress (animation);
102
  progress = _gtk_css_ease_value_transform (animation->ease, progress);
103

104 105 106 107 108 109 110 111 112 113
  for (i = 0; i < _gtk_css_keyframes_get_n_properties (animation->keyframes); i++)
    {
      GtkCssValue *value;
      guint property_id;
      
      property_id = _gtk_css_keyframes_get_property_id (animation->keyframes, i);

      value = _gtk_css_keyframes_get_value (animation->keyframes,
                                            i,
                                            progress,
114 115
                                            gtk_css_animated_style_get_intrinsic_value (style, property_id));
      gtk_css_animated_style_set_animated_value (style, property_id, value);
116 117 118 119 120
      _gtk_css_value_unref (value);
    }
}

static gboolean
121
gtk_css_animation_is_finished (GtkStyleAnimation *style_animation)
122 123 124 125
{
  return FALSE;
}

126
static gboolean
127
gtk_css_animation_is_static (GtkStyleAnimation *style_animation)
128 129 130
{
  GtkCssAnimation *animation = GTK_CSS_ANIMATION (style_animation);

131 132 133
  if (animation->play_state == GTK_CSS_PLAY_STATE_PAUSED)
    return TRUE;

134
  return gtk_progress_tracker_get_state (&animation->tracker) == GTK_PROGRESS_STATE_AFTER;
135 136
}

137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
static void
gtk_css_animation_finalize (GObject *object)
{
  GtkCssAnimation *animation = GTK_CSS_ANIMATION (object);

  g_free (animation->name);
  _gtk_css_keyframes_unref (animation->keyframes);
  _gtk_css_value_unref (animation->ease);

  G_OBJECT_CLASS (_gtk_css_animation_parent_class)->finalize (object);
}

static void
_gtk_css_animation_class_init (GtkCssAnimationClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GtkStyleAnimationClass *animation_class = GTK_STYLE_ANIMATION_CLASS (klass);

  object_class->finalize = gtk_css_animation_finalize;

157 158
  animation_class->advance = gtk_css_animation_advance;
  animation_class->apply_values = gtk_css_animation_apply_values;
159
  animation_class->is_finished = gtk_css_animation_is_finished;
160
  animation_class->is_static = gtk_css_animation_is_static;
161 162 163 164 165 166 167 168 169 170
}

static void
_gtk_css_animation_init (GtkCssAnimation *animation)
{
}

GtkStyleAnimation *
_gtk_css_animation_new (const char      *name,
                        GtkCssKeyframes *keyframes,
171 172
                        gint64           timestamp,
                        gint64           delay_us,
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
                        gint64           duration_us,
                        GtkCssValue     *ease,
                        GtkCssDirection  direction,
                        GtkCssPlayState  play_state,
                        GtkCssFillMode   fill_mode,
                        double           iteration_count)
{
  GtkCssAnimation *animation;

  g_return_val_if_fail (name != NULL, NULL);
  g_return_val_if_fail (keyframes != NULL, NULL);
  g_return_val_if_fail (ease != NULL, NULL);
  g_return_val_if_fail (iteration_count >= 0, NULL);

  animation = g_object_new (GTK_TYPE_CSS_ANIMATION, NULL);

  animation->name = g_strdup (name);
  animation->keyframes = _gtk_css_keyframes_ref (keyframes);
  animation->ease = _gtk_css_value_ref (ease);
  animation->direction = direction;
  animation->play_state = play_state;
  animation->fill_mode = fill_mode;
195 196 197 198 199 200

  gtk_progress_tracker_start (&animation->tracker, duration_us, delay_us, iteration_count);
  if (animation->play_state == GTK_CSS_PLAY_STATE_PAUSED)
    gtk_progress_tracker_skip_frame (&animation->tracker, timestamp);
  else
    gtk_progress_tracker_advance_frame (&animation->tracker, timestamp);
201 202 203 204 205 206 207 208 209 210 211

  return GTK_STYLE_ANIMATION (animation);
}

const char *
_gtk_css_animation_get_name (GtkCssAnimation *animation)
{
  g_return_val_if_fail (GTK_IS_CSS_ANIMATION (animation), NULL);

  return animation->name;
}
212 213

GtkStyleAnimation *
214 215 216
_gtk_css_animation_advance_with_play_state (GtkCssAnimation *source,
                                            gint64           timestamp,
                                            GtkCssPlayState  play_state)
217
{
218 219 220
  GtkCssAnimation *animation;

  g_return_val_if_fail (GTK_IS_CSS_ANIMATION (source), NULL);
221

222 223 224 225 226 227 228 229 230
  animation = g_object_new (GTK_TYPE_CSS_ANIMATION, NULL);

  animation->name = g_strdup (source->name);
  animation->keyframes = _gtk_css_keyframes_ref (source->keyframes);
  animation->ease = _gtk_css_value_ref (source->ease);
  animation->direction = source->direction;
  animation->play_state = play_state;
  animation->fill_mode = source->fill_mode;

231 232 233 234 235
  gtk_progress_tracker_init_copy (&source->tracker, &animation->tracker);
  if (animation->play_state == GTK_CSS_PLAY_STATE_PAUSED)
    gtk_progress_tracker_skip_frame (&animation->tracker, timestamp);
  else
    gtk_progress_tracker_advance_frame (&animation->tracker, timestamp);
236 237

  return GTK_STYLE_ANIMATION (animation);
238
}