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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2011 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 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
  18 #include "config.h"
  19
  20 #include "gtkcssarrayvalueprivate.h"
  21 #include "gtkcssimagevalueprivate.h"
  22 #include "gtkcssstylepropertyprivate.h"
  23
  24 #include <string.h>
  25
  26 struct _GtkCssValue {
  27   GTK_CSS_VALUE_BASE
  28   guint         n_values;
  29   GtkCssValue  *values[1];
  30 };
  31
  32 static void
  33 gtk_css_value_array_free (GtkCssValue *value)
  34 {
  35   guint i;
  36
  37   for (i = 0; i < value->n_values; i++)
  38     {
  39       _gtk_css_value_unref (value->values[i]);
  40     }
  41
  42   g_slice_free1 (sizeof (GtkCssValue) + sizeof (GtkCssValue *) * (value->n_values - 1), value);
  43 }
  44
  45 static GtkCssValue *
  46 gtk_css_value_array_compute (GtkCssValue        *value,
  47                              guint               property_id,
  48                              GtkStyleContext    *context,
  49                              GtkCssDependencies *dependencies)
  50 {
  51   GtkCssValue *result;
  52   gboolean changed = FALSE;
  53   guint i;
  54   GtkCssDependencies child_deps;
  55
  56   if (value->n_values == 0)
  57     return _gtk_css_value_ref (value);
  58
  59   result = _gtk_css_array_value_new_from_array (value->values, value->n_values);
  60   for (i = 0; i < value->n_values; i++)
  61     {
  62       result->values[i] = _gtk_css_value_compute (value->values[i], property_id, context, &child_deps);
  63
  64       *dependencies = _gtk_css_dependencies_union (*dependencies, child_deps);
  65
  66       changed |= (result->values[i] != value->values[i]);
  67     }
  68
  69   if (!changed)
  70     {
  71       _gtk_css_value_unref (result);
  72       return _gtk_css_value_ref (value);
  73     }
  74
  75   return result;
  76 }
  77
  78 static gboolean
  79 gtk_css_value_array_equal (const GtkCssValue *value1,
  80                            const GtkCssValue *value2)
  81 {
  82   guint i;
  83
  84   if (value1->n_values != value2->n_values)
  85     return FALSE;
  86
  87   for (i = 0; i < value1->n_values; i++)
  88     {
  89       if (!_gtk_css_value_equal (value1->values[i],
  90                                  value2->values[i]))
  91         return FALSE;
  92     }
  93
  94   return TRUE;
  95 }
  96
  97 static guint
  98 gcd (guint a, guint b)
  99 {
 100   while (b != 0)
 101     {
 102       guint t = b;
 103       b = a % b;
 104       a = t;
 105     }
 106   return a;
 107 }
 108
 109 static guint
 110 lcm (guint a, guint b)
 111 {
 112   return a / gcd (a, b) * b;
 113 }
 114
 115 static GtkCssValue *
 116 gtk_css_value_array_transition_repeat (GtkCssValue *start,
 117                                        GtkCssValue *end,
 118                                        guint        property_id,
 119                                        double       progress)
 120 {
 121   GtkCssValue **transitions;
 122   guint i, n;
 123
 124   n = lcm (start->n_values, end->n_values);
 125   transitions = g_newa (GtkCssValue *, n);
 126
 127   for (i = 0; i < n; i++)
 128     {
 129       transitions[i] = _gtk_css_value_transition (start->values[i % start->n_values],
 130                                                   end->values[i % end->n_values],
 131                                                   property_id,
 132                                                   progress);
 133       if (transitions[i] == NULL)
 134         {
 135           while (i--)
 136             _gtk_css_value_unref (transitions[i]);
 137           return NULL;
 138         }
 139     }
 140
 141   return _gtk_css_array_value_new_from_array (transitions, n);
 142 }
 143
 144 static GtkCssValue *
 145 gtk_css_array_value_create_default_transition_value (guint property_id)
 146 {
 147   switch (property_id)
 148     {
 149     case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
 150       return _gtk_css_image_value_new (NULL);
 151     default:
 152       g_return_val_if_reached (NULL);
 153     }
 154 }
 155
 156 static GtkCssValue *
 157 gtk_css_value_array_transition_extend (GtkCssValue *start,
 158                                        GtkCssValue *end,
 159                                        guint        property_id,
 160                                        double       progress)
 161 {
 162   GtkCssValue **transitions;
 163   guint i, n;
 164
 165   n = MAX (start->n_values, end->n_values);
 166   transitions = g_newa (GtkCssValue *, n);
 167
 168   for (i = 0; i < MIN (start->n_values, end->n_values); i++)
 169     {
 170       transitions[i] = _gtk_css_value_transition (start->values[i],
 171                                                   end->values[i],
 172                                                   property_id,
 173                                                   progress);
 174       if (transitions[i] == NULL)
 175         {
 176           while (i--)
 177             _gtk_css_value_unref (transitions[i]);
 178           return NULL;
 179         }
 180     }
 181
 182   if (start->n_values != end->n_values)
 183     {
 184       GtkCssValue *default_value;
 185
 186       default_value = gtk_css_array_value_create_default_transition_value (property_id);
 187
 188       for (; i < start->n_values; i++)
 189         {
 190           transitions[i] = _gtk_css_value_transition (start->values[i],
 191                                                       default_value,
 192                                                       property_id,
 193                                                       progress);
 194           if (transitions[i] == NULL)
 195             {
 196               while (i--)
 197                 _gtk_css_value_unref (transitions[i]);
 198               return NULL;
 199             }
 200         }
 201
 202       for (; i < end->n_values; i++)
 203         {
 204           transitions[i] = _gtk_css_value_transition (default_value,
 205                                                       end->values[i],
 206                                                       property_id,
 207                                                       progress);
 208           if (transitions[i] == NULL)
 209             {
 210               while (i--)
 211                 _gtk_css_value_unref (transitions[i]);
 212               return NULL;
 213             }
 214         }
 215
 216     }
 217
 218   g_assert (i == n);
 219
 220   return _gtk_css_array_value_new_from_array (transitions, n);
 221 }
 222
 223 static GtkCssValue *
 224 gtk_css_value_array_transition (GtkCssValue *start,
 225                                 GtkCssValue *end,
 226                                 guint        property_id,
 227                                 double       progress)
 228 {
 229   switch (property_id)
 230     {
 231     case GTK_CSS_PROPERTY_BACKGROUND_CLIP:
 232     case GTK_CSS_PROPERTY_BACKGROUND_ORIGIN:
 233     case GTK_CSS_PROPERTY_BACKGROUND_SIZE:
 234     case GTK_CSS_PROPERTY_BACKGROUND_POSITION:
 235     case GTK_CSS_PROPERTY_BACKGROUND_REPEAT:
 236       return gtk_css_value_array_transition_repeat (start, end, property_id, progress);
 237     case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
 238       return gtk_css_value_array_transition_extend (start, end, property_id, progress);
 239     case GTK_CSS_PROPERTY_COLOR:
 240     case GTK_CSS_PROPERTY_FONT_SIZE:
 241     case GTK_CSS_PROPERTY_BACKGROUND_COLOR:
 242     case GTK_CSS_PROPERTY_FONT_FAMILY:
 243     case GTK_CSS_PROPERTY_FONT_STYLE:
 244     case GTK_CSS_PROPERTY_FONT_VARIANT:
 245     case GTK_CSS_PROPERTY_FONT_WEIGHT:
 246     case GTK_CSS_PROPERTY_TEXT_SHADOW:
 247     case GTK_CSS_PROPERTY_ICON_SHADOW:
 248     case GTK_CSS_PROPERTY_BOX_SHADOW:
 249     case GTK_CSS_PROPERTY_MARGIN_TOP:
 250     case GTK_CSS_PROPERTY_MARGIN_LEFT:
 251     case GTK_CSS_PROPERTY_MARGIN_BOTTOM:
 252     case GTK_CSS_PROPERTY_MARGIN_RIGHT:
 253     case GTK_CSS_PROPERTY_PADDING_TOP:
 254     case GTK_CSS_PROPERTY_PADDING_LEFT:
 255     case GTK_CSS_PROPERTY_PADDING_BOTTOM:
 256     case GTK_CSS_PROPERTY_PADDING_RIGHT:
 257     case GTK_CSS_PROPERTY_BORDER_TOP_STYLE:
 258     case GTK_CSS_PROPERTY_BORDER_TOP_WIDTH:
 259     case GTK_CSS_PROPERTY_BORDER_LEFT_STYLE:
 260     case GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH:
 261     case GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE:
 262     case GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH:
 263     case GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE:
 264     case GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH:
 265     case GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS:
 266     case GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS:
 267     case GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS:
 268     case GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS:
 269     case GTK_CSS_PROPERTY_OUTLINE_STYLE:
 270     case GTK_CSS_PROPERTY_OUTLINE_WIDTH:
 271     case GTK_CSS_PROPERTY_OUTLINE_OFFSET:
 272     case GTK_CSS_PROPERTY_BORDER_TOP_COLOR:
 273     case GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR:
 274     case GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR:
 275     case GTK_CSS_PROPERTY_BORDER_LEFT_COLOR:
 276     case GTK_CSS_PROPERTY_OUTLINE_COLOR:
 277     case GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE:
 278     case GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT:
 279     case GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE:
 280     case GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH:
 281     case GTK_CSS_PROPERTY_ENGINE:
 282     default:
 283       /* keep all values that are not arrays here, so we get a warning if we ever turn them
 284        * into arrays and start animating them. */
 285       g_warning ("Don't know how to transition arrays for property '%s'",
 286                  _gtk_style_property_get_name (GTK_STYLE_PROPERTY (_gtk_css_style_property_lookup_by_id (property_id))));
 287     case GTK_CSS_PROPERTY_TRANSITION_PROPERTY:
 288     case GTK_CSS_PROPERTY_TRANSITION_DURATION:
 289     case GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION:
 290     case GTK_CSS_PROPERTY_TRANSITION_DELAY:
 291     case GTK_CSS_PROPERTY_GTK_KEY_BINDINGS:
 292       return NULL;
 293     }
 294 }
 295
 296 static void
 297 gtk_css_value_array_print (const GtkCssValue *value,
 298                            GString           *string)
 299 {
 300   guint i;
 301
 302   if (value->n_values == 0)
 303     {
 304       g_string_append (string, "none");
 305       return;
 306     }
 307
 308   for (i = 0; i < value->n_values; i++)
 309     {
 310       if (i > 0)
 311         g_string_append (string, ", ");
 312       _gtk_css_value_print (value->values[i], string);
 313     }
 314 }
 315
 316 static const GtkCssValueClass GTK_CSS_VALUE_ARRAY = {
 317   gtk_css_value_array_free,
 318   gtk_css_value_array_compute,
 319   gtk_css_value_array_equal,
 320   gtk_css_value_array_transition,
 321   gtk_css_value_array_print
 322 };
 323
 324 GtkCssValue *
 325 _gtk_css_array_value_new (GtkCssValue *content)
 326 {
 327   g_return_val_if_fail (content != NULL, NULL);
 328
 329   return _gtk_css_array_value_new_from_array (&content, 1);
 330 }
 331
 332 GtkCssValue *
 333 _gtk_css_array_value_new_from_array (GtkCssValue **values,
 334                                      guint         n_values)
 335 {
 336   GtkCssValue *result;
 337
 338   g_return_val_if_fail (values != NULL, NULL);
 339   g_return_val_if_fail (n_values > 0, NULL);
 340
 341   result = _gtk_css_value_alloc (&GTK_CSS_VALUE_ARRAY, sizeof (GtkCssValue) + sizeof (GtkCssValue *) * (n_values - 1));
 342   result->n_values = n_values;
 343   memcpy (&result->values[0], values, sizeof (GtkCssValue *) * n_values);
 344
 345   return result;
 346 }
 347
 348 GtkCssValue *
 349 _gtk_css_array_value_parse (GtkCssParser *parser,
 350                             GtkCssValue  *(* parse_func) (GtkCssParser *parser))
 351 {
 352   GtkCssValue *value, *result;
 353   GPtrArray *values;
 354
 355   values = g_ptr_array_new ();
 356
 357   do {
 358     value = parse_func (parser);
 359
 360     if (value == NULL)
 361       {
 362         g_ptr_array_set_free_func (values, (GDestroyNotify) _gtk_css_value_unref);
 363         g_ptr_array_free (values, TRUE);
 364         return NULL;
 365       }
 366
 367     g_ptr_array_add (values, value);
 368   } while (_gtk_css_parser_try (parser, ",", TRUE));
 369
 370   result = _gtk_css_array_value_new_from_array ((GtkCssValue **) values->pdata, values->len);
 371   g_ptr_array_free (values, TRUE);
 372   return result;
 373 }
 374
 375 GtkCssValue *
 376 _gtk_css_array_value_get_nth (const GtkCssValue *value,
 377                               guint              i)
 378 {
 379   g_return_val_if_fail (value != NULL, NULL);
 380   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_ARRAY, NULL);
 381   g_return_val_if_fail (value->n_values > 0, NULL);
 382
 383   return value->values[i % value->n_values];
 384 }
 385
 386 guint
 387 _gtk_css_array_value_get_n_values (const GtkCssValue *value)
 388 {
 389   g_return_val_if_fail (value != NULL, 0);
 390   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_ARRAY, 0);
 391
 392   return value->n_values;
 393 }
 394