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       GtkStyleProperty *prop = key;
 331       PropertyData *data = value;
 332       const GValue *value;
 333       guint id;
 334
 335       id = _gtk_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, 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 /* Property registration functions */
 356
 357 /**
 358  * gtk_style_properties_register_property: (skip)
 359  * @parse_func: parsing function to use, or %NULL
 360  * @pspec: the #GParamSpec for the new property
 361  *
 362  * Registers a property so it can be used in the CSS file format.
 363  * This function is the low-level equivalent of
 364  * gtk_theming_engine_register_property(), if you are implementing
 365  * a theming engine, you want to use that function instead.
 366  *
 367  * Since: 3.0
 368  **/
 369 void
 370 gtk_style_properties_register_property (GtkStylePropertyParser  parse_func,
 371                                         GParamSpec             *pspec)
 372 {
 373   g_return_if_fail (G_IS_PARAM_SPEC (pspec));
 374
 375   _gtk_style_property_register (pspec,
 376                                 0,
 377                                 parse_func,
 378                                 NULL,
 379                                 NULL,
 380                                 NULL);
 381 }
 382
 383 /**
 384  * gtk_style_properties_lookup_property: (skip)
 385  * @property_name: property name to look up
 386  * @parse_func: (out): return location for the parse function
 387  * @pspec: (out) (transfer none): return location for the #GParamSpec
 388  *
 389  * Returns %TRUE if a property has been registered, if @pspec or
 390  * @parse_func are not %NULL, the #GParamSpec and parsing function
 391  * will be respectively returned.
 392  *
 393  * Returns: %TRUE if the property is registered, %FALSE otherwise
 394  *
 395  * Since: 3.0
 396  **/
 397 gboolean
 398 gtk_style_properties_lookup_property (const gchar             *property_name,
 399                                       GtkStylePropertyParser  *parse_func,
 400                                       GParamSpec             **pspec)
 401 {
 402   GtkStyleProperty *node;
 403   gboolean found = FALSE;
 404
 405   g_return_val_if_fail (property_name != NULL, FALSE);
 406
 407   node = _gtk_style_property_lookup (property_name);
 408
 409   if (node)
 410     {
 411       if (pspec)
 412         *pspec = node->pspec;
 413
 414       if (parse_func)
 415         *parse_func = node->property_parse_func;
 416
 417       found = TRUE;
 418     }
 419
 420   return found;
 421 }
 422
 423 /* GtkStyleProperties methods */
 424
 425 /**
 426  * gtk_style_properties_new:
 427  *
 428  * Returns a newly created #GtkStyleProperties
 429  *
 430  * Returns: a new #GtkStyleProperties
 431  **/
 432 GtkStyleProperties *
 433 gtk_style_properties_new (void)
 434 {
 435   return g_object_new (GTK_TYPE_STYLE_PROPERTIES, NULL);
 436 }
 437
 438 void
 439 _gtk_style_properties_set_color_lookup_func (GtkStyleProperties         *props,
 440                                              GtkSymbolicColorLookupFunc  func,
 441                                              gpointer                    data)
 442 {
 443   GtkStylePropertiesPrivate *priv;
 444
 445   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 446   g_return_if_fail (func != NULL);
 447
 448   priv = props->priv;
 449   g_return_if_fail (priv->color_map == NULL);
 450
 451   priv->color_lookup_func = func;
 452   priv->color_lookup_data = data;
 453 }
 454
 455 /**
 456  * gtk_style_properties_map_color:
 457  * @props: a #GtkStyleProperties
 458  * @name: color name
 459  * @color: #GtkSymbolicColor to map @name to
 460  *
 461  * Maps @color so it can be referenced by @name. See
 462  * gtk_style_properties_lookup_color()
 463  *
 464  * Since: 3.0
 465  **/
 466 void
 467 gtk_style_properties_map_color (GtkStyleProperties *props,
 468                                 const gchar        *name,
 469                                 GtkSymbolicColor   *color)
 470 {
 471   GtkStylePropertiesPrivate *priv;
 472
 473   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 474   g_return_if_fail (name != NULL);
 475   g_return_if_fail (color != NULL);
 476
 477   priv = props->priv;
 478   g_return_if_fail (priv->color_lookup_func == NULL);
 479
 480   if (G_UNLIKELY (!priv->color_map))
 481     priv->color_map = g_hash_table_new_full (g_str_hash,
 482                                              g_str_equal,
 483                                              (GDestroyNotify) g_free,
 484                                              (GDestroyNotify) gtk_symbolic_color_unref);
 485
 486   g_hash_table_replace (priv->color_map,
 487                         g_strdup (name),
 488                         gtk_symbolic_color_ref (color));
 489 }
 490
 491 /**
 492  * gtk_style_properties_lookup_color:
 493  * @props: a #GtkStyleProperties
 494  * @name: color name to lookup
 495  *
 496  * Returns the symbolic color that is mapped
 497  * to @name.
 498  *
 499  * Returns: (transfer none): The mapped color
 500  *
 501  * Since: 3.0
 502  **/
 503 GtkSymbolicColor *
 504 gtk_style_properties_lookup_color (GtkStyleProperties *props,
 505                                    const gchar        *name)
 506 {
 507   GtkStylePropertiesPrivate *priv;
 508
 509   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), NULL);
 510   g_return_val_if_fail (name != NULL, NULL);
 511
 512   priv = props->priv;
 513
 514   if (priv->color_lookup_func)
 515     return priv->color_lookup_func (priv->color_lookup_data, name);
 516
 517   if (!priv->color_map)
 518     return NULL;
 519
 520   return g_hash_table_lookup (priv->color_map, name);
 521 }
 522
 523 void
 524 _gtk_style_properties_set_property_by_property (GtkStyleProperties *props,
 525                                                 GtkStyleProperty   *style_prop,
 526                                                 GtkStateFlags       state,
 527                                                 const GValue       *value)
 528 {
 529   GtkStylePropertiesPrivate *priv;
 530   PropertyData *prop;
 531   GValue *val;
 532
 533   priv = props->priv;
 534   prop = g_hash_table_lookup (priv->properties, style_prop);
 535
 536   if (!prop)
 537     {
 538       prop = property_data_new ();
 539       g_hash_table_insert (priv->properties, (gpointer) style_prop, prop);
 540     }
 541
 542   val = property_data_get_value (prop, state);
 543
 544   if (G_VALUE_TYPE (val) == G_VALUE_TYPE (value))
 545     g_value_reset (val);
 546   else
 547     {
 548       if (G_IS_VALUE (val))
 549         g_value_unset (val);
 550
 551       g_value_init (val, G_VALUE_TYPE (value));
 552     }
 553
 554   g_value_copy (value, val);
 555   if (_gtk_style_property_get_value_type (style_prop) == G_VALUE_TYPE (value))
 556     g_param_value_validate (style_prop->pspec, val);
 557 }
 558
 559 /**
 560  * gtk_style_properties_set_property:
 561  * @props: a #GtkStyleProperties
 562  * @property: styling property to set
 563  * @state: state to set the value for
 564  * @value: new value for the property
 565  *
 566  * Sets a styling property in @props.
 567  *
 568  * Since: 3.0
 569  **/
 570 void
 571 gtk_style_properties_set_property (GtkStyleProperties *props,
 572                                    const gchar        *property,
 573                                    GtkStateFlags       state,
 574                                    const GValue       *value)
 575 {
 576   GtkStyleProperty *node;
 577
 578   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 579   g_return_if_fail (property != NULL);
 580   g_return_if_fail (value != NULL);
 581
 582   node = _gtk_style_property_lookup (property);
 583
 584   if (!node)
 585     {
 586       g_warning ("Style property \"%s\" is not registered", property);
 587       return;
 588     }
 589   if (_gtk_style_property_get_value_type (node) == G_TYPE_NONE)
 590     {
 591       g_warning ("Style property \"%s\" is not settable", property);
 592       return;
 593     }
 594
 595   _gtk_style_property_assign (node, props, state, value);
 596 }
 597
 598 /**
 599  * gtk_style_properties_set_valist:
 600  * @props: a #GtkStyleProperties
 601  * @state: state to set the values for
 602  * @args: va_list of property name/value pairs, followed by %NULL
 603  *
 604  * Sets several style properties on @props.
 605  *
 606  * Since: 3.0
 607  **/
 608 void
 609 gtk_style_properties_set_valist (GtkStyleProperties *props,
 610                                  GtkStateFlags       state,
 611                                  va_list             args)
 612 {
 613   const gchar *property_name;
 614
 615   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 616
 617   property_name = va_arg (args, const gchar *);
 618
 619   while (property_name)
 620     {
 621       GtkStyleProperty *node;
 622       gchar *error = NULL;
 623       GType val_type;
 624       GValue val = G_VALUE_INIT;
 625
 626       node = _gtk_style_property_lookup (property_name);
 627
 628       if (!node)
 629         {
 630           g_warning ("Style property \"%s\" is not registered", property_name);
 631           break;
 632         }
 633
 634       val_type = _gtk_style_property_get_value_type (node);
 635       if (val_type == G_TYPE_NONE)
 636         {
 637           g_warning ("Style property \"%s\" is not settable", property_name);
 638           break;
 639         }
 640
 641       G_VALUE_COLLECT_INIT (&val, _gtk_style_property_get_value_type (node),
 642                             args, 0, &error);
 643       if (error)
 644         {
 645           g_warning ("Could not set style property \"%s\": %s", property_name, error);
 646           g_value_unset (&val);
 647           g_free (error);
 648           break;
 649         }
 650
 651       _gtk_style_property_assign (node, props, state, &val);
 652       g_value_unset (&val);
 653
 654       property_name = va_arg (args, const gchar *);
 655     }
 656 }
 657
 658 /**
 659  * gtk_style_properties_set:
 660  * @props: a #GtkStyleProperties
 661  * @state: state to set the values for
 662  * @...: property name/value pairs, followed by %NULL
 663  *
 664  * Sets several style properties on @props.
 665  *
 666  * Since: 3.0
 667  **/
 668 void
 669 gtk_style_properties_set (GtkStyleProperties *props,
 670                           GtkStateFlags       state,
 671                           ...)
 672 {
 673   va_list args;
 674
 675   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 676
 677   va_start (args, state);
 678   gtk_style_properties_set_valist (props, state, args);
 679   va_end (args);
 680 }
 681
 682 const GValue *
 683 _gtk_style_properties_peek_property (GtkStyleProperties *props,
 684                                      GtkStyleProperty   *property,
 685                                      GtkStateFlags       state)
 686 {
 687   GtkStylePropertiesPrivate *priv;
 688   PropertyData *prop;
 689
 690   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
 691   g_return_val_if_fail (property != NULL, FALSE);
 692
 693   priv = props->priv;
 694   prop = g_hash_table_lookup (priv->properties, property);
 695   if (prop == NULL)
 696     return NULL;
 697
 698   return property_data_match_state (prop, state);
 699 }
 700
 701 gboolean
 702 _gtk_style_properties_get_property (GtkStyleProperties *props,
 703                                     const gchar        *property,
 704                                     GtkStateFlags       state,
 705                                     GtkStylePropertyContext *context,
 706                                     GValue             *value)
 707 {
 708   GtkStyleProperty *node;
 709
 710   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
 711   g_return_val_if_fail (property != NULL, FALSE);
 712   g_return_val_if_fail (value != NULL, FALSE);
 713
 714   node = _gtk_style_property_lookup (property);
 715   if (!node)
 716     {
 717       g_warning ("Style property \"%s\" is not registered", property);
 718       return FALSE;
 719     }
 720   if (_gtk_style_property_get_value_type (node) == G_TYPE_NONE)
 721     {
 722       g_warning ("Style property \"%s\" is not gettable", property);
 723       return FALSE;
 724     }
 725
 726   _gtk_style_property_query (node, props, state, context, value);
 727   return TRUE;
 728 }
 729
 730 /**
 731  * gtk_style_properties_get_property:
 732  * @props: a #GtkStyleProperties
 733  * @property: style property name
 734  * @state: state to retrieve the property value for
 735  * @value: (out) (transfer full):  return location for the style property value.
 736  *
 737  * Gets a style property from @props for the given state. When done with @value,
 738  * g_value_unset() needs to be called to free any allocated memory.
 739  *
 740  * Returns: %TRUE if the property exists in @props, %FALSE otherwise
 741  *
 742  * Since: 3.0
 743  **/
 744 gboolean
 745 gtk_style_properties_get_property (GtkStyleProperties *props,
 746                                    const gchar        *property,
 747                                    GtkStateFlags       state,
 748                                    GValue             *value)
 749 {
 750   GtkStylePropertyContext context = { 100, 100};
 751
 752   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
 753   g_return_val_if_fail (property != NULL, FALSE);
 754   g_return_val_if_fail (value != NULL, FALSE);
 755
 756   return _gtk_style_properties_get_property (props,
 757                                              property,
 758                                              state, &context, value);
 759 }
 760
 761 void
 762 _gtk_style_properties_get_valist (GtkStyleProperties *props,
 763                                   GtkStateFlags       state,
 764                                   GtkStylePropertyContext *context,
 765                                   va_list             args)
 766 {
 767   const gchar *property_name;
 768
 769   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 770
 771   property_name = va_arg (args, const gchar *);
 772
 773   while (property_name)
 774     {
 775       gchar *error = NULL;
 776       GValue value = G_VALUE_INIT;
 777
 778       if (!_gtk_style_properties_get_property (props,
 779                                                property_name,
 780                                                state,
 781                                                context,
 782                                                &value))
 783         break;
 784
 785       G_VALUE_LCOPY (&value, args, 0, &error);
 786       g_value_unset (&value);
 787
 788       if (error)
 789         {
 790           g_warning ("Could not get style property \"%s\": %s", property_name, error);
 791           g_free (error);
 792           break;
 793         }
 794
 795       property_name = va_arg (args, const gchar *);
 796     }
 797 }
 798
 799 /**
 800  * gtk_style_properties_get_valist:
 801  * @props: a #GtkStyleProperties
 802  * @state: state to retrieve the property values for
 803  * @args: va_list of property name/return location pairs, followed by %NULL
 804  *
 805  * Retrieves several style property values from @props for a given state.
 806  *
 807  * Since: 3.0
 808  **/
 809 void
 810 gtk_style_properties_get_valist (GtkStyleProperties *props,
 811                                  GtkStateFlags       state,
 812                                  va_list             args)
 813 {
 814   GtkStylePropertyContext context = { 100, 100};
 815
 816   return _gtk_style_properties_get_valist (props, state, &context, args);
 817 }
 818
 819 void
 820 _gtk_style_properties_get (GtkStyleProperties *props,
 821                            GtkStateFlags       state,
 822                            GtkStylePropertyContext *context,
 823                            ...)
 824 {
 825   va_list args;
 826
 827   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 828
 829   va_start (args, context);
 830   _gtk_style_properties_get_valist (props, state, context, args);
 831   va_end (args);
 832 }
 833
 834 /**
 835  * gtk_style_properties_get:
 836  * @props: a #GtkStyleProperties
 837  * @state: state to retrieve the property values for
 838  * @...: property name /return value pairs, followed by %NULL
 839  *
 840  * Retrieves several style property values from @props for a
 841  * given state.
 842  *
 843  * Since: 3.0
 844  **/
 845 void
 846 gtk_style_properties_get (GtkStyleProperties *props,
 847                           GtkStateFlags       state,
 848                           ...)
 849 {
 850   va_list args;
 851
 852   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 853
 854   va_start (args, state);
 855   gtk_style_properties_get_valist (props, state, args);
 856   va_end (args);
 857 }
 858
 859 /**
 860  * gtk_style_properties_unset_property:
 861  * @props: a #GtkStyleProperties
 862  * @property: property to unset
 863  * @state: state to unset
 864  *
 865  * Unsets a style property in @props.
 866  *
 867  * Since: 3.0
 868  **/
 869 void
 870 gtk_style_properties_unset_property (GtkStyleProperties *props,
 871                                      const gchar        *property,
 872                                      GtkStateFlags       state)
 873 {
 874   GtkStylePropertiesPrivate *priv;
 875   GtkStyleProperty *node;
 876   PropertyData *prop;
 877   guint pos;
 878
 879   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 880   g_return_if_fail (property != NULL);
 881
 882   node = _gtk_style_property_lookup (property);
 883
 884   if (!node)
 885     {
 886       g_warning ("Style property \"%s\" is not registered", property);
 887       return;
 888     }
 889
 890   if (node->unset_func)
 891     {
 892       node->unset_func (props, state);
 893       return;
 894     }
 895
 896   priv = props->priv;
 897   prop = g_hash_table_lookup (priv->properties, node);
 898
 899   if (!prop)
 900     return;
 901
 902   if (property_data_find_position (prop, state, &pos))
 903     {
 904       ValueData *data;
 905
 906       data = &g_array_index (prop->values, ValueData, pos);
 907
 908       if (G_IS_VALUE (&data->value))
 909         g_value_unset (&data->value);
 910
 911       g_array_remove_index (prop->values, pos);
 912     }
 913 }
 914
 915 /**
 916  * gtk_style_properties_clear:
 917  * @props: a #GtkStyleProperties
 918  *
 919  * Clears all style information from @props.
 920  **/
 921 void
 922 gtk_style_properties_clear (GtkStyleProperties *props)
 923 {
 924   GtkStylePropertiesPrivate *priv;
 925
 926   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 927
 928   priv = props->priv;
 929   g_hash_table_remove_all (priv->properties);
 930 }
 931
 932 /**
 933  * gtk_style_properties_merge:
 934  * @props: a #GtkStyleProperties
 935  * @props_to_merge: a second #GtkStyleProperties
 936  * @replace: whether to replace values or not
 937  *
 938  * Merges into @props all the style information contained
 939  * in @props_to_merge. If @replace is %TRUE, the values
 940  * will be overwritten, if it is %FALSE, the older values
 941  * will prevail.
 942  *
 943  * Since: 3.0
 944  **/
 945 void
 946 gtk_style_properties_merge (GtkStyleProperties       *props,
 947                             const GtkStyleProperties *props_to_merge,
 948                             gboolean                  replace)
 949 {
 950   GtkStylePropertiesPrivate *priv, *priv_to_merge;
 951   GHashTableIter iter;
 952   gpointer key, value;
 953
 954   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 955   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props_to_merge));
 956
 957   priv = props->priv;
 958   priv_to_merge = props_to_merge->priv;
 959
 960   /* Merge symbolic color map */
 961   if (priv_to_merge->color_map)
 962     {
 963       g_hash_table_iter_init (&iter, priv_to_merge->color_map);
 964
 965       while (g_hash_table_iter_next (&iter, &key, &value))
 966         {
 967           const gchar *name;
 968           GtkSymbolicColor *color;
 969
 970           name = key;
 971           color = value;
 972
 973           if (!replace &&
 974               g_hash_table_lookup (priv->color_map, name))
 975             continue;
 976
 977           gtk_style_properties_map_color (props, name, color);
 978         }
 979     }
 980
 981   /* Merge symbolic style properties */
 982   g_hash_table_iter_init (&iter, priv_to_merge->properties);
 983
 984   while (g_hash_table_iter_next (&iter, &key, &value))
 985     {
 986       PropertyData *prop_to_merge = value;
 987       PropertyData *prop;
 988       guint i;
 989
 990       prop = g_hash_table_lookup (priv->properties, key);
 991
 992       if (!prop)
 993         {
 994           prop = property_data_new ();
 995           g_hash_table_insert (priv->properties, key, prop);
 996         }
 997
 998       for (i = 0; i < prop_to_merge->values->len; i++)
 999         {
1000           ValueData *data;
1001           GValue *value;
1002
1003           data = &g_array_index (prop_to_merge->values, ValueData, i);
1004
1005           if (replace && data->state == GTK_STATE_FLAG_NORMAL &&
1006               G_VALUE_TYPE (&data->value) != PANGO_TYPE_FONT_DESCRIPTION)
1007             {
1008               /* Let normal state override all states
1009                * previously set in the original set
1010                */
1011               property_data_remove_values (prop);
1012             }
1013
1014           value = property_data_get_value (prop, data->state);
1015
1016           if (G_VALUE_TYPE (&data->value) == PANGO_TYPE_FONT_DESCRIPTION &&
1017               G_IS_VALUE (value))
1018             {
1019               PangoFontDescription *font_desc;
1020               PangoFontDescription *font_desc_to_merge;
1021
1022               /* Handle merging of font descriptions */
1023               font_desc = g_value_get_boxed (value);
1024               font_desc_to_merge = g_value_get_boxed (&data->value);
1025
1026               pango_font_description_merge (font_desc, font_desc_to_merge, replace);
1027             }
1028           else if (G_VALUE_TYPE (&data->value) == G_TYPE_PTR_ARRAY &&
1029                    G_IS_VALUE (value))
1030             {
1031               GPtrArray *array, *array_to_merge;
1032               gint i;
1033
1034               /* Append the array, mainly thought
1035                * for the gtk-key-bindings property
1036                */
1037               array = g_value_get_boxed (value);
1038               array_to_merge = g_value_get_boxed (&data->value);
1039
1040               for (i = 0; i < array_to_merge->len; i++)
1041                 g_ptr_array_add (array, g_ptr_array_index (array_to_merge, i));
1042             }
1043           else if (replace || !G_IS_VALUE (value))
1044             {
1045               if (!G_IS_VALUE (value))
1046                 g_value_init (value, G_VALUE_TYPE (&data->value));
1047               else if (G_VALUE_TYPE (value) != G_VALUE_TYPE (&data->value))
1048                 {
1049                   g_value_unset (value);
1050                   g_value_init (value, G_VALUE_TYPE (&data->value));
1051                 }
1052
1053               g_value_copy (&data->value, value);
1054             }
1055         }
1056     }
1057 }