AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
8d77fcb2d5
gtk2/gtk/gtkstyleproperty.c

2068 lines
64 KiB
C
Raw Normal View History

css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
/* GTK - The GIMP Toolkit
* Copyright (C) 2010 Carlos Garnacho <carlosg@gnome.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
css: Rename gtkcssstrfuncs file to gtkstyleproperty The idea is to handle the style property registering etc in this file instead of the styleproperties file. The next commits will move those files.
2011-05-21 01:30:36 +00:00
#include "gtkstylepropertyprivate.h"
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <cairo-gobject.h>
#include "gtkcssprovider.h"
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
#include "gtkcssparserprivate.h"
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
#include "gtkcsstypesprivate.h"
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
/* the actual parsers we have */
#include "gtkanimationdescription.h"
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
#include "gtkbindings.h"
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
#include "gtk9slice.h"
#include "gtkgradient.h"
css: add a parser for GTK_TYPE_SHADOW properties https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:48:22 +00:00
#include "gtkshadowprivate.h"
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
#include "gtkthemingengine.h"
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
#include "gtktypebuiltins.h"
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
static GHashTable *parse_funcs = NULL;
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static GHashTable *print_funcs = NULL;
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
static GHashTable *properties = NULL;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
static void
styleproperty: Rename ParseFunc and PrintFunc typedefs Rename them to GtkStyleParseFunc and GtkStylePrintFunc, so we can export them.
2011-05-25 23:32:01 +00:00
register_conversion_function (GType type,
GtkStyleParseFunc parse,
GtkStylePrintFunc print)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (parse)
g_hash_table_insert (parse_funcs, GSIZE_TO_POINTER (type), parse);
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
if (print)
g_hash_table_insert (print_funcs, GSIZE_TO_POINTER (type), print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
styleproperty: Factor out the string print function We print strings in lots of places.
2011-05-29 03:25:05 +00:00
static void
string_append_double (GString *string,
double d)
{
char buf[G_ASCII_DTOSTR_BUF_SIZE];
g_ascii_dtostr (buf, sizeof (buf), d);
g_string_append (string, buf);
}
static void
string_append_string (GString *str,
const char *string)
{
gsize len;
g_string_append_c (str, '"');
do {
len = strcspn (string, "\"\n\r\f");
g_string_append (str, string);
string += len;
switch (*string)
{
case '\0':
break;
case '\n':
g_string_append (str, "\\A ");
break;
case '\r':
g_string_append (str, "\\D ");
break;
case '\f':
g_string_append (str, "\\C ");
break;
case '\"':
g_string_append (str, "\\\"");
break;
default:
g_assert_not_reached ();
break;
}
} while (*string);
g_string_append_c (str, '"');
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
/*** IMPLEMENTATIONS ***/
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
rgba_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkSymbolicColor *symbolic;
GdkRGBA rgba;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
symbolic = _gtk_css_parser_read_symbolic_color (parser);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (symbolic == NULL)
return FALSE;
cssstringfuncs: Read colors as symbolic colors always ... and then try to resolve them, so static colors get resolved in advance, just like it was before.
2011-05-18 11:15:05 +00:00
if (gtk_symbolic_color_resolve (symbolic, NULL, &rgba))
{
g_value_set_boxed (value, &rgba);
gtkstyleproperty: Plug two leaks In rgba_value_parse(), unref the symbolic color once we've resolved it. In gradient_value_parse(), take the GtkGradient so we leave no dangling references.
2011-05-30 17:21:42 +00:00
gtk_symbolic_color_unref (symbolic);
cssstringfuncs: Read colors as symbolic colors always ... and then try to resolve them, so static colors get resolved in advance, just like it was before.
2011-05-18 11:15:05 +00:00
}
else
{
g_value_unset (value);
g_value_init (value, GTK_TYPE_SYMBOLIC_COLOR);
g_value_take_boxed (value, symbolic);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
rgba_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
const GdkRGBA *rgba = g_value_get_boxed (value);
if (rgba == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
else
{
char *s = gdk_rgba_to_string (rgba);
g_string_append (string, s);
g_free (s);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
color_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkSymbolicColor *symbolic;
cssstringfuncs: Read colors as symbolic colors always ... and then try to resolve them, so static colors get resolved in advance, just like it was before.
2011-05-18 11:15:05 +00:00
GdkRGBA rgba;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
symbolic = _gtk_css_parser_read_symbolic_color (parser);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (symbolic == NULL)
return FALSE;
cssstringfuncs: Read colors as symbolic colors always ... and then try to resolve them, so static colors get resolved in advance, just like it was before.
2011-05-18 11:15:05 +00:00
if (gtk_symbolic_color_resolve (symbolic, NULL, &rgba))
{
GdkColor color;
color.red = rgba.red * 65535. + 0.5;
color.green = rgba.green * 65535. + 0.5;
color.blue = rgba.blue * 65535. + 0.5;
g_value_set_boxed (value, &color);
}
else
{
g_value_unset (value);
g_value_init (value, GTK_TYPE_SYMBOLIC_COLOR);
g_value_take_boxed (value, symbolic);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
color_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
const GdkColor *color = g_value_get_boxed (value);
if (color == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
else
{
char *s = gdk_color_to_string (color);
g_string_append (string, s);
g_free (s);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
static gboolean
symbolic_color_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkSymbolicColor *symbolic;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
symbolic = _gtk_css_parser_read_symbolic_color (parser);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (symbolic == NULL)
return FALSE;
g_value_take_boxed (value, symbolic);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
symbolic_color_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkSymbolicColor *symbolic = g_value_get_boxed (value);
if (symbolic == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
else
{
char *s = gtk_symbolic_color_to_string (symbolic);
g_string_append (string, s);
g_free (s);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
font_description_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
PangoFontDescription *font_desc;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
char *str;
str = _gtk_css_parser_read_value (parser);
if (str == NULL)
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
font_desc = pango_font_description_from_string (str);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_free (str);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_value_take_boxed (value, font_desc);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
font_description_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
const PangoFontDescription *desc = g_value_get_boxed (value);
if (desc == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
else
{
char *s = pango_font_description_to_string (desc);
g_string_append (string, s);
g_free (s);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
boolean_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (_gtk_css_parser_try (parser, "true", TRUE) ||
_gtk_css_parser_try (parser, "1", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
g_value_set_boolean (value, TRUE);
return TRUE;
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
else if (_gtk_css_parser_try (parser, "false", TRUE) ||
_gtk_css_parser_try (parser, "0", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
g_value_set_boolean (value, FALSE);
return TRUE;
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
else
{
_gtk_css_parser_error (parser, "Expected a boolean value");
return FALSE;
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
boolean_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
if (g_value_get_boolean (value))
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "true");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "false");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
int_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
gint i;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (!_gtk_css_parser_try_int (parser, &i))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser, "Expected a valid integer value");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return FALSE;
}
g_value_set_int (value, i);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
int_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append_printf (string, "%d", g_value_get_int (value));
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
uint_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
guint u;
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (!_gtk_css_parser_try_uint (parser, &u))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser, "Expected a valid unsigned value");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return FALSE;
}
g_value_set_uint (value, u);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
uint_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append_printf (string, "%u", g_value_get_uint (value));
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
double_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
gdouble d;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (!_gtk_css_parser_try_double (parser, &d))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser, "Expected a number");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return FALSE;
}
g_value_set_double (value, d);
return TRUE;
}
styleproperty: Add a helper function for printing doubles We will want to print doubles more often, so add a little helper function for it. We cannot use printf() here, because we want English locale output.
2011-05-26 01:44:09 +00:00
static void
double_value_print (const GValue *value,
GString *string)
{
string_append_double (string, g_value_get_double (value));
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
float_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
gdouble d;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (!_gtk_css_parser_try_double (parser, &d))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser, "Expected a number");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return FALSE;
}
g_value_set_float (value, d);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
float_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
styleproperty: Add a helper function for printing doubles We will want to print doubles more often, so add a little helper function for it. We cannot use printf() here, because we want English locale output.
2011-05-26 01:44:09 +00:00
string_append_double (string, g_value_get_float (value));
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
cssprovider: Add support for strings
2011-04-12 02:26:10 +00:00
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
string_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
cssprovider: Add support for strings
2011-04-12 02:26:10 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
char *str = _gtk_css_parser_read_string (parser);
cssprovider: Add support for strings
2011-04-12 02:26:10 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (str == NULL)
cssprovider: Add support for strings
2011-04-12 02:26:10 +00:00
return FALSE;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_value_take_string (value, str);
cssprovider: Add support for strings
2011-04-12 02:26:10 +00:00
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
string_value_print (const GValue *value,
GString *str)
cssprovider: Add support for strings
2011-04-12 02:26:10 +00:00
{
styleproperty: Factor out the string print function We print strings in lots of places.
2011-05-29 03:25:05 +00:00
string_append_string (str, g_value_get_string (value));
cssprovider: Add support for strings
2011-04-12 02:26:10 +00:00
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
theming_engine_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkThemingEngine *engine;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
char *str;
str = _gtk_css_parser_try_ident (parser, TRUE);
if (str == NULL)
{
_gtk_css_parser_error (parser, "Expected a valid theme name");
return FALSE;
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
engine = gtk_theming_engine_load (str);
if (engine == NULL)
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser, "Themeing engine '%s' not found", str);
g_free (str);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return FALSE;
}
g_value_set_object (value, engine);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_free (str);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
theming_engine_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkThemingEngine *engine;
char *name;
engine = g_value_get_object (value);
if (engine == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
else
{
/* XXX: gtk_theming_engine_get_name()? */
g_object_get (engine, "name", &name, NULL);
g_string_append (string, name);
g_free (name);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
animation_description_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkAnimationDescription *desc;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
char *str;
str = _gtk_css_parser_read_value (parser);
if (str == NULL)
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
desc = _gtk_animation_description_from_string (str);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_free (str);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (desc == NULL)
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
{
_gtk_css_parser_error (parser, "Invalid animation description");
return FALSE;
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_value_take_boxed (value, desc);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
animation_description_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkAnimationDescription *desc = g_value_get_boxed (value);
if (desc == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
else
_gtk_animation_description_print (desc, string);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
static gboolean
border_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
GtkBorder border = { 0, };
guint i, numbers[4];
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
for (i = 0; i < G_N_ELEMENTS (numbers); i++)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (!_gtk_css_parser_try_uint (parser, &numbers[i]))
break;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
/* XXX: shouldn't allow spaces here? */
_gtk_css_parser_try (parser, "px", TRUE);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (i == 0)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser, "Expected valid border");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return FALSE;
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
border.top = numbers[0];
if (i > 1)
border.right = numbers[1];
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
border.right = border.top;
if (i > 2)
border.bottom = numbers[2];
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
border.bottom = border.top;
if (i > 3)
border.left = numbers[3];
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
border.left = border.right;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_value_set_boxed (value, &border);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
border_value_print (const GValue *value, GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
const GtkBorder *border = g_value_get_boxed (value);
if (border == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else if (border->left != border->right)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append_printf (string, "%d %d %d %d", border->top, border->right, border->bottom, border->left);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else if (border->top != border->bottom)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append_printf (string, "%d %d %d", border->top, border->right, border->bottom);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else if (border->top != border->left)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append_printf (string, "%d %d", border->top, border->right);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append_printf (string, "%d", border->top);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
static gboolean
gradient_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkGradient *gradient;
cairo_pattern_type_t type;
gdouble coords[6];
guint i;
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try (parser, "-gtk-gradient", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
_gtk_css_parser_error (parser,
"Expected '-gtk-gradient'");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try (parser, "(", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
_gtk_css_parser_error (parser,
"Expected '(' after '-gtk-gradient'");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
/* Parse gradient type */
if (_gtk_css_parser_try (parser, "linear", TRUE))
type = CAIRO_PATTERN_TYPE_LINEAR;
else if (_gtk_css_parser_try (parser, "radial", TRUE))
type = CAIRO_PATTERN_TYPE_RADIAL;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
else
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
_gtk_css_parser_error (parser,
"Gradient type must be 'radial' or 'linear'");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
/* Parse start/stop position parameters */
for (i = 0; i < 2; i++)
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (! _gtk_css_parser_try (parser, ",", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
_gtk_css_parser_error (parser,
"Expected ','");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (_gtk_css_parser_try (parser, "left", TRUE))
coords[i * 3] = 0;
else if (_gtk_css_parser_try (parser, "right", TRUE))
coords[i * 3] = 1;
else if (_gtk_css_parser_try (parser, "center", TRUE))
coords[i * 3] = 0.5;
else if (!_gtk_css_parser_try_double (parser, &coords[i * 3]))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
_gtk_css_parser_error (parser,
"Expected a valid X coordinate");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (_gtk_css_parser_try (parser, "top", TRUE))
coords[i * 3 + 1] = 0;
else if (_gtk_css_parser_try (parser, "bottom", TRUE))
coords[i * 3 + 1] = 1;
else if (_gtk_css_parser_try (parser, "center", TRUE))
coords[i * 3 + 1] = 0.5;
else if (!_gtk_css_parser_try_double (parser, &coords[i * 3 + 1]))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
_gtk_css_parser_error (parser,
"Expected a valid Y coordinate");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
if (type == CAIRO_PATTERN_TYPE_RADIAL)
{
/* Parse radius */
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (! _gtk_css_parser_try (parser, ",", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
_gtk_css_parser_error (parser,
"Expected ','");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (! _gtk_css_parser_try_double (parser, &coords[(i * 3) + 2]))
{
_gtk_css_parser_error (parser,
"Expected a numer for the radius");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
}
if (type == CAIRO_PATTERN_TYPE_LINEAR)
gradient = gtk_gradient_new_linear (coords[0], coords[1], coords[3], coords[4]);
else
gradient = gtk_gradient_new_radial (coords[0], coords[1], coords[2],
coords[3], coords[4], coords[5]);
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
while (_gtk_css_parser_try (parser, ",", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkSymbolicColor *color;
gdouble position;
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (_gtk_css_parser_try (parser, "from", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
position = 0;
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try (parser, "(", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_unref (gradient);
_gtk_css_parser_error (parser,
"Expected '('");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
else if (_gtk_css_parser_try (parser, "to", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
position = 1;
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try (parser, "(", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_unref (gradient);
_gtk_css_parser_error (parser,
"Expected '('");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
else if (_gtk_css_parser_try (parser, "color-stop", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try (parser, "(", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_unref (gradient);
_gtk_css_parser_error (parser,
"Expected '('");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try_double (parser, &position))
{
gtk_gradient_unref (gradient);
_gtk_css_parser_error (parser,
"Expected a valid number");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try (parser, ",", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_unref (gradient);
_gtk_css_parser_error (parser,
"Expected a comma");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
}
else
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_unref (gradient);
_gtk_css_parser_error (parser,
"Not a valid color-stop definition");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
color = _gtk_css_parser_read_symbolic_color (parser);
if (color == NULL)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_unref (gradient);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_add_color_stop (gradient, position, color);
gtk_symbolic_color_unref (color);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try (parser, ")", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_unref (gradient);
_gtk_css_parser_error (parser,
"Expected ')'");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
}
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
if (!_gtk_css_parser_try (parser, ")", TRUE))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Rewrite the parser Instead of relying on GScanner and its idea of syntax, code up a parser that obeys the CSS spec. This also has the great side effect of reporting correct line numbers and positions. Also included is a reorganization of the returned error values. Instead of error values describing what type of syntax error was returned, the code just returns SYNTAX_ERROR. Other messages exist for when actual values don't work or when errors shouldn't be fatal due to backwards compatibility.
2011-04-14 02:47:18 +00:00
gtk_gradient_unref (gradient);
_gtk_css_parser_error (parser,
"Expected ')'");
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
gtkstyleproperty: Plug two leaks In rgba_value_parse(), unref the symbolic color once we've resolved it. In gradient_value_parse(), take the GtkGradient so we leave no dangling references.
2011-05-30 17:21:42 +00:00
g_value_take_boxed (value, gradient);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
gradient_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GtkGradient *gradient = g_value_get_boxed (value);
if (gradient == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
else
{
char *s = gtk_gradient_to_string (gradient);
g_string_append (string, s);
g_free (s);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
stringfuncs: Remove _gtk_css_parse_url() from header No code changes, just moving the function in the c file so it doesn't need to be forward-declared.
2011-05-21 01:18:00 +00:00
static GFile *
gtk_css_parse_url (GtkCssParser *parser,
GFile *base)
{
gchar *path;
GFile *file;
if (_gtk_css_parser_try (parser, "url", FALSE))
{
if (!_gtk_css_parser_try (parser, "(", TRUE))
{
_gtk_css_parser_skip_whitespace (parser);
if (_gtk_css_parser_try (parser, "(", TRUE))
{
GError *error;
error = g_error_new_literal (GTK_CSS_PROVIDER_ERROR,
GTK_CSS_PROVIDER_ERROR_DEPRECATED,
"Whitespace between 'url' and '(' is not allowed");
_gtk_css_parser_take_error (parser, error);
}
else
{
_gtk_css_parser_error (parser, "Expected '(' after 'url'");
return NULL;
}
}
path = _gtk_css_parser_read_string (parser);
if (path == NULL)
return NULL;
if (!_gtk_css_parser_try (parser, ")", TRUE))
{
_gtk_css_parser_error (parser, "No closing ')' found for 'url'");
g_free (path);
return NULL;
}
}
else
{
path = _gtk_css_parser_try_name (parser, TRUE);
if (path == NULL)
{
_gtk_css_parser_error (parser, "Not a valid url");
return NULL;
}
}
file = g_file_resolve_relative_path (base, path);
g_free (path);
return file;
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
pattern_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (_gtk_css_parser_begins_with (parser, '-'))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
g_value_unset (value);
g_value_init (value, GTK_TYPE_GRADIENT);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return gradient_value_parse (parser, base, value);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
else
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
GError *error = NULL;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
gchar *path;
GdkPixbuf *pixbuf;
GFile *file;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
cairo_surface_t *surface;
cairo_pattern_t *pattern;
cairo_t *cr;
cairo_matrix_t matrix;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
stringfuncs: Remove _gtk_css_parse_url() from header No code changes, just moving the function in the c file so it doesn't need to be forward-declared.
2011-05-21 01:18:00 +00:00
file = gtk_css_parse_url (parser, base);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (file == NULL)
return FALSE;
path = g_file_get_path (file);
g_object_unref (file);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
pixbuf = gdk_pixbuf_new_from_file (path, &error);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_free (path);
if (pixbuf == NULL)
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
{
_gtk_css_parser_take_error (parser, error);
return FALSE;
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
cr = cairo_create (surface);
gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
cairo_paint (cr);
pattern = cairo_pattern_create_for_surface (surface);
cairo_matrix_init_scale (&matrix,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
cairo_pattern_set_matrix (pattern, &matrix);
cairo_surface_destroy (surface);
cairo_destroy (cr);
g_object_unref (pixbuf);
g_value_take_boxed (value, pattern);
}
return TRUE;
}
css: add a parser for GTK_TYPE_SHADOW properties https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:48:22 +00:00
static gboolean
shadow_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
{
gboolean inset;
gdouble hoffset, voffset, blur, spread;
GtkSymbolicColor *color;
GtkShadow *shadow;
shadow = _gtk_shadow_new ();
do
{
inset = _gtk_css_parser_try (parser, "inset", TRUE);
if (!_gtk_css_parser_try_double (parser, &hoffset) ||
!_gtk_css_parser_try_double (parser, &voffset))
{
_gtk_css_parser_error (parser, "Horizontal and vertical offsets are required");
_gtk_shadow_unref (shadow);
return FALSE;
}
if (!_gtk_css_parser_try_double (parser, &blur))
blur = 0;
if (!_gtk_css_parser_try_double (parser, &spread))
spread = 0;
/* XXX: the color is optional and UA-defined if it's missing,
* but it doesn't really make sense for us...
*/
color = _gtk_css_parser_read_symbolic_color (parser);
if (color == NULL)
{
_gtk_shadow_unref (shadow);
return FALSE;
}
_gtk_shadow_append (shadow,
hoffset, voffset,
blur, spread,
inset, color);
gtk_symbolic_color_unref (color);
}
while (_gtk_css_parser_try (parser, ",", TRUE));
g_value_take_boxed (value, shadow);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
shadow_value_print (const GValue *value,
GString *string)
css: add a parser for GTK_TYPE_SHADOW properties https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:48:22 +00:00
{
GtkShadow *shadow;
shadow = g_value_get_boxed (value);
if (shadow == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, "none");
else
_gtk_shadow_print (shadow, string);
css: add a parser for GTK_TYPE_SHADOW properties https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:48:22 +00:00
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
slice_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
gdouble distance_top, distance_bottom;
gdouble distance_left, distance_right;
GtkSliceSideModifier mods[2];
GdkPixbuf *pixbuf;
Gtk9Slice *slice;
GFile *file;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
GError *error = NULL;
gint i;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
char *path;
/* Parse image url */
stringfuncs: Remove _gtk_css_parse_url() from header No code changes, just moving the function in the c file so it doesn't need to be forward-declared.
2011-05-21 01:18:00 +00:00
file = gtk_css_parse_url (parser, base);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (!file)
return FALSE;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (!_gtk_css_parser_try_double (parser, &distance_top) ||
!_gtk_css_parser_try_double (parser, &distance_right) ||
!_gtk_css_parser_try_double (parser, &distance_bottom) ||
!_gtk_css_parser_try_double (parser, &distance_left))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser, "Expected a number");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_object_unref (file);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return FALSE;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
for (i = 0; i < 2; i++)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (_gtk_css_parser_try (parser, "stretch", TRUE))
mods[i] = GTK_SLICE_STRETCH;
else if (_gtk_css_parser_try (parser, "repeat", TRUE))
mods[i] = GTK_SLICE_REPEAT;
else if (i == 0)
{
mods[1] = mods[0] = GTK_SLICE_STRETCH;
break;
}
else
mods[i] = mods[0];
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
path = g_file_get_path (file);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_object_unref (file);
pixbuf = gdk_pixbuf_new_from_file (path, &error);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_free (path);
if (!pixbuf)
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
{
_gtk_css_parser_take_error (parser, error);
return FALSE;
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
slice = _gtk_9slice_new (pixbuf,
distance_top, distance_bottom,
distance_left, distance_right,
mods[0], mods[1]);
g_object_unref (pixbuf);
g_value_take_boxed (value, slice);
return TRUE;
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
enum_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GEnumClass *enum_class;
GEnumValue *enum_value;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
char *str;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
str = _gtk_css_parser_try_ident (parser, TRUE);
if (str == NULL)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser, "Expected an identifier");
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return FALSE;
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
enum_class = g_type_class_ref (G_VALUE_TYPE (value));
enum_value = g_enum_get_value_by_nick (enum_class, str);
if (enum_value)
g_value_set_enum (value, enum_value->value);
else
_gtk_css_parser_error (parser,
"Unknown value '%s' for enum type '%s'",
str, g_type_name (G_VALUE_TYPE (value)));
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_type_class_unref (enum_class);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_free (str);
return enum_value != NULL;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
enum_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GEnumClass *enum_class;
GEnumValue *enum_value;
enum_class = g_type_class_ref (G_VALUE_TYPE (value));
enum_value = g_enum_get_value (enum_class, g_value_get_enum (value));
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, enum_value->value_nick);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_type_class_unref (enum_class);
}
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
flags_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GFlagsClass *flags_class;
GFlagsValue *flag_value;
guint flags = 0;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
char *str;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
flags_class = g_type_class_ref (G_VALUE_TYPE (value));
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
do {
str = _gtk_css_parser_try_ident (parser, TRUE);
if (str == NULL)
{
_gtk_css_parser_error (parser, "Expected an identifier");
g_type_class_unref (flags_class);
return FALSE;
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
flag_value = g_flags_get_value_by_nick (flags_class, str);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (!flag_value)
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser,
"Unknown flag value '%s' for type '%s'",
str, g_type_name (G_VALUE_TYPE (value)));
/* XXX Do we want to return FALSE here? We can get
* forward-compatibility for new values this way
*/
g_free (str);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_type_class_unref (flags_class);
return FALSE;
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_free (str);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
while (_gtk_css_parser_try (parser, ",", FALSE));
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
g_type_class_unref (flags_class);
g_value_set_enum (value, flags);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
flags_value_print (const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
GFlagsClass *flags_class;
guint i, flags;
flags_class = g_type_class_ref (G_VALUE_TYPE (value));
flags = g_value_get_flags (value);
for (i = 0; i < flags_class->n_values; i++)
{
GFlagsValue *flags_value = &flags_class->values[i];
if (flags & flags_value->value)
{
if (string->len != 0)
g_string_append (string, ", ");
g_string_append (string, flags_value->value_nick);
}
}
g_type_class_unref (flags_class);
}
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
static gboolean
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
bindings_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
{
GPtrArray *array;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
GtkBindingSet *binding_set;
char *name;
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
array = g_ptr_array_new ();
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
do {
name = _gtk_css_parser_try_ident (parser, TRUE);
if (name == NULL)
{
_gtk_css_parser_error (parser, "Not a valid binding name");
g_ptr_array_free (array, TRUE);
return FALSE;
}
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
binding_set = gtk_binding_set_find (name);
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
if (!binding_set)
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
{
_gtk_css_parser_error (parser, "No binding set named '%s'", name);
g_free (name);
continue;
}
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
g_ptr_array_add (array, binding_set);
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_free (name);
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
while (_gtk_css_parser_try (parser, ",", TRUE));
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
g_value_take_boxed (value, array);
return TRUE;
}
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
static void
bindings_value_print (const GValue *value,
GString *string)
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
{
GPtrArray *array;
guint i;
array = g_value_get_boxed (value);
for (i = 0; i < array->len; i++)
{
GtkBindingSet *binding_set = g_ptr_array_index (array, i);
if (i > 0)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
g_string_append (string, ", ");
g_string_append (string, binding_set->set_name);
css: Move binding set parsing to strfuncs
2011-05-18 16:03:23 +00:00
}
}
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
static gboolean
border_corner_radius_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
{
GtkCssBorderCornerRadius corner;
if (!_gtk_css_parser_try_double (parser, &corner.horizontal))
{
_gtk_css_parser_error (parser, "Expected a number");
return FALSE;
}
else if (corner.horizontal < 0)
goto negative;
if (!_gtk_css_parser_try_double (parser, &corner.vertical))
corner.vertical = corner.horizontal;
else if (corner.vertical < 0)
goto negative;
g_value_set_boxed (value, &corner);
return TRUE;
negative:
_gtk_css_parser_error (parser, "Border radius values cannot be negative");
return FALSE;
}
static void
border_corner_radius_value_print (const GValue *value,
GString *string)
{
GtkCssBorderCornerRadius *corner;
corner = g_value_get_boxed (value);
if (corner == NULL)
{
g_string_append (string, "none");
return;
}
string_append_double (string, corner->horizontal);
if (corner->horizontal != corner->vertical)
{
g_string_append_c (string, ' ');
string_append_double (string, corner->vertical);
}
}
static gboolean
border_radius_value_parse (GtkCssParser *parser,
GFile *base,
GValue *value)
{
GtkCssBorderRadius border;
if (!_gtk_css_parser_try_double (parser, &border.top_left.horizontal))
{
_gtk_css_parser_error (parser, "Expected a number");
return FALSE;
}
else if (border.top_left.horizontal < 0)
goto negative;
if (_gtk_css_parser_try_double (parser, &border.top_right.horizontal))
{
if (border.top_right.horizontal < 0)
goto negative;
if (_gtk_css_parser_try_double (parser, &border.bottom_right.horizontal))
{
if (border.bottom_right.horizontal < 0)
goto negative;
if (!_gtk_css_parser_try_double (parser, &border.bottom_left.horizontal))
border.bottom_left.horizontal = border.top_right.horizontal;
else if (border.bottom_left.horizontal < 0)
goto negative;
}
else
{
border.bottom_right.horizontal = border.top_left.horizontal;
border.bottom_left.horizontal = border.top_right.horizontal;
}
}
else
{
border.top_right.horizontal = border.top_left.horizontal;
border.bottom_right.horizontal = border.top_left.horizontal;
border.bottom_left.horizontal = border.top_left.horizontal;
}
if (_gtk_css_parser_try (parser, "/", TRUE))
{
if (!_gtk_css_parser_try_double (parser, &border.top_left.vertical))
{
_gtk_css_parser_error (parser, "Expected a number");
return FALSE;
}
else if (border.top_left.vertical < 0)
goto negative;
if (_gtk_css_parser_try_double (parser, &border.top_right.vertical))
{
if (border.top_right.vertical < 0)
goto negative;
if (_gtk_css_parser_try_double (parser, &border.bottom_right.vertical))
{
if (border.bottom_right.vertical < 0)
goto negative;
if (!_gtk_css_parser_try_double (parser, &border.bottom_left.vertical))
border.bottom_left.vertical = border.top_right.vertical;
else if (border.bottom_left.vertical < 0)
goto negative;
}
else
{
border.bottom_right.vertical = border.top_left.vertical;
border.bottom_left.vertical = border.top_right.vertical;
}
}
else
{
border.top_right.vertical = border.top_left.vertical;
border.bottom_right.vertical = border.top_left.vertical;
border.bottom_left.vertical = border.top_left.vertical;
}
}
else
{
border.top_left.vertical = border.top_left.horizontal;
border.top_right.vertical = border.top_right.horizontal;
border.bottom_right.vertical = border.bottom_right.horizontal;
border.bottom_left.vertical = border.bottom_left.horizontal;
}
/* border-radius is an int property for backwards-compat reasons */
g_value_unset (value);
g_value_init (value, GTK_TYPE_CSS_BORDER_RADIUS);
g_value_set_boxed (value, &border);
return TRUE;
negative:
_gtk_css_parser_error (parser, "Border radius values cannot be negative");
return FALSE;
}
static void
border_radius_value_print (const GValue *value,
GString *string)
{
GtkCssBorderRadius *border;
border = g_value_get_boxed (value);
if (border == NULL)
{
g_string_append (string, "none");
return;
}
string_append_double (string, border->top_left.horizontal);
if (border->top_left.horizontal != border->top_right.horizontal ||
border->top_left.horizontal != border->bottom_right.horizontal ||
border->top_left.horizontal != border->bottom_left.horizontal)
{
g_string_append_c (string, ' ');
string_append_double (string, border->top_right.horizontal);
if (border->top_left.horizontal != border->bottom_right.horizontal ||
border->top_right.horizontal != border->bottom_left.horizontal)
{
g_string_append_c (string, ' ');
string_append_double (string, border->bottom_right.horizontal);
if (border->top_right.horizontal != border->bottom_left.horizontal)
{
g_string_append_c (string, ' ');
string_append_double (string, border->bottom_left.horizontal);
}
}
}
if (border->top_left.horizontal != border->top_left.vertical ||
border->top_right.horizontal != border->top_right.vertical ||
border->bottom_right.horizontal != border->bottom_right.vertical ||
border->bottom_left.horizontal != border->bottom_left.vertical)
{
g_string_append (string, " / ");
string_append_double (string, border->top_left.vertical);
if (border->top_left.vertical != border->top_right.vertical ||
border->top_left.vertical != border->bottom_right.vertical ||
border->top_left.vertical != border->bottom_left.vertical)
{
g_string_append_c (string, ' ');
string_append_double (string, border->top_right.vertical);
if (border->top_left.vertical != border->bottom_right.vertical ||
border->top_right.vertical != border->bottom_left.vertical)
{
g_string_append_c (string, ' ');
string_append_double (string, border->bottom_right.vertical);
if (border->top_right.vertical != border->bottom_left.vertical)
{
g_string_append_c (string, ' ');
string_append_double (string, border->bottom_left.vertical);
}
}
}
}
}
style: Convert border-width to a shorthand Add the corresponding properties it refers to, too: - border-top-width - border-left-width - border-bottom-width - border-right-width
2011-05-21 22:10:43 +00:00
/*** PACKING ***/
static GParameter *
unpack_border (const GValue *value,
guint *n_params,
const char *top,
const char *left,
const char *bottom,
const char *right)
{
GParameter *parameter = g_new0 (GParameter, 4);
GtkBorder *border = g_value_get_boxed (value);
parameter[0].name = top;
g_value_init (&parameter[0].value, G_TYPE_INT);
g_value_set_int (&parameter[0].value, border->top);
parameter[1].name = left;
g_value_init (&parameter[1].value, G_TYPE_INT);
g_value_set_int (&parameter[1].value, border->left);
parameter[2].name = bottom;
g_value_init (&parameter[2].value, G_TYPE_INT);
g_value_set_int (&parameter[2].value, border->bottom);
parameter[3].name = right;
g_value_init (&parameter[3].value, G_TYPE_INT);
g_value_set_int (&parameter[3].value, border->right);
*n_params = 4;
return parameter;
}
static void
pack_border (GValue *value,
GtkStyleProperties *props,
GtkStateFlags state,
const char *top,
const char *left,
const char *bottom,
const char *right)
{
GtkBorder border;
int t, l, b, r;
gtk_style_properties_get (props,
state,
top, &t,
left, &l,
bottom, &b,
right, &r,
NULL);
border.top = t;
border.left = l;
border.bottom = b;
border.right = r;
g_value_set_boxed (value, &border);
}
static GParameter *
unpack_border_width (const GValue *value,
guint *n_params)
{
return unpack_border (value, n_params,
"border-top-width", "border-left-width",
"border-bottom-width", "border-right-width");
}
static void
pack_border_width (GValue *value,
GtkStyleProperties *props,
GtkStateFlags state)
{
pack_border (value, props, state,
"border-top-width", "border-left-width",
"border-bottom-width", "border-right-width");
}
style: Make padding a shorthand ... and add the real properties: - padding-top - padding-left - padding-bottom - padding-right
2011-05-22 03:42:17 +00:00
static GParameter *
unpack_padding (const GValue *value,
guint *n_params)
{
return unpack_border (value, n_params,
"padding-top", "padding-left",
"padding-bottom", "padding-right");
}
static void
pack_padding (GValue *value,
GtkStyleProperties *props,
GtkStateFlags state)
{
pack_border (value, props, state,
"padding-top", "padding-left",
"padding-bottom", "padding-right");
}
style: Make margin a shorthand ... and add the real properties: - margin-top - margin-left - margin-bottom - margin-right
2011-05-22 03:55:12 +00:00
static GParameter *
unpack_margin (const GValue *value,
guint *n_params)
{
return unpack_border (value, n_params,
"margin-top", "margin-left",
"margin-bottom", "margin-right");
}
static void
pack_margin (GValue *value,
GtkStyleProperties *props,
GtkStateFlags state)
{
pack_border (value, props, state,
"margin-top", "margin-left",
"margin-bottom", "margin-right");
}
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
static GParameter *
unpack_border_radius (const GValue *value,
guint *n_params)
{
GParameter *parameter = g_new0 (GParameter, 4);
GtkCssBorderRadius *border;
if (G_VALUE_HOLDS_BOXED (value))
border = g_value_get_boxed (value);
else
border = NULL;
parameter[0].name = "border-top-left-radius";
g_value_init (&parameter[0].value, GTK_TYPE_CSS_BORDER_CORNER_RADIUS);
parameter[1].name = "border-top-right-radius";
g_value_init (&parameter[1].value, GTK_TYPE_CSS_BORDER_CORNER_RADIUS);
parameter[2].name = "border-bottom-right-radius";
g_value_init (&parameter[2].value, GTK_TYPE_CSS_BORDER_CORNER_RADIUS);
parameter[3].name = "border-bottom-left-radius";
g_value_init (&parameter[3].value, GTK_TYPE_CSS_BORDER_CORNER_RADIUS);
if (border)
{
g_value_set_boxed (&parameter[0].value, &border->top_left);
g_value_set_boxed (&parameter[1].value, &border->top_right);
g_value_set_boxed (&parameter[2].value, &border->bottom_right);
g_value_set_boxed (&parameter[3].value, &border->bottom_left);
}
*n_params = 4;
return parameter;
}
static void
pack_border_radius (GValue *value,
GtkStyleProperties *props,
GtkStateFlags state)
{
GtkCssBorderCornerRadius *top_left;
/* NB: We are an int property, so we have to resolve to an int here.
* So we just resolve to an int. We pick one and stick to it.
* Lesson learned: Don't query border-radius shorthand, query the
* real properties instead. */
gtk_style_properties_get (props,
state,
"border-top-left-radius", &top_left,
NULL);
if (top_left)
g_value_set_int (value, top_left->horizontal);
g_free (top_left);
}
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
/*** API ***/
static void
css_string_funcs_init (void)
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
if (G_LIKELY (parse_funcs != NULL))
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return;
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
parse_funcs = g_hash_table_new (NULL, NULL);
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
print_funcs = g_hash_table_new (NULL, NULL);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (GDK_TYPE_RGBA,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
rgba_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
rgba_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (GDK_TYPE_COLOR,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
color_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
color_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (GTK_TYPE_SYMBOLIC_COLOR,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
symbolic_color_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
symbolic_color_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (PANGO_TYPE_FONT_DESCRIPTION,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
font_description_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
font_description_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (G_TYPE_BOOLEAN,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
boolean_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
boolean_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (G_TYPE_INT,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
int_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
int_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (G_TYPE_UINT,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
uint_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
uint_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (G_TYPE_DOUBLE,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
double_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
double_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (G_TYPE_FLOAT,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
float_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
float_value_print);
cssprovider: Add support for strings
2011-04-12 02:26:10 +00:00
register_conversion_function (G_TYPE_STRING,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
string_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
string_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (GTK_TYPE_THEMING_ENGINE,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
theming_engine_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
theming_engine_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (GTK_TYPE_ANIMATION_DESCRIPTION,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
animation_description_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
animation_description_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (GTK_TYPE_BORDER,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
border_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
border_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (GTK_TYPE_GRADIENT,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
gradient_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
gradient_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (CAIRO_GOBJECT_TYPE_PATTERN,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
pattern_value_parse,
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
NULL);
register_conversion_function (GTK_TYPE_9SLICE,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
slice_value_parse,
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
NULL);
css: add a parser for GTK_TYPE_SHADOW properties https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:48:22 +00:00
register_conversion_function (GTK_TYPE_SHADOW,
shadow_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
shadow_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (G_TYPE_ENUM,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
enum_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
enum_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
register_conversion_function (G_TYPE_FLAGS,
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
flags_value_parse,
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
flags_value_print);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
gboolean
css: Rename function to _gtk_style_property_parse_value() ... and take an optional style property as argument. This way, we can allow custom parse functions for properties. The style property needs to be optional so that we can use it for widget style properties, too.
2011-05-25 23:01:44 +00:00
_gtk_style_property_parse_value (const GtkStyleProperty *property,
GValue *value,
GtkCssParser *parser,
GFile *base)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
styleproperty: Rename ParseFunc and PrintFunc typedefs Rename them to GtkStyleParseFunc and GtkStylePrintFunc, so we can export them.
2011-05-25 23:32:01 +00:00
GtkStyleParseFunc func;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
g_return_val_if_fail (value != NULL, FALSE);
g_return_val_if_fail (parser != NULL, FALSE);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css_string_funcs_init ();
css: Move property parsing into styleproperty file Just shuffles code around for parsing properties.
2011-05-25 23:25:00 +00:00
if (property)
{
if (_gtk_css_parser_try (parser, "none", TRUE))
{
/* Insert the default value, so it has an opportunity
* to override other style providers when merged
*/
g_param_value_set_default (property->pspec, value);
return TRUE;
}
else if (property->property_parse_func)
{
GError *error = NULL;
char *value_str;
gboolean success;
value_str = _gtk_css_parser_read_value (parser);
if (value_str == NULL)
return FALSE;
success = (*property->property_parse_func) (value_str, value, &error);
g_free (value_str);
return success;
}
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
func = property->parse_func;
css: Move property parsing into styleproperty file Just shuffles code around for parsing properties.
2011-05-25 23:25:00 +00:00
}
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
else
func = NULL;
css: Move property parsing into styleproperty file Just shuffles code around for parsing properties.
2011-05-25 23:25:00 +00:00
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
if (func == NULL)
func = g_hash_table_lookup (parse_funcs,
GSIZE_TO_POINTER (G_VALUE_TYPE (value)));
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (func == NULL)
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
func = g_hash_table_lookup (parse_funcs,
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
GSIZE_TO_POINTER (g_type_fundamental (G_VALUE_TYPE (value))));
if (func == NULL)
{
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
_gtk_css_parser_error (parser,
"Cannot convert to type '%s'",
g_type_name (G_VALUE_TYPE (value)));
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
return FALSE;
}
css: Make property parsing functions take a css parser Instead of reading a string and then passing that in, let the parse functions use the full power of the parser.
2011-05-18 16:32:22 +00:00
return (*func) (parser, base, value);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
styleproperty: Change _css_value_to_string() Name it _gtk_style_property_print_value() and actually pass it the style property. This way, we can later change it to use custom print functions for different style properties.
2011-05-23 05:16:17 +00:00
void
_gtk_style_property_print_value (const GtkStyleProperty *property,
const GValue *value,
GString *string)
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
{
styleproperty: Rename ParseFunc and PrintFunc typedefs Rename them to GtkStyleParseFunc and GtkStylePrintFunc, so we can export them.
2011-05-25 23:32:01 +00:00
GtkStylePrintFunc func;
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
css_string_funcs_init ();
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
if (property)
func = property->print_func;
else
func = NULL;
if (func == NULL)
func = g_hash_table_lookup (print_funcs,
GSIZE_TO_POINTER (G_VALUE_TYPE (value)));
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
if (func == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
func = g_hash_table_lookup (print_funcs,
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
GSIZE_TO_POINTER (g_type_fundamental (G_VALUE_TYPE (value))));
styleproperty: Change _css_value_to_string() Name it _gtk_style_property_print_value() and actually pass it the style property. This way, we can later change it to use custom print functions for different style properties.
2011-05-23 05:16:17 +00:00
if (func == NULL)
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
{
styleproperty: Change _css_value_to_string() Name it _gtk_style_property_print_value() and actually pass it the style property. This way, we can later change it to use custom print functions for different style properties.
2011-05-23 05:16:17 +00:00
char *s = g_strdup_value_contents (value);
g_string_append (string, s);
g_free (s);
return;
css: Change to_string() to print() It's preferrable to print to an existing GString instead of returning a char* everywhere that needs to be freed later.
2011-05-23 05:02:36 +00:00
}
styleproperty: Change _css_value_to_string() Name it _gtk_style_property_print_value() and actually pass it the style property. This way, we can later change it to use custom print functions for different style properties.
2011-05-23 05:16:17 +00:00
func (value, string);
css: Overhaul value parsing Value parsing only sometimes emitted errors. Sometimes it didn't emit errors but ignored the value, sometimes it took a default, sometimes it converted it to something it deemed suitable. While refactoring, I moved the whole GValue <=> char * conversion routines to a separate file, to make navigating the core css provider easier.
2011-04-08 14:08:28 +00:00
}
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
void
_gtk_style_property_default_value (const GtkStyleProperty *property,
GtkStyleProperties *properties,
GValue *value)
{
if (property->default_value_func)
property->default_value_func (properties, value);
else if (property->pspec->value_type == GTK_TYPE_THEMING_ENGINE)
g_value_set_object (value, gtk_theming_engine_load (NULL));
else if (property->pspec->value_type == PANGO_TYPE_FONT_DESCRIPTION)
g_value_take_boxed (value, pango_font_description_from_string ("Sans 10"));
else if (property->pspec->value_type == GDK_TYPE_RGBA)
{
GdkRGBA color;
gdk_rgba_parse (&color, "pink");
g_value_set_boxed (value, &color);
}
else if (property->pspec->value_type == GTK_TYPE_BORDER)
{
g_value_take_boxed (value, gtk_border_new ());
}
else
g_param_value_set_default (property->pspec, value);
}
style: Add support for shorthand properties Shorthand properties are basically the same a in CSS. For storage in style properties or the CSS provider, they are unpacked into the real values, so it is possible to partially override them. No properties are yet converted to the new world yet, this is just the code for supporting them.
2011-05-21 21:47:19 +00:00
gboolean
_gtk_style_property_is_shorthand (const GtkStyleProperty *property)
{
g_return_val_if_fail (property != NULL, FALSE);
return property->pack_func != NULL;
}
GParameter *
_gtk_style_property_unpack (const GtkStyleProperty *property,
const GValue *value,
guint *n_params)
{
g_return_val_if_fail (property != NULL, NULL);
g_return_val_if_fail (property->unpack_func != NULL, NULL);
g_return_val_if_fail (value != NULL, NULL);
g_return_val_if_fail (n_params != NULL, NULL);
return property->unpack_func (value, n_params);
}
void
_gtk_style_property_pack (const GtkStyleProperty *property,
GtkStyleProperties *props,
GtkStateFlags state,
GValue *value)
{
g_return_if_fail (property != NULL);
g_return_if_fail (property->pack_func != NULL);
g_return_if_fail (GTK_IS_STYLE_PROPERTIES (props));
g_return_if_fail (G_IS_VALUE (value));
property->pack_func (value, props, state);
}
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
static void
gtk_style_property_init (void)
{
GParamSpec *pspec;
if (G_LIKELY (properties))
return;
/* stuff is never freed, so no need for free functions */
properties = g_hash_table_new (g_str_hash, g_str_equal);
/* note that gtk_style_properties_register_property() calls this function,
* so make sure we're sanely inited to avoid infloops */
pspec = g_param_spec_boxed ("color",
"Foreground color",
"Foreground color",
GDK_TYPE_RGBA, 0);
gtk_style_param_set_inherit (pspec, TRUE);
gtk_style_properties_register_property (NULL, pspec);
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("background-color",
"Background color",
"Background color",
GDK_TYPE_RGBA, 0));
pspec = g_param_spec_boxed ("font",
"Font Description",
"Font Description",
PANGO_TYPE_FONT_DESCRIPTION, 0);
gtk_style_param_set_inherit (pspec, TRUE);
gtk_style_properties_register_property (NULL, pspec);
pspec = g_param_spec_boxed ("text-shadow",
"Text shadow",
"Text shadow",
GTK_TYPE_SHADOW, 0);
gtk_style_param_set_inherit (pspec, TRUE);
gtk_style_properties_register_property (NULL, pspec);
gtk_style_properties_register_property (NULL,
style: Make margin a shorthand ... and add the real properties: - margin-top - margin-left - margin-bottom - margin-right
2011-05-22 03:55:12 +00:00
g_param_spec_int ("margin-top",
"margin top",
"Margin at top",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("margin-left",
"margin left",
"Margin at left",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("margin-bottom",
"margin bottom",
"Margin at bottom",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("margin-right",
"margin right",
"Margin at right",
0, G_MAXINT, 0, 0));
_gtk_style_property_register (g_param_spec_boxed ("margin",
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
"Margin",
"Margin",
style: Make margin a shorthand ... and add the real properties: - margin-top - margin-left - margin-bottom - margin-right
2011-05-22 03:55:12 +00:00
GTK_TYPE_BORDER, 0),
NULL,
unpack_margin,
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
pack_margin,
NULL,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
NULL,
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
NULL);
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
gtk_style_properties_register_property (NULL,
style: Make padding a shorthand ... and add the real properties: - padding-top - padding-left - padding-bottom - padding-right
2011-05-22 03:42:17 +00:00
g_param_spec_int ("padding-top",
"padding top",
"Padding at top",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("padding-left",
"padding left",
"Padding at left",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("padding-bottom",
"padding bottom",
"Padding at bottom",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("padding-right",
"padding right",
"Padding at right",
0, G_MAXINT, 0, 0));
_gtk_style_property_register (g_param_spec_boxed ("padding",
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
"Padding",
"Padding",
style: Make padding a shorthand ... and add the real properties: - padding-top - padding-left - padding-bottom - padding-right
2011-05-22 03:42:17 +00:00
GTK_TYPE_BORDER, 0),
NULL,
unpack_padding,
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
pack_padding,
NULL,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
NULL,
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
NULL);
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
gtk_style_properties_register_property (NULL,
style: Convert border-width to a shorthand Add the corresponding properties it refers to, too: - border-top-width - border-left-width - border-bottom-width - border-right-width
2011-05-21 22:10:43 +00:00
g_param_spec_int ("border-top-width",
"border top width",
"Border width at top",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("border-left-width",
"border left width",
"Border width at left",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("border-bottom-width",
"border bottom width",
"Border width at bottom",
0, G_MAXINT, 0, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("border-right-width",
"border right width",
"Border width at right",
0, G_MAXINT, 0, 0));
_gtk_style_property_register (g_param_spec_boxed ("border-width",
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
"Border width",
"Border width, in pixels",
style: Convert border-width to a shorthand Add the corresponding properties it refers to, too: - border-top-width - border-left-width - border-bottom-width - border-right-width
2011-05-21 22:10:43 +00:00
GTK_TYPE_BORDER, 0),
NULL,
unpack_border_width,
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
pack_border_width,
NULL,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
NULL,
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
NULL);
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
_gtk_style_property_register (g_param_spec_boxed ("border-top-left-radius",
"Border top left radius",
"Border radius of top left corner, in pixels",
GTK_TYPE_CSS_BORDER_CORNER_RADIUS, 0),
NULL,
NULL,
NULL,
border_corner_radius_value_parse,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
border_corner_radius_value_print,
NULL);
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
_gtk_style_property_register (g_param_spec_boxed ("border-top-right-radius",
"Border top right radius",
"Border radius of top right corner, in pixels",
GTK_TYPE_CSS_BORDER_CORNER_RADIUS, 0),
NULL,
NULL,
NULL,
border_corner_radius_value_parse,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
border_corner_radius_value_print,
NULL);
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
_gtk_style_property_register (g_param_spec_boxed ("border-bottom-right-radius",
"Border bottom right radius",
"Border radius of bottom right corner, in pixels",
GTK_TYPE_CSS_BORDER_CORNER_RADIUS, 0),
NULL,
NULL,
NULL,
border_corner_radius_value_parse,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
border_corner_radius_value_print,
NULL);
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
_gtk_style_property_register (g_param_spec_boxed ("border-bottom-left-radius",
"Border bottom left radius",
"Border radius of bottom left corner, in pixels",
GTK_TYPE_CSS_BORDER_CORNER_RADIUS, 0),
NULL,
NULL,
NULL,
border_corner_radius_value_parse,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
border_corner_radius_value_print,
NULL);
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
_gtk_style_property_register (g_param_spec_int ("border-radius",
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
"Border radius",
"Border radius, in pixels",
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
0, G_MAXINT, 0, 0),
NULL,
unpack_border_radius,
pack_border_radius,
border_radius_value_parse,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
border_radius_value_print,
NULL);
css: Add all border-radius properties Implement all border-radisu properties as specified by http://www.w3.org/TR/css3-background/#the-border-radius The end goal here is to get joined buttons to really look joined.
2011-05-26 01:50:53 +00:00
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
gtk_style_properties_register_property (NULL,
g_param_spec_enum ("border-style",
"Border style",
"Border style",
GTK_TYPE_BORDER_STYLE,
GTK_BORDER_STYLE_NONE, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("border-color",
"Border color",
"Border color",
GDK_TYPE_RGBA, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("background-image",
"Background Image",
"Background Image",
CAIRO_GOBJECT_TYPE_PATTERN, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("border-image",
"Border Image",
"Border Image",
GTK_TYPE_9SLICE, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_object ("engine",
"Theming Engine",
"Theming Engine",
GTK_TYPE_THEMING_ENGINE, 0));
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("transition",
"Transition animation description",
"Transition animation description",
GTK_TYPE_ANIMATION_DESCRIPTION, 0));
/* Private property holding the binding sets */
styleproperty: Make keybindings use custom parse/print functions We don't want to use it for GPtrArray.
2011-05-25 23:50:41 +00:00
_gtk_style_property_register (g_param_spec_boxed ("gtk-key-bindings",
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
"Key bindings",
"Key bindings",
styleproperty: Make keybindings use custom parse/print functions We don't want to use it for GPtrArray.
2011-05-25 23:50:41 +00:00
G_TYPE_PTR_ARRAY, 0),
NULL,
NULL,
NULL,
bindings_value_parse,
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
bindings_value_print,
NULL);
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
}
const GtkStyleProperty *
_gtk_style_property_lookup (const char *name)
{
gtk_style_property_init ();
return g_hash_table_lookup (properties, name);
}
void
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
_gtk_style_property_register (GParamSpec *pspec,
GtkStylePropertyParser property_parse_func,
GtkStyleUnpackFunc unpack_func,
GtkStylePackFunc pack_func,
GtkStyleParseFunc parse_func,
GtkStylePrintFunc print_func,
GtkStyleDefaultValueFunc default_value_func)
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
{
const GtkStyleProperty *existing;
GtkStyleProperty *node;
style: Add support for shorthand properties Shorthand properties are basically the same a in CSS. For storage in style properties or the CSS provider, they are unpacked into the real values, so it is possible to partially override them. No properties are yet converted to the new world yet, this is just the code for supporting them.
2011-05-21 21:47:19 +00:00
g_return_if_fail ((pack_func == NULL) == (unpack_func == NULL));
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
gtk_style_property_init ();
existing = _gtk_style_property_lookup (pspec->name);
if (existing != NULL)
{
g_warning ("Property \"%s\" was already registered with type %s",
pspec->name, g_type_name (existing->pspec->value_type));
return;
}
node = g_slice_new0 (GtkStyleProperty);
node->pspec = pspec;
css: Rename struct variable I want to add parse_func as something different soon.
2011-05-25 22:09:26 +00:00
node->property_parse_func = property_parse_func;
style: Add support for shorthand properties Shorthand properties are basically the same a in CSS. For storage in style properties or the CSS provider, they are unpacked into the real values, so it is possible to partially override them. No properties are yet converted to the new world yet, this is just the code for supporting them.
2011-05-21 21:47:19 +00:00
node->pack_func = pack_func;
node->unpack_func = unpack_func;
styleproperty: Allow passing in a parse func and a print func It's not used yet, but it's now possible to specify a custom read or write func.
2011-05-25 23:46:49 +00:00
node->parse_func = parse_func;
node->print_func = print_func;
styleproperty: Move default value setting to styleproperty.c
2011-05-28 03:43:07 +00:00
node->default_value_func = default_value_func;
styleproperties: Move the style property handling code ... from gtkstyleproperties.c to gtkstyleproperty.c
2011-05-21 02:17:28 +00:00
g_hash_table_insert (properties, pspec->name, node);
}
Reference in New Issue Copy Permalink