Pileus Git - ~andy/gtk/blob - gtk/gtkcsscomputedvalues.c

   1 /*
   2  * Copyright © 2012 Red Hat Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Authors: Benjamin Otte <otte@gnome.org>
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gtkcsscomputedvaluesprivate.h"
  23
  24 #include "gtkcssanimationprivate.h"
  25 #include "gtkcssarrayvalueprivate.h"
  26 #include "gtkcssenumvalueprivate.h"
  27 #include "gtkcssinheritvalueprivate.h"
  28 #include "gtkcssinitialvalueprivate.h"
  29 #include "gtkcssnumbervalueprivate.h"
  30 #include "gtkcssshorthandpropertyprivate.h"
  31 #include "gtkcssstringvalueprivate.h"
  32 #include "gtkcssstylepropertyprivate.h"
  33 #include "gtkcsstransitionprivate.h"
  34 #include "gtkstyleanimationprivate.h"
  35 #include "gtkstylepropertiesprivate.h"
  36 #include "gtkstylepropertyprivate.h"
  37 #include "gtkstyleproviderprivate.h"
  38
  39 G_DEFINE_TYPE (GtkCssComputedValues, _gtk_css_computed_values, G_TYPE_OBJECT)
  40
  41 static void
  42 gtk_css_computed_values_dispose (GObject *object)
  43 {
  44   GtkCssComputedValues *values = GTK_CSS_COMPUTED_VALUES (object);
  45
  46   if (values->values)
  47     {
  48       g_ptr_array_unref (values->values);
  49       values->values = NULL;
  50     }
  51   if (values->sections)
  52     {
  53       g_ptr_array_unref (values->sections);
  54       values->sections = NULL;
  55     }
  56   if (values->animated_values)
  57     {
  58       g_ptr_array_unref (values->animated_values);
  59       values->animated_values = NULL;
  60     }
  61
  62   g_slist_free_full (values->animations, g_object_unref);
  63   values->animations = NULL;
  64
  65   G_OBJECT_CLASS (_gtk_css_computed_values_parent_class)->dispose (object);
  66 }
  67
  68 static void
  69 gtk_css_computed_values_finalize (GObject *object)
  70 {
  71   GtkCssComputedValues *values = GTK_CSS_COMPUTED_VALUES (object);
  72
  73   _gtk_bitmask_free (values->depends_on_parent);
  74   _gtk_bitmask_free (values->equals_parent);
  75   _gtk_bitmask_free (values->depends_on_color);
  76   _gtk_bitmask_free (values->depends_on_font_size);
  77
  78   G_OBJECT_CLASS (_gtk_css_computed_values_parent_class)->finalize (object);
  79 }
  80
  81 static void
  82 _gtk_css_computed_values_class_init (GtkCssComputedValuesClass *klass)
  83 {
  84   GObjectClass *object_class = G_OBJECT_CLASS (klass);
  85
  86   object_class->dispose = gtk_css_computed_values_dispose;
  87   object_class->finalize = gtk_css_computed_values_finalize;
  88 }
  89
  90 static void
  91 _gtk_css_computed_values_init (GtkCssComputedValues *values)
  92 {
  93   values->depends_on_parent = _gtk_bitmask_new ();
  94   values->equals_parent = _gtk_bitmask_new ();
  95   values->depends_on_color = _gtk_bitmask_new ();
  96   values->depends_on_font_size = _gtk_bitmask_new ();
  97 }
  98
  99 GtkCssComputedValues *
 100 _gtk_css_computed_values_new (void)
 101 {
 102   return g_object_new (GTK_TYPE_CSS_COMPUTED_VALUES, NULL);
 103 }
 104
 105 static void
 106 maybe_unref_section (gpointer section)
 107 {
 108   if (section)
 109     gtk_css_section_unref (section);
 110 }
 111
 112 void
 113 _gtk_css_computed_values_compute_value (GtkCssComputedValues    *values,
 114                                         GtkStyleProviderPrivate *provider,
 115                                         GtkCssComputedValues    *parent_values,
 116                                         guint                    id,
 117                                         GtkCssValue             *specified,
 118                                         GtkCssSection           *section)
 119 {
 120   GtkCssDependencies dependencies;
 121   GtkCssValue *value;
 122
 123   g_return_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values));
 124   g_return_if_fail (GTK_IS_STYLE_PROVIDER_PRIVATE (provider));
 125   g_return_if_fail (parent_values == NULL || GTK_IS_CSS_COMPUTED_VALUES (parent_values));
 126
 127   /* http://www.w3.org/TR/css3-cascade/#cascade
 128    * Then, for every element, the value for each property can be found
 129    * by following this pseudo-algorithm:
 130    * 1) Identify all declarations that apply to the element
 131    */
 132   if (specified == NULL)
 133     {
 134       GtkCssStyleProperty *prop = _gtk_css_style_property_lookup_by_id (id);
 135
 136       if (_gtk_css_style_property_is_inherit (prop))
 137         specified = _gtk_css_inherit_value_new ();
 138       else
 139         specified = _gtk_css_initial_value_new ();
 140     }
 141   else
 142     _gtk_css_value_ref (specified);
 143
 144   value = _gtk_css_value_compute (specified, id, provider, values, parent_values, &dependencies);
 145
 146   _gtk_css_computed_values_set_value (values, id, value, dependencies, section);
 147
 148   _gtk_css_value_unref (value);
 149   _gtk_css_value_unref (specified);
 150 }
 151
 152 void
 153 _gtk_css_computed_values_set_animated_value (GtkCssComputedValues *values,
 154                                              guint                 id,
 155                                              GtkCssValue          *value)
 156 {
 157   g_return_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values));
 158   g_return_if_fail (value != NULL);
 159
 160   if (values->animated_values == NULL)
 161     values->animated_values = g_ptr_array_new_with_free_func ((GDestroyNotify)_gtk_css_value_unref);
 162   if (id >= values->animated_values->len)
 163    g_ptr_array_set_size (values->animated_values, id + 1);
 164
 165   if (g_ptr_array_index (values->animated_values, id))
 166     _gtk_css_value_unref (g_ptr_array_index (values->animated_values, id));
 167   g_ptr_array_index (values->animated_values, id) = _gtk_css_value_ref (value);
 168
 169 }
 170
 171 void
 172 _gtk_css_computed_values_set_value (GtkCssComputedValues *values,
 173                                     guint                 id,
 174                                     GtkCssValue          *value,
 175                                     GtkCssDependencies    dependencies,
 176                                     GtkCssSection        *section)
 177 {
 178   g_return_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values));
 179
 180   if (values->values == NULL)
 181     values->values = g_ptr_array_new_with_free_func ((GDestroyNotify)_gtk_css_value_unref);
 182   if (id >= values->values->len)
 183    g_ptr_array_set_size (values->values, id + 1);
 184
 185   if (g_ptr_array_index (values->values, id))
 186     _gtk_css_value_unref (g_ptr_array_index (values->values, id));
 187   g_ptr_array_index (values->values, id) = _gtk_css_value_ref (value);
 188
 189   if (dependencies & (GTK_CSS_DEPENDS_ON_PARENT | GTK_CSS_EQUALS_PARENT))
 190     values->depends_on_parent = _gtk_bitmask_set (values->depends_on_parent, id, TRUE);
 191   if (dependencies & (GTK_CSS_EQUALS_PARENT))
 192     values->equals_parent = _gtk_bitmask_set (values->equals_parent, id, TRUE);
 193   if (dependencies & (GTK_CSS_DEPENDS_ON_COLOR))
 194     values->depends_on_color = _gtk_bitmask_set (values->depends_on_color, id, TRUE);
 195   if (dependencies & (GTK_CSS_DEPENDS_ON_FONT_SIZE))
 196     values->depends_on_font_size = _gtk_bitmask_set (values->depends_on_font_size, id, TRUE);
 197
 198   if (values->sections && values->sections->len > id && g_ptr_array_index (values->sections, id))
 199     {
 200       gtk_css_section_unref (g_ptr_array_index (values->sections, id));
 201       g_ptr_array_index (values->sections, id) = NULL;
 202     }
 203
 204   if (section)
 205     {
 206       if (values->sections == NULL)
 207         values->sections = g_ptr_array_new_with_free_func (maybe_unref_section);
 208       if (values->sections->len <= id)
 209         g_ptr_array_set_size (values->sections, id + 1);
 210
 211       g_ptr_array_index (values->sections, id) = gtk_css_section_ref (section);
 212     }
 213 }
 214
 215 GtkCssValue *
 216 _gtk_css_computed_values_get_value (GtkCssComputedValues *values,
 217                                     guint                 id)
 218 {
 219   g_return_val_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values), NULL);
 220
 221   if (values->animated_values &&
 222       id < values->animated_values->len &&
 223       g_ptr_array_index (values->animated_values, id))
 224     return g_ptr_array_index (values->animated_values, id);
 225
 226   return _gtk_css_computed_values_get_intrinsic_value (values, id);
 227 }
 228
 229 GtkCssValue *
 230 _gtk_css_computed_values_get_intrinsic_value (GtkCssComputedValues *values,
 231                                               guint                 id)
 232 {
 233   g_return_val_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values), NULL);
 234
 235   if (values->values == NULL ||
 236       id >= values->values->len)
 237     return NULL;
 238
 239   return g_ptr_array_index (values->values, id);
 240 }
 241
 242 GtkCssSection *
 243 _gtk_css_computed_values_get_section (GtkCssComputedValues *values,
 244                                       guint                 id)
 245 {
 246   g_return_val_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values), NULL);
 247
 248   if (values->sections == NULL ||
 249       id >= values->sections->len)
 250     return NULL;
 251
 252   return g_ptr_array_index (values->sections, id);
 253 }
 254
 255 GtkBitmask *
 256 _gtk_css_computed_values_get_difference (GtkCssComputedValues *values,
 257                                          GtkCssComputedValues *other)
 258 {
 259   GtkBitmask *result;
 260   guint i, len;
 261
 262   len = MIN (values->values->len, other->values->len);
 263   result = _gtk_bitmask_new ();
 264   if (values->values->len != other->values->len)
 265     result = _gtk_bitmask_invert_range (result, len, MAX (values->values->len, other->values->len));
 266
 267   for (i = 0; i < len; i++)
 268     {
 269       if (!_gtk_css_value_equal (g_ptr_array_index (values->values, i),
 270                                  g_ptr_array_index (other->values, i)))
 271         result = _gtk_bitmask_set (result, i, TRUE);
 272     }
 273
 274   return result;
 275 }
 276
 277 /* TRANSITIONS */
 278
 279 typedef struct _TransitionInfo TransitionInfo;
 280 struct _TransitionInfo {
 281   guint index;                  /* index into value arrays */
 282   gboolean pending;             /* TRUE if we still need to handle it */
 283 };
 284
 285 static void
 286 transition_info_add (TransitionInfo    infos[GTK_CSS_PROPERTY_N_PROPERTIES],
 287                      GtkStyleProperty *property,
 288                      guint             index)
 289 {
 290   if (property == NULL)
 291     {
 292       guint i;
 293
 294       for (i = 0; i < _gtk_css_style_property_get_n_properties (); i++)
 295         {
 296           GtkCssStyleProperty *prop = _gtk_css_style_property_lookup_by_id (i);
 297
 298           transition_info_add (infos, GTK_STYLE_PROPERTY (prop), index);
 299         }
 300     }
 301   else if (GTK_IS_CSS_SHORTHAND_PROPERTY (property))
 302     {
 303       GtkCssShorthandProperty *shorthand = GTK_CSS_SHORTHAND_PROPERTY (property);
 304       guint i;
 305
 306       for (i = 0; i < _gtk_css_shorthand_property_get_n_subproperties (shorthand); i++)
 307         {
 308           GtkCssStyleProperty *prop = _gtk_css_shorthand_property_get_subproperty (shorthand, i);
 309
 310           transition_info_add (infos, GTK_STYLE_PROPERTY (prop), index);
 311         }
 312     }
 313   else if (GTK_IS_CSS_STYLE_PROPERTY (property))
 314     {
 315       guint id;
 316
 317       if (!_gtk_css_style_property_is_animated (GTK_CSS_STYLE_PROPERTY (property)))
 318         return;
 319
 320       id = _gtk_css_style_property_get_id (GTK_CSS_STYLE_PROPERTY (property));
 321       g_assert (id < GTK_CSS_PROPERTY_N_PROPERTIES);
 322       infos[id].index = index;
 323       infos[id].pending = TRUE;
 324     }
 325   else
 326     {
 327       g_assert_not_reached ();
 328     }
 329 }
 330
 331 static void
 332 transition_infos_set (TransitionInfo  infos[GTK_CSS_PROPERTY_N_PROPERTIES],
 333                       GtkCssValue    *transitions)
 334 {
 335   guint i;
 336
 337   for (i = 0; i < _gtk_css_array_value_get_n_values (transitions); i++)
 338     {
 339       GtkStyleProperty *property;
 340       GtkCssValue *prop_value;
 341
 342       prop_value = _gtk_css_array_value_get_nth (transitions, i);
 343       if (g_ascii_strcasecmp (_gtk_css_ident_value_get (prop_value), "all") == 0)
 344         property = NULL;
 345       else
 346         {
 347           property = _gtk_style_property_lookup (_gtk_css_ident_value_get (prop_value));
 348           if (property == NULL)
 349             continue;
 350         }
 351
 352       transition_info_add (infos, property, i);
 353     }
 354 }
 355
 356 static GtkStyleAnimation *
 357 gtk_css_computed_values_find_transition (GtkCssComputedValues *values,
 358                                          guint                 property_id)
 359 {
 360   GSList *list;
 361
 362   for (list = values->animations; list; list = list->next)
 363     {
 364       if (!GTK_IS_CSS_TRANSITION (list->data))
 365         continue;
 366
 367       if (_gtk_css_transition_get_property (list->data) == property_id)
 368         return list->data;
 369     }
 370
 371   return NULL;
 372 }
 373
 374 static void
 375 gtk_css_computed_values_create_css_transitions (GtkCssComputedValues *values,
 376                                                 gint64                timestamp,
 377                                                 GtkCssComputedValues *source)
 378 {
 379   TransitionInfo transitions[GTK_CSS_PROPERTY_N_PROPERTIES] = { { 0, } };
 380   GtkCssValue *durations, *delays, *timing_functions;
 381   guint i;
 382
 383   transition_infos_set (transitions, _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_TRANSITION_PROPERTY));
 384
 385   durations = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_TRANSITION_DURATION);
 386   delays = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_TRANSITION_DELAY);
 387   timing_functions = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION);
 388
 389   for (i = 0; i < GTK_CSS_PROPERTY_N_PROPERTIES; i++)
 390     {
 391       GtkStyleAnimation *animation;
 392       GtkCssValue *start, *end;
 393       double duration, delay;
 394
 395       if (!transitions[i].pending)
 396         continue;
 397
 398       duration = _gtk_css_number_value_get (_gtk_css_array_value_get_nth (durations, transitions[i].index), 100);
 399       delay = _gtk_css_number_value_get (_gtk_css_array_value_get_nth (delays, transitions[i].index), 100);
 400       if (duration + delay == 0.0)
 401         continue;
 402
 403       start = _gtk_css_computed_values_get_intrinsic_value (source, i);
 404       end = _gtk_css_computed_values_get_intrinsic_value (values, i);
 405       if (_gtk_css_value_equal (start, end))
 406         {
 407           animation = gtk_css_computed_values_find_transition (GTK_CSS_COMPUTED_VALUES (source), i);
 408           if (animation)
 409             values->animations = g_slist_prepend (values->animations, g_object_ref (animation));
 410         }
 411       else
 412         {
 413           animation = _gtk_css_transition_new (i,
 414                                                _gtk_css_computed_values_get_value (source, i),
 415                                                _gtk_css_array_value_get_nth (timing_functions, i),
 416                                                timestamp + delay * G_USEC_PER_SEC,
 417                                                timestamp + (delay + duration) * G_USEC_PER_SEC);
 418           values->animations = g_slist_prepend (values->animations, animation);
 419         }
 420     }
 421 }
 422
 423 static GtkStyleAnimation *
 424 gtk_css_computed_values_find_animation (GtkCssComputedValues *values,
 425                                         const char           *name)
 426 {
 427   GSList *list;
 428
 429   for (list = values->animations; list; list = list->next)
 430     {
 431       if (!GTK_IS_CSS_ANIMATION (list->data))
 432         continue;
 433
 434       if (g_str_equal (_gtk_css_animation_get_name (list->data), name))
 435         return list->data;
 436     }
 437
 438   return NULL;
 439 }
 440
 441 static void
 442 gtk_css_computed_values_create_css_animations (GtkCssComputedValues    *values,
 443                                                GtkCssComputedValues    *parent_values,
 444                                                gint64                   timestamp,
 445                                                GtkStyleProviderPrivate *provider,
 446                                                GtkCssComputedValues    *source)
 447 {
 448   GtkCssValue *durations, *delays, *timing_functions, *animations;
 449   GtkCssValue *iteration_counts, *directions, *play_states, *fill_modes;
 450   guint i;
 451
 452   animations = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_ANIMATION_NAME);
 453   durations = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_ANIMATION_DURATION);
 454   delays = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_ANIMATION_DELAY);
 455   timing_functions = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_ANIMATION_TIMING_FUNCTION);
 456   iteration_counts = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_ANIMATION_ITERATION_COUNT);
 457   directions = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_ANIMATION_DIRECTION);
 458   play_states = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_ANIMATION_PLAY_STATE);
 459   fill_modes = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_ANIMATION_FILL_MODE);
 460
 461   for (i = 0; i < _gtk_css_array_value_get_n_values (animations); i++)
 462     {
 463       GtkStyleAnimation *animation;
 464       GtkCssKeyframes *keyframes;
 465       const char *name;
 466
 467       name = _gtk_css_ident_value_get (_gtk_css_array_value_get_nth (animations, i));
 468       if (g_ascii_strcasecmp (name, "none") == 0)
 469         continue;
 470
 471       animation = gtk_css_computed_values_find_animation (values, name);
 472       if (animation)
 473         continue;
 474
 475       if (source)
 476         animation = gtk_css_computed_values_find_animation (source, name);
 477
 478       if (animation)
 479         {
 480           animation = _gtk_css_animation_copy (GTK_CSS_ANIMATION (animation),
 481                                                timestamp,
 482                                                _gtk_css_play_state_value_get (_gtk_css_array_value_get_nth (play_states, i)));
 483         }
 484       else
 485         {
 486           keyframes = _gtk_style_provider_private_get_keyframes (provider, name);
 487           if (keyframes == NULL)
 488             continue;
 489
 490           keyframes = _gtk_css_keyframes_compute (keyframes, provider, values, parent_values);
 491
 492           animation = _gtk_css_animation_new (name,
 493                                               keyframes,
 494                                               timestamp,
 495                                               _gtk_css_number_value_get (_gtk_css_array_value_get_nth (delays, i), 100) * G_USEC_PER_SEC,
 496                                               _gtk_css_number_value_get (_gtk_css_array_value_get_nth (durations, i), 100) * G_USEC_PER_SEC,
 497                                               _gtk_css_array_value_get_nth (timing_functions, i),
 498                                               _gtk_css_direction_value_get (_gtk_css_array_value_get_nth (directions, i)),
 499                                               _gtk_css_play_state_value_get (_gtk_css_array_value_get_nth (play_states, i)),
 500                                               _gtk_css_fill_mode_value_get (_gtk_css_array_value_get_nth (fill_modes, i)),
 501                                               _gtk_css_number_value_get (_gtk_css_array_value_get_nth (iteration_counts, i), 100));
 502           _gtk_css_keyframes_unref (keyframes);
 503         }
 504       values->animations = g_slist_prepend (values->animations, animation);
 505     }
 506 }
 507
 508 /* PUBLIC API */
 509
 510 void
 511 _gtk_css_computed_values_create_animations (GtkCssComputedValues    *values,
 512                                             GtkCssComputedValues    *parent_values,
 513                                             gint64                   timestamp,
 514                                             GtkStyleProviderPrivate *provider,
 515                                             GtkCssComputedValues    *source)
 516 {
 517   if (source != NULL)
 518     gtk_css_computed_values_create_css_transitions (values, timestamp, source);
 519   gtk_css_computed_values_create_css_animations (values, parent_values, timestamp, provider, source);
 520 }
 521
 522 GtkBitmask *
 523 _gtk_css_computed_values_advance (GtkCssComputedValues *values,
 524                                   gint64                timestamp)
 525 {
 526   GtkBitmask *changed;
 527   GPtrArray *old_computed_values;
 528   GSList *list;
 529   guint i;
 530
 531   g_return_val_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values), NULL);
 532   g_return_val_if_fail (timestamp >= values->current_time, NULL);
 533
 534   values->current_time = timestamp;
 535   old_computed_values = values->animated_values;
 536   values->animated_values = NULL;
 537
 538   list = values->animations;
 539   while (list)
 540     {
 541       GtkStyleAnimation *animation = list->data;
 542
 543       list = list->next;
 544
 545       _gtk_style_animation_set_values (animation,
 546                                        timestamp,
 547                                        GTK_CSS_COMPUTED_VALUES (values));
 548
 549       if (_gtk_style_animation_is_finished (animation, timestamp))
 550         {
 551           values->animations = g_slist_remove (values->animations, animation);
 552           g_object_unref (animation);
 553         }
 554     }
 555
 556   /* figure out changes */
 557   changed = _gtk_bitmask_new ();
 558
 559   for (i = 0; i < GTK_CSS_PROPERTY_N_PROPERTIES; i++)
 560     {
 561       GtkCssValue *old_animated, *new_animated;
 562
 563       old_animated = old_computed_values && i < old_computed_values->len ? g_ptr_array_index (old_computed_values, i) : NULL;
 564       new_animated = values->animated_values && i < values->animated_values->len ? g_ptr_array_index (values->animated_values, i) : NULL;
 565
 566       if (!_gtk_css_value_equal0 (old_animated, new_animated))
 567         changed = _gtk_bitmask_set (changed, i, TRUE);
 568     }
 569
 570   if (old_computed_values)
 571     g_ptr_array_unref (old_computed_values);
 572
 573   return changed;
 574 }
 575
 576 gboolean
 577 _gtk_css_computed_values_is_static (GtkCssComputedValues *values)
 578 {
 579   GSList *list;
 580
 581   g_return_val_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values), TRUE);
 582
 583   for (list = values->animations; list; list = list->next)
 584     {
 585       if (!_gtk_style_animation_is_static (list->data, values->current_time))
 586         return FALSE;
 587     }
 588
 589   return TRUE;
 590 }
 591
 592 void
 593 _gtk_css_computed_values_cancel_animations (GtkCssComputedValues *values)
 594 {
 595   g_return_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values));
 596
 597   if (values->animated_values)
 598     {
 599       g_ptr_array_unref (values->animated_values);
 600       values->animated_values = NULL;
 601     }
 602
 603   g_slist_free_full (values->animations, g_object_unref);
 604   values->animations = NULL;
 605 }
 606
 607 GtkBitmask *
 608 _gtk_css_computed_values_compute_dependencies (GtkCssComputedValues *values,
 609                                                const GtkBitmask     *parent_changes)
 610 {
 611   GtkBitmask *changes;
 612
 613   g_return_val_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values), _gtk_bitmask_new ());
 614
 615   changes = _gtk_bitmask_copy (parent_changes);
 616   changes = _gtk_bitmask_intersect (changes, values->depends_on_parent);
 617   if (_gtk_bitmask_get (changes, GTK_CSS_PROPERTY_COLOR))
 618     changes = _gtk_bitmask_union (changes, values->depends_on_color);
 619   if (_gtk_bitmask_get (changes, GTK_CSS_PROPERTY_FONT_SIZE))
 620     changes = _gtk_bitmask_union (changes, values->depends_on_font_size);
 621
 622   return changes;
 623 }
 624