Pileus Git - ~andy/gtk/blob - gtk/deprecated/gtksymboliccolor.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 #define GDK_DISABLE_DEPRECATION_WARNINGS
  21
  22 #include "gtkcsscolorvalueprivate.h"
  23 #include "gtkcssrgbavalueprivate.h"
  24 #include "gtkcssstylepropertyprivate.h"
  25 #include "gtkhslaprivate.h"
  26 #include "gtkstylepropertyprivate.h"
  27 #include "gtksymboliccolorprivate.h"
  28 #include "gtkstyleproperties.h"
  29 #include "gtkintl.h"
  30 #include "gtkwin32themeprivate.h"
  31
  32 /**
  33  * SECTION:gtksymboliccolor
  34  * @Short_description: Symbolic colors
  35  * @Title: GtkSymbolicColor
  36  *
  37  * GtkSymbolicColor is a boxed type that represents a symbolic color.
  38  * It is the result of parsing a
  39  * <link linkend="gtkcssprovider-symbolic-colors">color expression</link>.
  40  * To obtain the color represented by a GtkSymbolicColor, it has to
  41  * be resolved with gtk_symbolic_color_resolve(), which replaces all
  42  * symbolic color references by the colors they refer to (in a given
  43  * context) and evaluates mix, shade and other expressions, resulting
  44  * in a #GdkRGBA value.
  45  *
  46  * It is not normally necessary to deal directly with #GtkSymbolicColors,
  47  * since they are mostly used behind the scenes by #GtkStyleContext and
  48  * #GtkCssProvider.
  49  *
  50  * #GtkSymbolicColor is deprecated. Symbolic colors are considered an
  51  * implementation detail of GTK+.
  52  */
  53
  54 G_DEFINE_BOXED_TYPE (GtkSymbolicColor, gtk_symbolic_color,
  55                      gtk_symbolic_color_ref, gtk_symbolic_color_unref)
  56
  57 struct _GtkSymbolicColor
  58 {
  59   GtkCssValue *value;
  60   gint ref_count;
  61 };
  62
  63 static GtkSymbolicColor *
  64 gtk_symbolic_color_new (GtkCssValue *value)
  65 {
  66   GtkSymbolicColor *symbolic;
  67
  68   symbolic = g_slice_new0 (GtkSymbolicColor);
  69   symbolic->value = value;
  70   symbolic->ref_count = 1;
  71
  72   return symbolic;
  73 }
  74
  75 /**
  76  * gtk_symbolic_color_new_literal:
  77  * @color: a #GdkRGBA
  78  *
  79  * Creates a symbolic color pointing to a literal color.
  80  *
  81  * Returns: a newly created #GtkSymbolicColor
  82  *
  83  * Since: 3.0
  84  *
  85  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
  86  **/
  87 GtkSymbolicColor *
  88 gtk_symbolic_color_new_literal (const GdkRGBA *color)
  89 {
  90   g_return_val_if_fail (color != NULL, NULL);
  91
  92   return gtk_symbolic_color_new (_gtk_css_color_value_new_literal (color));
  93 }
  94
  95 /**
  96  * gtk_symbolic_color_new_name:
  97  * @name: color name
  98  *
  99  * Creates a symbolic color pointing to an unresolved named
 100  * color. See gtk_style_context_lookup_color() and
 101  * gtk_style_properties_lookup_color().
 102  *
 103  * Returns: a newly created #GtkSymbolicColor
 104  *
 105  * Since: 3.0
 106  *
 107  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 108  **/
 109 GtkSymbolicColor *
 110 gtk_symbolic_color_new_name (const gchar *name)
 111 {
 112   g_return_val_if_fail (name != NULL, NULL);
 113
 114   return gtk_symbolic_color_new (_gtk_css_color_value_new_name (name));
 115 }
 116
 117 /**
 118  * gtk_symbolic_color_new_shade: (constructor)
 119  * @color: another #GtkSymbolicColor
 120  * @factor: shading factor to apply to @color
 121  *
 122  * Creates a symbolic color defined as a shade of
 123  * another color. A factor > 1.0 would resolve to
 124  * a brighter color, while < 1.0 would resolve to
 125  * a darker color.
 126  *
 127  * Returns: A newly created #GtkSymbolicColor
 128  *
 129  * Since: 3.0
 130  *
 131  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 132  **/
 133 GtkSymbolicColor *
 134 gtk_symbolic_color_new_shade (GtkSymbolicColor *color,
 135                               gdouble           factor)
 136 {
 137   g_return_val_if_fail (color != NULL, NULL);
 138
 139   return gtk_symbolic_color_new (_gtk_css_color_value_new_shade (color->value,
 140                                                                  factor));
 141 }
 142
 143 /**
 144  * gtk_symbolic_color_new_alpha: (constructor)
 145  * @color: another #GtkSymbolicColor
 146  * @factor: factor to apply to @color alpha
 147  *
 148  * Creates a symbolic color by modifying the relative alpha
 149  * value of @color. A factor < 1.0 would resolve to a more
 150  * transparent color, while > 1.0 would resolve to a more
 151  * opaque color.
 152  *
 153  * Returns: A newly created #GtkSymbolicColor
 154  *
 155  * Since: 3.0
 156  *
 157  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 158  **/
 159 GtkSymbolicColor *
 160 gtk_symbolic_color_new_alpha (GtkSymbolicColor *color,
 161                               gdouble           factor)
 162 {
 163   g_return_val_if_fail (color != NULL, NULL);
 164
 165   return gtk_symbolic_color_new (_gtk_css_color_value_new_alpha (color->value,
 166                                                                  factor));
 167 }
 168
 169 /**
 170  * gtk_symbolic_color_new_mix: (constructor)
 171  * @color1: color to mix
 172  * @color2: another color to mix
 173  * @factor: mix factor
 174  *
 175  * Creates a symbolic color defined as a mix of another
 176  * two colors. a mix factor of 0 would resolve to @color1,
 177  * while a factor of 1 would resolve to @color2.
 178  *
 179  * Returns: A newly created #GtkSymbolicColor
 180  *
 181  * Since: 3.0
 182  *
 183  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 184  **/
 185 GtkSymbolicColor *
 186 gtk_symbolic_color_new_mix (GtkSymbolicColor *color1,
 187                             GtkSymbolicColor *color2,
 188                             gdouble           factor)
 189 {
 190   g_return_val_if_fail (color1 != NULL, NULL);
 191   g_return_val_if_fail (color1 != NULL, NULL);
 192
 193   return gtk_symbolic_color_new (_gtk_css_color_value_new_mix (color1->value,
 194                                                                color2->value,
 195                                                                factor));
 196 }
 197
 198 /**
 199  * gtk_symbolic_color_new_win32: (constructor)
 200  * @theme_class: The theme class to pull color from
 201  * @id: The color id
 202  *
 203  * Creates a symbolic color based on the current win32
 204  * theme.
 205  *
 206  * Note that while this call is available on all platforms
 207  * the actual value returned is not reliable on non-win32
 208  * platforms.
 209  *
 210  * Returns: A newly created #GtkSymbolicColor
 211  *
 212  * Since: 3.4
 213  *
 214  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 215  */
 216 GtkSymbolicColor *
 217 gtk_symbolic_color_new_win32 (const gchar *theme_class,
 218                               gint         id)
 219 {
 220   g_return_val_if_fail (theme_class != NULL, NULL);
 221
 222   return gtk_symbolic_color_new (_gtk_css_color_value_new_win32 (theme_class, id));
 223 }
 224
 225 /**
 226  * gtk_symbolic_color_ref:
 227  * @color: a #GtkSymbolicColor
 228  *
 229  * Increases the reference count of @color
 230  *
 231  * Returns: the same @color
 232  *
 233  * Since: 3.0
 234  *
 235  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 236  **/
 237 GtkSymbolicColor *
 238 gtk_symbolic_color_ref (GtkSymbolicColor *color)
 239 {
 240   g_return_val_if_fail (color != NULL, NULL);
 241
 242   color->ref_count++;
 243
 244   return color;
 245 }
 246
 247 /**
 248  * gtk_symbolic_color_unref:
 249  * @color: a #GtkSymbolicColor
 250  *
 251  * Decreases the reference count of @color, freeing its memory if the
 252  * reference count reaches 0.
 253  *
 254  * Since: 3.0
 255  *
 256  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 257  **/
 258 void
 259 gtk_symbolic_color_unref (GtkSymbolicColor *color)
 260 {
 261   g_return_if_fail (color != NULL);
 262
 263   if (--color->ref_count)
 264     return;
 265
 266   _gtk_css_value_unref (color->value);
 267
 268   g_slice_free (GtkSymbolicColor, color);
 269 }
 270
 271 /**
 272  * gtk_symbolic_color_resolve:
 273  * @color: a #GtkSymbolicColor
 274  * @props: (allow-none): #GtkStyleProperties to use when resolving
 275  *    named colors, or %NULL
 276  * @resolved_color: (out): return location for the resolved color
 277  *
 278  * If @color is resolvable, @resolved_color will be filled in
 279  * with the resolved color, and %TRUE will be returned. Generally,
 280  * if @color can't be resolved, it is due to it being defined on
 281  * top of a named color that doesn't exist in @props.
 282  *
 283  * When @props is %NULL, resolving of named colors will fail, so if
 284  * your @color is or references such a color, this function will
 285  * return %FALSE.
 286  *
 287  * Returns: %TRUE if the color has been resolved
 288  *
 289  * Since: 3.0
 290  *
 291  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 292  **/
 293 gboolean
 294 gtk_symbolic_color_resolve (GtkSymbolicColor   *color,
 295                             GtkStyleProperties *props,
 296                             GdkRGBA            *resolved_color)
 297 {
 298   GdkRGBA pink = { 1.0, 0.5, 0.5, 1.0 };
 299   GtkCssValue *v, *current;
 300
 301   g_return_val_if_fail (color != NULL, FALSE);
 302   g_return_val_if_fail (resolved_color != NULL, FALSE);
 303   g_return_val_if_fail (props == NULL || GTK_IS_STYLE_PROPERTIES (props), FALSE);
 304
 305   current = _gtk_css_rgba_value_new_from_rgba (&pink);
 306   v = _gtk_css_color_value_resolve (color->value,
 307                                     GTK_STYLE_PROVIDER_PRIVATE (props),
 308                                     current,
 309                                     0,
 310                                     NULL);
 311   _gtk_css_value_unref (current);
 312   if (v == NULL)
 313     return FALSE;
 314
 315   *resolved_color = *_gtk_css_rgba_value_get_rgba (v);
 316   _gtk_css_value_unref (v);
 317   return TRUE;
 318 }
 319
 320 /**
 321  * gtk_symbolic_color_to_string:
 322  * @color: color to convert to a string
 323  *
 324  * Converts the given @color to a string representation. This is useful
 325  * both for debugging and for serialization of strings. The format of
 326  * the string may change between different versions of GTK, but it is
 327  * guaranteed that the GTK css parser is able to read the string and
 328  * create the same symbolic color from it.
 329  *
 330  * Returns: a new string representing @color
 331  *
 332  * Deprecated: 3.8: #GtkSymbolicColor is deprecated.
 333  **/
 334 char *
 335 gtk_symbolic_color_to_string (GtkSymbolicColor *color)
 336 {
 337   g_return_val_if_fail (color != NULL, NULL);
 338
 339   return _gtk_css_value_to_string (color->value);
 340 }
 341
 342 GtkSymbolicColor *
 343 _gtk_css_symbolic_value_new (GtkCssParser *parser)
 344 {
 345   GtkCssValue *value;
 346
 347   value = _gtk_css_color_value_parse (parser);
 348   if (value == NULL)
 349     return NULL;
 350
 351   return gtk_symbolic_color_new (value);
 352 }
 353
 354 GtkCssValue *
 355 _gtk_symbolic_color_get_css_value (GtkSymbolicColor *symbolic)
 356 {
 357   return symbolic->value;
 358 }
 359