Pileus Git - ~andy/gtk/blob - gtk/gtkstyleproperty.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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include "gtkstylepropertyprivate.h"
  21
  22 #include "gtkcssprovider.h"
  23 #include "gtkcssparserprivate.h"
  24 #include "gtkcssshorthandpropertyprivate.h"
  25 #include "gtkcssstylefuncsprivate.h"
  26 #include "gtkcssstylepropertyprivate.h"
  27 #include "gtkcsstypesprivate.h"
  28 #include "gtkintl.h"
  29 #include "gtkprivatetypebuiltins.h"
  30 #include "gtkstylepropertiesprivate.h"
  31
  32 enum {
  33   PROP_0,
  34   PROP_NAME,
  35   PROP_VALUE_TYPE
  36 };
  37
  38 G_DEFINE_ABSTRACT_TYPE (GtkStyleProperty, _gtk_style_property, G_TYPE_OBJECT)
  39
  40 static void
  41 gtk_style_property_finalize (GObject *object)
  42 {
  43   GtkStyleProperty *property = GTK_STYLE_PROPERTY (object);
  44
  45   g_warning ("finalizing %s `%s', how could this happen?", G_OBJECT_TYPE_NAME (object), property->name);
  46
  47   G_OBJECT_CLASS (_gtk_style_property_parent_class)->finalize (object);
  48 }
  49
  50 static void
  51 gtk_style_property_set_property (GObject      *object,
  52                                  guint         prop_id,
  53                                  const GValue *value,
  54                                  GParamSpec   *pspec)
  55 {
  56   GtkStyleProperty *property = GTK_STYLE_PROPERTY (object);
  57   GtkStylePropertyClass *klass = GTK_STYLE_PROPERTY_GET_CLASS (property);
  58
  59   switch (prop_id)
  60     {
  61     case PROP_NAME:
  62       property->name = g_value_dup_string (value);
  63       g_assert (property->name);
  64       g_assert (g_hash_table_lookup (klass->properties, property->name) == NULL);
  65       g_hash_table_insert (klass->properties, property->name, property);
  66       break;
  67     case PROP_VALUE_TYPE:
  68       property->value_type = g_value_get_gtype (value);
  69       break;
  70     default:
  71       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  72       break;
  73     }
  74 }
  75
  76 static void
  77 gtk_style_property_get_property (GObject    *object,
  78                                  guint       prop_id,
  79                                  GValue     *value,
  80                                  GParamSpec *pspec)
  81 {
  82   GtkStyleProperty *property = GTK_STYLE_PROPERTY (object);
  83
  84   switch (prop_id)
  85     {
  86     case PROP_NAME:
  87       g_value_set_string (value, property->name);
  88       break;
  89     case PROP_VALUE_TYPE:
  90       g_value_set_gtype (value, property->value_type);
  91       break;
  92     default:
  93       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  94       break;
  95     }
  96 }
  97
  98 static void
  99 _gtk_style_property_class_init (GtkStylePropertyClass *klass)
 100 {
 101   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 102
 103   object_class->finalize = gtk_style_property_finalize;
 104   object_class->set_property = gtk_style_property_set_property;
 105   object_class->get_property = gtk_style_property_get_property;
 106
 107   g_object_class_install_property (object_class,
 108                                    PROP_NAME,
 109                                    g_param_spec_string ("name",
 110                                                         P_("Property name"),
 111                                                         P_("The name of the property"),
 112                                                         NULL,
 113                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 114   g_object_class_install_property (object_class,
 115                                    PROP_VALUE_TYPE,
 116                                    g_param_spec_gtype ("value-type",
 117                                                        P_("Value type"),
 118                                                        P_("The value type returned by GtkStyleContext"),
 119                                                        G_TYPE_NONE,
 120                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 121
 122   klass->properties = g_hash_table_new (g_str_hash, g_str_equal);
 123 }
 124
 125 static void
 126 _gtk_style_property_init (GtkStyleProperty *property)
 127 {
 128   property->value_type = G_TYPE_NONE;
 129 }
 130
 131 /**
 132  * _gtk_style_property_parse_value:
 133  * @property: the property
 134  * @parser: the parser to parse from
 135  *
 136  * Tries to parse the given @property from the given @parser into
 137  * @value. The type that @value will be assigned is dependant on
 138  * the parser and no assumptions must be made about it. If the
 139  * parsing fails, %FALSE will be returned and @value will be
 140  * left uninitialized.
 141  *
 142  * Only if @property is a #GtkCssShorthandProperty, the @value will
 143  * always be a #GtkCssValue whose values can be queried with
 144  * _gtk_css_array_value_get_nth().
 145  *
 146  * Returns: %NULL on failure or the parsed #GtkCssValue
 147  **/
 148 GtkCssValue *
 149 _gtk_style_property_parse_value (GtkStyleProperty *property,
 150                                  GtkCssParser     *parser)
 151 {
 152   GtkStylePropertyClass *klass;
 153
 154   g_return_val_if_fail (GTK_IS_STYLE_PROPERTY (property), NULL);
 155   g_return_val_if_fail (parser != NULL, NULL);
 156
 157   klass = GTK_STYLE_PROPERTY_GET_CLASS (property);
 158
 159   return klass->parse_value (property, parser);
 160 }
 161
 162 /**
 163  * _gtk_style_property_assign:
 164  * @property: the property
 165  * @props: The properties to assign to
 166  * @state: The state to assign
 167  * @value: (out): the #GValue with the value to be
 168  *     assigned
 169  *
 170  * This function is called by gtk_style_properties_set() and in
 171  * turn gtk_style_context_set() and similar functions to set the
 172  * value from code using old APIs.
 173  **/
 174 void
 175 _gtk_style_property_assign (GtkStyleProperty   *property,
 176                             GtkStyleProperties *props,
 177                             GtkStateFlags       state,
 178                             const GValue       *value)
 179 {
 180   GtkStylePropertyClass *klass;
 181
 182   g_return_if_fail (GTK_IS_STYLE_PROPERTY (property));
 183   g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
 184   g_return_if_fail (value != NULL);
 185
 186   klass = GTK_STYLE_PROPERTY_GET_CLASS (property);
 187
 188   klass->assign (property, props, state, value);
 189 }
 190
 191 /**
 192  * _gtk_style_property_query:
 193  * @property: the property
 194  * @value: (out): an uninitialized #GValue to be filled with the
 195  *   contents of the lookup
 196  * @query_func: The function to use to query properties
 197  * @query_data: The data to pass to @query_func
 198  *
 199  * This function is called by gtk_style_properties_get() and in
 200  * turn gtk_style_context_get() and similar functions to get the
 201  * value to return to code using old APIs.
 202  **/
 203 void
 204 _gtk_style_property_query (GtkStyleProperty  *property,
 205                            GValue            *value,
 206                            GtkStyleQueryFunc  query_func,
 207                            gpointer           query_data)
 208 {
 209   GtkStylePropertyClass *klass;
 210
 211   g_return_if_fail (value != NULL);
 212   g_return_if_fail (GTK_IS_STYLE_PROPERTY (property));
 213   g_return_if_fail (query_func != NULL);
 214
 215   klass = GTK_STYLE_PROPERTY_GET_CLASS (property);
 216
 217   return klass->query (property, value, query_func, query_data);
 218 }
 219
 220 void
 221 _gtk_style_property_init_properties (void)
 222 {
 223   static gboolean initialized = FALSE;
 224
 225   if (G_LIKELY (initialized))
 226     return;
 227
 228   initialized = TRUE;
 229
 230   _gtk_css_style_property_init_properties ();
 231   /* initialize shorthands last, they depend on the real properties existing */
 232   _gtk_css_shorthand_property_init_properties ();
 233 }
 234
 235 /**
 236  * _gtk_style_property_lookup:
 237  * @name: name of the property to lookup
 238  *
 239  * Looks up the CSS property with the given @name. If no such
 240  * property exists, %NULL is returned.
 241  *
 242  * Returns: (transfer none): The property or %NULL if no
 243  *     property with the given name exists.
 244  **/
 245 GtkStyleProperty *
 246 _gtk_style_property_lookup (const char *name)
 247 {
 248   GtkStylePropertyClass *klass;
 249
 250   g_return_val_if_fail (name != NULL, NULL);
 251
 252   _gtk_style_property_init_properties ();
 253
 254   klass = g_type_class_peek (GTK_TYPE_STYLE_PROPERTY);
 255
 256   return g_hash_table_lookup (klass->properties, name);
 257 }
 258
 259 /**
 260  * _gtk_style_property_get_name:
 261  * @property: the property to query
 262  *
 263  * Gets the name of the given property.
 264  *
 265  * Returns: the name of the property
 266  **/
 267 const char *
 268 _gtk_style_property_get_name (GtkStyleProperty *property)
 269 {
 270   g_return_val_if_fail (GTK_IS_STYLE_PROPERTY (property), NULL);
 271
 272   return property->name;
 273 }
 274
 275 /**
 276  * _gtk_style_property_get_value_type:
 277  * @property: the property to query
 278  *
 279  * Gets the value type of the @property, if the property is usable
 280  * in public API via _gtk_style_property_assign() and
 281  * _gtk_style_property_query(). If the @property is not usable in that
 282  * way, %G_TYPE_NONE is returned.
 283  *
 284  * Returns: the value type in use or %G_TYPE_NONE if none.
 285  **/
 286 GType
 287 _gtk_style_property_get_value_type (GtkStyleProperty *property)
 288 {
 289   g_return_val_if_fail (GTK_IS_STYLE_PROPERTY (property), G_TYPE_NONE);
 290
 291   return property->value_type;
 292 }