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