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