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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2010 Carlos Garnacho <carlosg@gnome.org>
   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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gtkstylepropertiesprivate.h"
  23
  24 #include <stdlib.h>
  25 #include <gobject/gvaluecollector.h>
  26 #include <cairo-gobject.h>
  27
  28 #include "gtkstyleprovider.h"
  29 #include "gtksymboliccolor.h"
  30 #include "gtkthemingengine.h"
  31 #include "gtkanimationdescription.h"
  32 #include "gtkgradient.h"
  33 #include "gtkshadowprivate.h"
  34 #include "gtkcssshorthandpropertyprivate.h"
  35 #include "gtkcsstypesprivate.h"
  36 #include "gtkborderimageprivate.h"
  37
  38 #include "gtkprivatetypebuiltins.h"
  39 #include "gtkstylepropertyprivate.h"
  40 #include "gtkstyleproviderprivate.h"
  41 #include "gtkintl.h"
  42
  43 #include "gtkwin32themeprivate.h"
  44
  45 /**
  46  * SECTION:gtkstyleproperties
  47  * @Short_description: Store for style property information
  48  * @Title: GtkStyleProperties
  49  *
  50  * GtkStyleProperties provides the storage for style information
  51  * that is used by #GtkStyleContext and other #GtkStyleProvider
  52  * implementations.
  53  *
  54  * Before style properties can be stored in GtkStyleProperties, they
  55  * must be registered with gtk_style_properties_register_property().
  56  *
  57  * Unless you are writing a #GtkStyleProvider implementation, you
  58  * are unlikely to use this API directly, as gtk_style_context_get()
  59  * and its variants are the preferred way to access styling information
  60  * from widget implementations and theming engine implementations
  61  * should use the APIs provided by #GtkThemingEngine instead.
  62  */
  63
  64 typedef struct PropertyData PropertyData;
  65 typedef struct ValueData ValueData;
  66
  67 struct ValueData
  68 {
  69   GtkStateFlags state;
  70   GValue value;
  71 };
  72
  73 struct PropertyData
  74 {
  75   GArray *values;
  76 };
  77
  78 struct _GtkStylePropertiesPrivate
  79 {
  80   GHashTable *color_map;
  81   GHashTable *properties;
  82   GtkSymbolicColorLookupFunc color_lookup_func;
  83   gpointer color_lookup_data;
  84 };
  85
  86 static void gtk_style_properties_provider_init         (GtkStyleProviderIface            *iface);
  87 static void gtk_style_properties_provider_private_init (GtkStyleProviderPrivateInterface *iface);
  88 static void gtk_style_properties_finalize              (GObject                          *object);
  89
  90
  91 G_DEFINE_TYPE_EXTENDED (GtkStyleProperties, gtk_style_properties, G_TYPE_OBJECT, 0,
  92                         G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER,
  93                                                gtk_style_properties_provider_init)
  94                         G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER_PRIVATE,
  95                                                gtk_style_properties_provider_private_init));
  96
  97 static void
  98 gtk_style_properties_class_init (GtkStylePropertiesClass *klass)
  99 {
 100   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 101
 102   object_class->finalize = gtk_style_properties_finalize;
 103
 104   g_type_class_add_private (object_class, sizeof (GtkStylePropertiesPrivate));
 105 }
 106
 107 static PropertyData *
 108 property_data_new (void)
 109 {
 110   PropertyData *data;
 111
 112   data = g_slice_new0 (PropertyData);
 113   data->values = g_array_new (FALSE, FALSE, sizeof (ValueData));
 114
 115   return data;
 116 }
 117
 118 static void
 119 property_data_remove_values (PropertyData *data)
 120 {
 121   guint i;
 122
 123   for (i = 0; i < data->values->len; i++)
 124     {
 125       ValueData *value_data;
 126
 127       value_data = &g_array_index (data->values, ValueData, i);
 128
 129       if (G_IS_VALUE (&value_data->value))
 130         g_value_unset (&value_data->value);
 131     }
 132
 133   if (data->values->len > 0)
 134     g_array_remove_range (data->values, 0, data->values->len);
 135 }
 136
 137 static void
 138 property_data_free (PropertyData *data)
 139 {
 140   property_data_remove_values (data);
 141   g_array_free (data->values, TRUE);
 142   g_slice_free (PropertyData, data);
 143 }
 144
 145 static gboolean
 146 property_data_find_position (PropertyData  *data,
 147                              GtkStateFlags  state,
 148                              guint         *pos)
 149 {
 150   gint min, max, mid;
 151   gboolean found = FALSE;
 152   guint position;
 153
 154   if (pos)
 155     *pos = 0;
 156
 157   if (data->values->len == 0)
 158     return FALSE;
 159
 160   /* Find position for the given state, or the position where
 161    * it would be if not found, the array is ordered by the
 162    * state flags.
 163    */
 164   min = 0;
 165   max = data->values->len - 1;
 166
 167   do
 168     {
 169       ValueData *value_data;
 170
 171       mid = (min + max) / 2;
 172       value_data = &g_array_index (data->values, ValueData, mid);
 173
 174       if (value_data->state == state)
 175         {
 176           found = TRUE;
 177           position = mid;
 178         }
 179       else if (value_data->state < state)
 180           position = min = mid + 1;
 181       else
 182         {
 183           max = mid - 1;
 184           position = mid;
 185         }
 186     }
 187   while (!found && min <= max);
 188
 189   if (pos)
 190     *pos = position;
 191
 192   return found;
 193 }
 194
 195 static GValue *
 196 property_data_get_value (PropertyData  *data,
 197                          GtkStateFlags  state)
 198 {
 199   ValueData *val_data;
 200   guint pos;
 201
 202   if (!property_data_find_position (data, state, &pos))
 203     {
 204       ValueData new = { 0 };
 205
 206       new.state = state;
 207       g_array_insert_val (data->values, pos, new);
 208     }
 209
 210   val_data = &g_array_index (data->values, ValueData, pos);
 211
 212   return &val_data->value;
 213 }
 214
 215 static GValue *
 216 property_data_match_state (PropertyData  *data,
 217                            GtkStateFlags  state)
 218 {
 219   guint pos;
 220   gint i;
 221
 222   if (property_data_find_position (data, state, &pos))
 223     {
 224       ValueData *val_data;
 225
 226       /* Exact match */
 227       val_data = &g_array_index (data->values, ValueData, pos);
 228       return &val_data->value;
 229     }
 230
 231   if (pos >= data->values->len)
 232     pos = data->values->len - 1;
 233
 234   /* No exact match, go downwards the list to find
 235    * the closest match to the given state flags, as
 236    * a side effect, there is an implicit precedence
 237    * of higher flags over the smaller ones.
 238    */
 239   for (i = pos; i >= 0; i--)
 240     {
 241       ValueData *val_data;
 242
 243       val_data = &g_array_index (data->values, ValueData, i);
 244
 245        /* Check whether any of the requested
 246         * flags are set, and no other flags are.
 247         *
 248         * Also, no flags acts as a wildcard, such
 249         * value should be always in the first position
 250         * in the array (if present) anyways.
 251         */
 252       if (val_data->state == 0 ||
 253           ((val_data->state & state) != 0 &&
 254            (val_data->state & ~state) == 0))
 255         return &val_data->value;
 256     }
 257
 258   return NULL;
 259 }
 260
 261 static void
 262 gtk_style_properties_init (GtkStyleProperties *props)
 263 {
 264   GtkStylePropertiesPrivate *priv;
 265
 266   priv = props->priv = G_TYPE_INSTANCE_GET_PRIVATE (props,
 267                                                     GTK_TYPE_STYLE_PROPERTIES,
 268                                                     GtkStylePropertiesPrivate);
 269
 270   priv->properties = g_hash_table_new_full (NULL, NULL, NULL,
 271                                             (GDestroyNotify) property_data_free);
 272 }
 273
 274 static void
 275 gtk_style_properties_finalize (GObject *object)
 276 {
 277   GtkStylePropertiesPrivate *priv;
 278   GtkStyleProperties *props;
 279
 280   props = GTK_STYLE_PROPERTIES (object);
 281   priv = props->priv;
 282   g_hash_table_destroy (priv->properties);
 283
 284   if (priv->color_map)
 285     g_hash_table_destroy (priv->color_map);
 286
 287   G_OBJECT_CLASS (gtk_style_properties_parent_class)->finalize (object);
 288 }
 289
 290 GtkStyleProperties *
 291 gtk_style_properties_get_style (GtkStyleProvider *provider,
 292                                 GtkWidgetPath    *path)
 293 {
 294   /* Return style set itself */
 295   return g_object_ref (provider);
 296 }
 297
 298 static void
 299 gtk_style_properties_provider_init (GtkStyleProviderIface *iface)
 300 {
 301   iface->get_style = gtk_style_properties_get_style;
 302 }
 303
 304 static GtkSymbolicColor *
 305 gtk_style_properties_provider_get_color (GtkStyleProviderPrivate *provider,
 306                                          const char              *name)
 307 {
 308   return gtk_style_properties_lookup_color (GTK_STYLE_PROPERTIES (provider), name);
 309 }
 310
 311 static void
 312 gtk_style_properties_provider_lookup (GtkStyleProviderPrivate *provider,
 313                                       GtkWidgetPath           *path,
 314                                       GtkStateFlags            state,
 315                                       GtkCssLookup            *lookup)
 316 {
 317   GtkStyleProperties *props;
 318   GtkStylePropertiesPrivate *priv;
 319   GHashTableIter iter;
 320   gpointer key, value;
 321
 322   props = GTK_STYLE_PROPERTIES (provider);
 323   priv = props->priv;
 324
 325   /* Merge symbolic style properties */
 326   g_hash_table_iter_init (&iter, priv->properties);
 327
 328   while (g_hash_table_iter_next (&iter, &key, &value))
 329     {
 330       GtkCssStyleProperty *prop = key;
 331       PropertyData *data = value;
 332       const GValue *value;
 333       guint id;
 334
 335       id = _gtk_css_style_property_get_id (prop);
 336
 337       if (!_gtk_css_lookup_is_missing (lookup, id))
 338           continue;
 339
 340       value = property_data_match_state (data, state);
 341       if (value == NULL)
 342         continue;
 343
 344       _gtk_css_lookup_set (lookup, id, NULL, value);
 345     }
 346 }
 347
 348 static void
 349 gtk_style_properties_provider_private_init (GtkStyleProviderPrivateInterface *iface)
 350 {
 351   iface->get_color = gtk_style_properties_provider_get_color;
 352   iface->lookup = gtk_style_properties_provider_lookup;
 353 }
 354
 355 /* GtkStyleProperties methods */
 356
 357 /**
 358  * gtk_style_properties_new:
 359  *
 360  * Returns a newly created #GtkStyleProperties
 361  *
 362  * Returns: a new #GtkStyleProperties
 363  **/
 364 GtkStyleProperties *
 365 gtk_style_properties_new (void)
 366 {
 367   return g_object_new (GTK_TYPE_STYLE_PROPERTIES, NULL);
 368 }
 369
 370 void
 371 _gtk_style_properties_set_color_lookup_func (GtkStyleProperties         *props,
 372                                              GtkSymbolicColorLookupFunc  func,
 373                                              gpointer                    data)
 374 {
 375   GtkStylePropertiesPrivate *priv;
 376
 377   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 378   g_return_if_fail (func != NULL);
 379
 380   priv = props->priv;
 381   g_return_if_fail (priv->color_map == NULL);
 382
 383   priv->color_lookup_func = func;
 384   priv->color_lookup_data = data;
 385 }
 386
 387 /**
 388  * gtk_style_properties_map_color:
 389  * @props: a #GtkStyleProperties
 390  * @name: color name
 391  * @color: #GtkSymbolicColor to map @name to
 392  *
 393  * Maps @color so it can be referenced by @name. See
 394  * gtk_style_properties_lookup_color()
 395  *
 396  * Since: 3.0
 397  **/
 398 void
 399 gtk_style_properties_map_color (GtkStyleProperties *props,
 400                                 const gchar        *name,
 401                                 GtkSymbolicColor   *color)
 402 {
 403   GtkStylePropertiesPrivate *priv;
 404
 405   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 406   g_return_if_fail (name != NULL);
 407   g_return_if_fail (color != NULL);
 408
 409   priv = props->priv;
 410   g_return_if_fail (priv->color_lookup_func == NULL);
 411
 412   if (G_UNLIKELY (!priv->color_map))
 413     priv->color_map = g_hash_table_new_full (g_str_hash,
 414                                              g_str_equal,
 415                                              (GDestroyNotify) g_free,
 416                                              (GDestroyNotify) gtk_symbolic_color_unref);
 417
 418   g_hash_table_replace (priv->color_map,
 419                         g_strdup (name),
 420                         gtk_symbolic_color_ref (color));
 421 }
 422
 423 /**
 424  * gtk_style_properties_lookup_color:
 425  * @props: a #GtkStyleProperties
 426  * @name: color name to lookup
 427  *
 428  * Returns the symbolic color that is mapped
 429  * to @name.
 430  *
 431  * Returns: (transfer none): The mapped color
 432  *
 433  * Since: 3.0
 434  **/
 435 GtkSymbolicColor *
 436 gtk_style_properties_lookup_color (GtkStyleProperties *props,
 437                                    const gchar        *name)
 438 {
 439   GtkStylePropertiesPrivate *priv;
 440
 441   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), NULL);
 442   g_return_val_if_fail (name != NULL, NULL);
 443
 444   priv = props->priv;
 445
 446   if (priv->color_lookup_func)
 447     return priv->color_lookup_func (priv->color_lookup_data, name);
 448
 449   if (!priv->color_map)
 450     return NULL;
 451
 452   return g_hash_table_lookup (priv->color_map, name);
 453 }
 454
 455 void
 456 _gtk_style_properties_set_property_by_property (GtkStyleProperties  *props,
 457                                                 GtkCssStyleProperty *style_prop,
 458                                                 GtkStateFlags        state,
 459                                                 const GValue        *value)
 460 {
 461   GtkStylePropertiesPrivate *priv;
 462   PropertyData *prop;
 463   GValue *val;
 464
 465   priv = props->priv;
 466   prop = g_hash_table_lookup (priv->properties, style_prop);
 467
 468   if (!prop)
 469     {
 470       prop = property_data_new ();
 471       g_hash_table_insert (priv->properties, (gpointer) style_prop, prop);
 472     }
 473
 474   val = property_data_get_value (prop, state);
 475
 476   if (G_VALUE_TYPE (val) == G_VALUE_TYPE (value))
 477     g_value_reset (val);
 478   else
 479     {
 480       if (G_IS_VALUE (val))
 481         g_value_unset (val);
 482
 483       g_value_init (val, G_VALUE_TYPE (value));
 484     }
 485
 486   g_value_copy (value, val);
 487 }
 488
 489 /**
 490  * gtk_style_properties_set_property:
 491  * @props: a #GtkStyleProperties
 492  * @property: styling property to set
 493  * @state: state to set the value for
 494  * @value: new value for the property
 495  *
 496  * Sets a styling property in @props.
 497  *
 498  * Since: 3.0
 499  **/
 500 void
 501 gtk_style_properties_set_property (GtkStyleProperties *props,
 502                                    const gchar        *property,
 503                                    GtkStateFlags       state,
 504                                    const GValue       *value)
 505 {
 506   GtkStyleProperty *node;
 507
 508   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 509   g_return_if_fail (property != NULL);
 510   g_return_if_fail (value != NULL);
 511
 512   node = _gtk_style_property_lookup (property);
 513
 514   if (!node)
 515     {
 516       g_warning ("Style property \"%s\" is not registered", property);
 517       return;
 518     }
 519   if (_gtk_style_property_get_value_type (node) == G_TYPE_NONE)
 520     {
 521       g_warning ("Style property \"%s\" is not settable", property);
 522       return;
 523     }
 524
 525   _gtk_style_property_assign (node, props, state, value);
 526 }
 527
 528 /**
 529  * gtk_style_properties_set_valist:
 530  * @props: a #GtkStyleProperties
 531  * @state: state to set the values for
 532  * @args: va_list of property name/value pairs, followed by %NULL
 533  *
 534  * Sets several style properties on @props.
 535  *
 536  * Since: 3.0
 537  **/
 538 void
 539 gtk_style_properties_set_valist (GtkStyleProperties *props,
 540                                  GtkStateFlags       state,
 541                                  va_list             args)
 542 {
 543   const gchar *property_name;
 544
 545   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 546
 547   property_name = va_arg (args, const gchar *);
 548
 549   while (property_name)
 550     {
 551       GtkStyleProperty *node;
 552       gchar *error = NULL;
 553       GType val_type;
 554       GValue val = G_VALUE_INIT;
 555
 556       node = _gtk_style_property_lookup (property_name);
 557
 558       if (!node)
 559         {
 560           g_warning ("Style property \"%s\" is not registered", property_name);
 561           break;
 562         }
 563
 564       val_type = _gtk_style_property_get_value_type (node);
 565       if (val_type == G_TYPE_NONE)
 566         {
 567           g_warning ("Style property \"%s\" is not settable", property_name);
 568           break;
 569         }
 570
 571       G_VALUE_COLLECT_INIT (&val, _gtk_style_property_get_value_type (node),
 572                             args, 0, &error);
 573       if (error)
 574         {
 575           g_warning ("Could not set style property \"%s\": %s", property_name, error);
 576           g_value_unset (&val);
 577           g_free (error);
 578           break;
 579         }
 580
 581       _gtk_style_property_assign (node, props, state, &val);
 582       g_value_unset (&val);
 583
 584       property_name = va_arg (args, const gchar *);
 585     }
 586 }
 587
 588 /**
 589  * gtk_style_properties_set:
 590  * @props: a #GtkStyleProperties
 591  * @state: state to set the values for
 592  * @...: property name/value pairs, followed by %NULL
 593  *
 594  * Sets several style properties on @props.
 595  *
 596  * Since: 3.0
 597  **/
 598 void
 599 gtk_style_properties_set (GtkStyleProperties *props,
 600                           GtkStateFlags       state,
 601                           ...)
 602 {
 603   va_list args;
 604
 605   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 606
 607   va_start (args, state);
 608   gtk_style_properties_set_valist (props, state, args);
 609   va_end (args);
 610 }
 611
 612 const GValue *
 613 _gtk_style_properties_peek_property (GtkStyleProperties  *props,
 614                                      GtkCssStyleProperty *property,
 615                                      GtkStateFlags        state)
 616 {
 617   GtkStylePropertiesPrivate *priv;
 618   PropertyData *prop;
 619
 620   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
 621   g_return_val_if_fail (property != NULL, FALSE);
 622
 623   priv = props->priv;
 624   prop = g_hash_table_lookup (priv->properties, property);
 625   if (prop == NULL)
 626     return NULL;
 627
 628   return property_data_match_state (prop, state);
 629 }
 630
 631 gboolean
 632 _gtk_style_properties_get_property (GtkStyleProperties *props,
 633                                     const gchar        *property,
 634                                     GtkStateFlags       state,
 635                                     GtkStylePropertyContext *context,
 636                                     GValue             *value)
 637 {
 638   GtkStyleProperty *node;
 639
 640   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
 641   g_return_val_if_fail (property != NULL, FALSE);
 642   g_return_val_if_fail (value != NULL, FALSE);
 643
 644   node = _gtk_style_property_lookup (property);
 645   if (!node)
 646     {
 647       g_warning ("Style property \"%s\" is not registered", property);
 648       return FALSE;
 649     }
 650   if (_gtk_style_property_get_value_type (node) == G_TYPE_NONE)
 651     {
 652       g_warning ("Style property \"%s\" is not gettable", property);
 653       return FALSE;
 654     }
 655
 656   _gtk_style_property_query (node, props, state, context, value);
 657   return TRUE;
 658 }
 659
 660 /**
 661  * gtk_style_properties_get_property:
 662  * @props: a #GtkStyleProperties
 663  * @property: style property name
 664  * @state: state to retrieve the property value for
 665  * @value: (out) (transfer full):  return location for the style property value.
 666  *
 667  * Gets a style property from @props for the given state. When done with @value,
 668  * g_value_unset() needs to be called to free any allocated memory.
 669  *
 670  * Returns: %TRUE if the property exists in @props, %FALSE otherwise
 671  *
 672  * Since: 3.0
 673  **/
 674 gboolean
 675 gtk_style_properties_get_property (GtkStyleProperties *props,
 676                                    const gchar        *property,
 677                                    GtkStateFlags       state,
 678                                    GValue             *value)
 679 {
 680   GtkStylePropertyContext context = { 100, 100};
 681
 682   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
 683   g_return_val_if_fail (property != NULL, FALSE);
 684   g_return_val_if_fail (value != NULL, FALSE);
 685
 686   return _gtk_style_properties_get_property (props,
 687                                              property,
 688                                              state, &context, value);
 689 }
 690
 691 void
 692 _gtk_style_properties_get_valist (GtkStyleProperties *props,
 693                                   GtkStateFlags       state,
 694                                   GtkStylePropertyContext *context,
 695                                   va_list             args)
 696 {
 697   const gchar *property_name;
 698
 699   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 700
 701   property_name = va_arg (args, const gchar *);
 702
 703   while (property_name)
 704     {
 705       gchar *error = NULL;
 706       GValue value = G_VALUE_INIT;
 707
 708       if (!_gtk_style_properties_get_property (props,
 709                                                property_name,
 710                                                state,
 711                                                context,
 712                                                &value))
 713         break;
 714
 715       G_VALUE_LCOPY (&value, args, 0, &error);
 716       g_value_unset (&value);
 717
 718       if (error)
 719         {
 720           g_warning ("Could not get style property \"%s\": %s", property_name, error);
 721           g_free (error);
 722           break;
 723         }
 724
 725       property_name = va_arg (args, const gchar *);
 726     }
 727 }
 728
 729 /**
 730  * gtk_style_properties_get_valist:
 731  * @props: a #GtkStyleProperties
 732  * @state: state to retrieve the property values for
 733  * @args: va_list of property name/return location pairs, followed by %NULL
 734  *
 735  * Retrieves several style property values from @props for a given state.
 736  *
 737  * Since: 3.0
 738  **/
 739 void
 740 gtk_style_properties_get_valist (GtkStyleProperties *props,
 741                                  GtkStateFlags       state,
 742                                  va_list             args)
 743 {
 744   GtkStylePropertyContext context = { 100, 100};
 745
 746   return _gtk_style_properties_get_valist (props, state, &context, args);
 747 }
 748
 749 void
 750 _gtk_style_properties_get (GtkStyleProperties *props,
 751                            GtkStateFlags       state,
 752                            GtkStylePropertyContext *context,
 753                            ...)
 754 {
 755   va_list args;
 756
 757   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 758
 759   va_start (args, context);
 760   _gtk_style_properties_get_valist (props, state, context, args);
 761   va_end (args);
 762 }
 763
 764 /**
 765  * gtk_style_properties_get:
 766  * @props: a #GtkStyleProperties
 767  * @state: state to retrieve the property values for
 768  * @...: property name /return value pairs, followed by %NULL
 769  *
 770  * Retrieves several style property values from @props for a
 771  * given state.
 772  *
 773  * Since: 3.0
 774  **/
 775 void
 776 gtk_style_properties_get (GtkStyleProperties *props,
 777                           GtkStateFlags       state,
 778                           ...)
 779 {
 780   va_list args;
 781
 782   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 783
 784   va_start (args, state);
 785   gtk_style_properties_get_valist (props, state, args);
 786   va_end (args);
 787 }
 788
 789 /**
 790  * gtk_style_properties_unset_property:
 791  * @props: a #GtkStyleProperties
 792  * @property: property to unset
 793  * @state: state to unset
 794  *
 795  * Unsets a style property in @props.
 796  *
 797  * Since: 3.0
 798  **/
 799 void
 800 gtk_style_properties_unset_property (GtkStyleProperties *props,
 801                                      const gchar        *property,
 802                                      GtkStateFlags       state)
 803 {
 804   GtkStylePropertiesPrivate *priv;
 805   GtkStyleProperty *node;
 806   PropertyData *prop;
 807   guint pos;
 808
 809   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 810   g_return_if_fail (property != NULL);
 811
 812   node = _gtk_style_property_lookup (property);
 813
 814   if (!node)
 815     {
 816       g_warning ("Style property \"%s\" is not registered", property);
 817       return;
 818     }
 819   if (_gtk_style_property_get_value_type (node) == G_TYPE_NONE)
 820     {
 821       g_warning ("Style property \"%s\" is not settable", property);
 822       return;
 823     }
 824
 825   if (GTK_IS_CSS_SHORTHAND_PROPERTY (node))
 826     {
 827       GtkCssShorthandProperty *shorthand = GTK_CSS_SHORTHAND_PROPERTY (node);
 828
 829       for (pos = 0; pos < _gtk_css_shorthand_property_get_n_subproperties (shorthand); pos++)
 830         {
 831           GtkCssStyleProperty *sub = _gtk_css_shorthand_property_get_subproperty (shorthand, pos);
 832           gtk_style_properties_unset_property (props,
 833                                                _gtk_style_property_get_name (GTK_STYLE_PROPERTY (sub)),
 834                                                state);
 835         }
 836       return;
 837     }
 838
 839   priv = props->priv;
 840   prop = g_hash_table_lookup (priv->properties, node);
 841
 842   if (!prop)
 843     return;
 844
 845   if (property_data_find_position (prop, state, &pos))
 846     {
 847       ValueData *data;
 848
 849       data = &g_array_index (prop->values, ValueData, pos);
 850
 851       if (G_IS_VALUE (&data->value))
 852         g_value_unset (&data->value);
 853
 854       g_array_remove_index (prop->values, pos);
 855     }
 856 }
 857
 858 /**
 859  * gtk_style_properties_clear:
 860  * @props: a #GtkStyleProperties
 861  *
 862  * Clears all style information from @props.
 863  **/
 864 void
 865 gtk_style_properties_clear (GtkStyleProperties *props)
 866 {
 867   GtkStylePropertiesPrivate *priv;
 868
 869   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 870
 871   priv = props->priv;
 872   g_hash_table_remove_all (priv->properties);
 873 }
 874
 875 /**
 876  * gtk_style_properties_merge:
 877  * @props: a #GtkStyleProperties
 878  * @props_to_merge: a second #GtkStyleProperties
 879  * @replace: whether to replace values or not
 880  *
 881  * Merges into @props all the style information contained
 882  * in @props_to_merge. If @replace is %TRUE, the values
 883  * will be overwritten, if it is %FALSE, the older values
 884  * will prevail.
 885  *
 886  * Since: 3.0
 887  **/
 888 void
 889 gtk_style_properties_merge (GtkStyleProperties       *props,
 890                             const GtkStyleProperties *props_to_merge,
 891                             gboolean                  replace)
 892 {
 893   GtkStylePropertiesPrivate *priv, *priv_to_merge;
 894   GHashTableIter iter;
 895   gpointer key, value;
 896
 897   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 898   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props_to_merge));
 899
 900   priv = props->priv;
 901   priv_to_merge = props_to_merge->priv;
 902
 903   /* Merge symbolic color map */
 904   if (priv_to_merge->color_map)
 905     {
 906       g_hash_table_iter_init (&iter, priv_to_merge->color_map);
 907
 908       while (g_hash_table_iter_next (&iter, &key, &value))
 909         {
 910           const gchar *name;
 911           GtkSymbolicColor *color;
 912
 913           name = key;
 914           color = value;
 915
 916           if (!replace &&
 917               g_hash_table_lookup (priv->color_map, name))
 918             continue;
 919
 920           gtk_style_properties_map_color (props, name, color);
 921         }
 922     }
 923
 924   /* Merge symbolic style properties */
 925   g_hash_table_iter_init (&iter, priv_to_merge->properties);
 926
 927   while (g_hash_table_iter_next (&iter, &key, &value))
 928     {
 929       PropertyData *prop_to_merge = value;
 930       PropertyData *prop;
 931       guint i;
 932
 933       prop = g_hash_table_lookup (priv->properties, key);
 934
 935       if (!prop)
 936         {
 937           prop = property_data_new ();
 938           g_hash_table_insert (priv->properties, key, prop);
 939         }
 940
 941       for (i = 0; i < prop_to_merge->values->len; i++)
 942         {
 943           ValueData *data;
 944           GValue *value;
 945
 946           data = &g_array_index (prop_to_merge->values, ValueData, i);
 947
 948           if (replace && data->state == GTK_STATE_FLAG_NORMAL &&
 949               G_VALUE_TYPE (&data->value) != PANGO_TYPE_FONT_DESCRIPTION)
 950             {
 951               /* Let normal state override all states
 952                * previously set in the original set
 953                */
 954               property_data_remove_values (prop);
 955             }
 956
 957           value = property_data_get_value (prop, data->state);
 958
 959           if (G_VALUE_TYPE (&data->value) == PANGO_TYPE_FONT_DESCRIPTION &&
 960               G_IS_VALUE (value))
 961             {
 962               PangoFontDescription *font_desc;
 963               PangoFontDescription *font_desc_to_merge;
 964
 965               /* Handle merging of font descriptions */
 966               font_desc = g_value_get_boxed (value);
 967               font_desc_to_merge = g_value_get_boxed (&data->value);
 968
 969               pango_font_description_merge (font_desc, font_desc_to_merge, replace);
 970             }
 971           else if (G_VALUE_TYPE (&data->value) == G_TYPE_PTR_ARRAY &&
 972                    G_IS_VALUE (value))
 973             {
 974               GPtrArray *array, *array_to_merge;
 975               gint i;
 976
 977               /* Append the array, mainly thought
 978                * for the gtk-key-bindings property
 979                */
 980               array = g_value_get_boxed (value);
 981               array_to_merge = g_value_get_boxed (&data->value);
 982
 983               for (i = 0; i < array_to_merge->len; i++)
 984                 g_ptr_array_add (array, g_ptr_array_index (array_to_merge, i));
 985             }
 986           else if (replace || !G_IS_VALUE (value))
 987             {
 988               if (!G_IS_VALUE (value))
 989                 g_value_init (value, G_VALUE_TYPE (&data->value));
 990               else if (G_VALUE_TYPE (value) != G_VALUE_TYPE (&data->value))
 991                 {
 992                   g_value_unset (value);
 993                   g_value_init (value, G_VALUE_TYPE (&data->value));
 994                 }
 995
 996               g_value_copy (&data->value, value);
 997             }
 998         }
 999     }
1000 }