* 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.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gtkcssproviderprivate.h"
-#include "gtkcssstringfuncsprivate.h"
-#include "gtksymboliccolor.h"
+#include "gtkbitmaskprivate.h"
+#include "gtkcssarrayvalueprivate.h"
+#include "gtkcsscolorvalueprivate.h"
+#include "gtkcsskeyframesprivate.h"
+#include "gtkcssparserprivate.h"
+#include "gtkcsssectionprivate.h"
+#include "gtkcssselectorprivate.h"
+#include "gtkcssshorthandpropertyprivate.h"
+#include "gtkcssstylefuncsprivate.h"
#include "gtkstyleprovider.h"
#include "gtkstylecontextprivate.h"
+#include "gtkstylepropertiesprivate.h"
+#include "gtkstylepropertyprivate.h"
+#include "gtkstyleproviderprivate.h"
#include "gtkbindings.h"
#include "gtkmarshalers.h"
#include "gtkprivate.h"
*
* /* Theme any widget within a GtkBin */
* GtkBin * {
- * font-name: Sans 20
+ * font: Sans 20
* }
*
* /* Theme a label named title-label */
* GtkLabel#title-label {
- * font-name: Sans 15
+ * font: Sans 15
* }
*
* /* Theme any widget named main-entry */
* <entry>darker(@color)</entry>
* <entry>A darker variant of @color</entry>
* </row>
+ * <row>
+ * <entry>alpha(@color, @f)</entry>
+ * <entry>Modifies passed color's alpha by a factor @f. @f is a
+ * floating point number. @f < 1.0 results in a more transparent
+ * color while @f > 1.0 results in a more opaque color.
+ * </entry>
+ * <entry>alhpa(blue, 0.5)</entry>
+ * </row>
* </tbody>
* </tgroup>
* </informaltable>
* color-stop (1, @green))</literallayout></para>
* </example>
* </refsect2>
- * <refsect2 id="gtkcssprovider-slices">
+ * <refsect2 id="gtkcssprovider-shadows">
+ * <title>Text shadow</title>
+ * <para>
+ * A shadow list can be applied to text or symbolic icons, using the CSS3
+ * text-shadow syntax, as defined in
+ * <ulink url="http://www.w3.org/TR/css3-text/#text-shadow">the CSS3 specification</ulink>.
+ * </para>
+ * <para>
+ * A text shadow is specified using the syntax
+ * <literallayout>text-shadow: @horizontal_offset @vertical_offset [ @blur_radius ] @color</literallayout>
+ * The offset of the shadow is specified with the @horizontal_offset and @vertical_offset
+ * parameters. The optional blur radius is parsed, but it is currently not rendered by
+ * the GTK+ theming engine.
+ * </para>
+ * <para>
+ * To set multiple shadows on an element, you can specify a comma-separated list
+ * of shadow elements in the text-shadow property. Shadows are always rendered
+ * front-back, i.e. the first shadow specified is on top of the others. Shadows
+ * can thus overlay each other, but they can never overlay the text itself,
+ * which is always rendered on top of the shadow layer.
+ * </para>
+ * </refsect2>
+ * <refsect2>
+ * <title>Box shadow</title>
+ * <para>
+ * Themes can apply shadows on framed elements using the CSS3 box-shadow syntax,
+ * as defined in
+ * <ulink url="http://www.w3.org/TR/css3-background/#the-box-shadow">the CSS3 specification</ulink>.
+ * </para>
+ * <para>
+ * A box shadow is specified using the syntax
+ * <literallayout>box-shadow: [ @inset ] @horizontal_offset @vertical_offset [ @blur_radius ] [ @spread ] @color</literallayout>
+ * A positive offset will draw a shadow that is offset to the right (down) of the box,
+ * a negative offset to the left (top). The optional spread parameter defines an additional
+ * distance to expand the shadow shape in all directions, by the specified radius.
+ * The optional blur radius parameter is parsed, but it is currently not rendered by
+ * the GTK+ theming engine.
+ * The inset parameter defines whether the drop shadow should be rendered inside or outside
+ * the box canvas. Only inset box-shadows are currently supported by the GTK+ theming engine,
+ * non-inset elements are currently ignored.
+ * </para>
+ * <para>
+ * To set multiple box-shadows on an element, you can specify a comma-separated list
+ * of shadow elements in the box-shadow property. Shadows are always rendered
+ * front-back, i.e. the first shadow specified is on top of the others, so they may
+ * overlap other boxes or other shadows.
+ * </para>
+ * </refsect2>
+ * <refsect2 id="gtkcssprovider-border-image">
* <title>Border images</title>
* <para>
- * Images can be used in 'slices' for the purpose of creating scalable
- * borders.
+ * Images and gradients can also be used in slices for the purpose of creating
+ * scalable borders.
+ * For more information, see the CSS3 documentation for the border-image property,
+ * which can be found <ulink url="http://www.w3.org/TR/css3-background/#border-images">here</ulink>.
* </para>
* <inlinegraphic fileref="slices.png" format="PNG"/>
* <para>
- * The syntax for specifying border images of this kind is:
- * <literallayout>url(@path) @top @right @bottom @left [repeat|stretch]? [repeat|stretch]?</literallayout>
- * The sizes of the 'cut off' portions are specified
- * with the @top, @right, @bottom and @left parameters.
- * The 'middle' sections can be repeated or stretched to create
- * the desired effect, by adding the 'repeat' or 'stretch' options after
- * the dimensions. If two options are specified, the first one affects
+ * The parameters of the slicing process are controlled by
+ * four separate properties. Note that you can use the
+ * <literallayout>border-image</literallayout> shorthand property
+ * to set values for the three properties at the same time.
+ * </para>
+ * <para>
+ * <literallayout>border-image-source: url(@path)
+ * (or border-image-source: -gtk-gradient(...))</literallayout>:
+ * Specifies the source of the border image, and it can either
+ * be an URL or a gradient (see above).
+ * </para>
+ * <para>
+ * <literallayout>border-image-slice: @top @right @bottom @left</literallayout>
+ * The sizes specified by the @top, @right, @bottom and @left parameters
+ * are the offsets, in pixels, from the relevant edge where the image
+ * should be "cut off" to build the slices used for the rendering
+ * of the border.
+ * </para>
+ * <para>
+ * <literallayout>border-image-width: @top @right @bottom @left</literallayout>
+ * The sizes specified by the @top, @right, @bottom and @left parameters
+ * are inward distances from the border box edge, used to specify the
+ * rendered size of each slice determined by border-image-slice.
+ * If this property is not specified, the values of border-width will
+ * be used as a fallback.
+ * </para>
+ * <para>
+ * <literallayout>border-image-repeat: [stretch|repeat|round|space] ?
+ * [stretch|repeat|round|space]</literallayout>
+ * Specifies how the image slices should be rendered in the area
+ * outlined by border-width.
+ * The default (stretch) is to resize the slice to fill in the whole
+ * allocated area.
+ * If the value of this property is 'repeat', the image slice
+ * will be tiled to fill the area.
+ * If the value of this property is 'round', the image slice will
+ * be tiled to fill the area, and scaled to fit it exactly
+ * a whole number of times.
+ * If the value of this property is 'space', the image slice will
+ * be tiled to fill the area, and if it doesn't fit it exactly a whole
+ * number of times, the extra space is distributed as padding around
+ * the slices.
+ * If two options are specified, the first one affects
* the horizontal behaviour and the second one the vertical behaviour.
* If only one option is specified, it affects both.
* </para>
* map intuitively in a widget based environment).
* </para>
* <para>
- * There is also a difference in shorthand properties, for
- * example in common CSS it is fine to define a font through
- * the different @font-family, @font-style, @font-size
- * properties, meanwhile in GTK+'s CSS only the canonical
- * @font property is supported.
- * </para>
- * <para>
* The currently supported properties are:
* </para>
* <informaltable>
* <row>
* <entry>background-color</entry>
* <entry morerows="2">color (see above)</entry>
- * <entry morerows="2">#GdkRGBA</entry>
- * <entry morerows="2"><literallayout>background-color: #fff;
+ * <entry morerows="7">#GdkRGBA</entry>
+ * <entry morerows="7"><literallayout>background-color: #fff;
* color: &color1;
* background-color: shade (&color1, 0.5);
* color: mix (&color1, #f0f, 0.8);</literallayout>
* <entry>color</entry>
* </row>
* <row>
+ * <entry>border-top-color</entry>
+ * <entry morerows="4">transparent|color (see above)</entry>
+ * </row>
+ * <row>
+ * <entry>border-right-color</entry>
+ * </row>
+ * <row>
+ * <entry>border-bottom-color</entry>
+ * </row>
+ * <row>
+ * <entry>border-left-color</entry>
+ * </row>
+ * <row>
* <entry>border-color</entry>
+ * <entry>[transparent|color]{1,4}</entry>
+ * </row>
+ * <row>
+ * <entry>font-family</entry>
+ * <entry>@family [, @family]*</entry>
+ * <entry>#gchararray</entry>
+ * <entry>font-family: Sans, Arial;</entry>
+ * </row>
+ * <row>
+ * <entry>font-style</entry>
+ * <entry>[normal|oblique|italic]</entry>
+ * <entry>#PANGO_TYPE_STYLE</entry>
+ * <entry>font-style: italic;</entry>
+ * </row>
+ * <row>
+ * <entry>font-variant</entry>
+ * <entry>[normal|small-caps]</entry>
+ * <entry>#PANGO_TYPE_VARIANT</entry>
+ * <entry>font-variant: normal;</entry>
+ * </row>
+ * <row>
+ * <entry>font-weight</entry>
+ * <entry>[normal|bold|bolder|lighter|100|200|300|400|500|600|700|800|900]</entry>
+ * <entry>#PANGO_TYPE_WEIGHT</entry>
+ * <entry>font-weight: bold;</entry>
+ * </row>
+ * <row>
+ * <entry>font-size</entry>
+ * <entry>Font size in point</entry>
+ * <entry>#gint</entry>
+ * <entry>font-size: 13;</entry>
* </row>
* <row>
* <entry>font</entry>
* <entry>font: Sans 15;</entry>
* </row>
* <row>
+ * <entry>margin-top</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>margin-top: 0;</entry>
+ * </row>
+ * <row>
+ * <entry>margin-left</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>margin-left: 1;</entry>
+ * </row>
+ * <row>
+ * <entry>margin-bottom</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>margin-bottom: 2;</entry>
+ * </row>
+ * <row>
+ * <entry>margin-right</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>margin-right: 4;</entry>
+ * </row>
+ * <row>
* <entry>margin</entry>
* <entry morerows="1"><literallayout>@width
* @vertical_width @horizontal_width
* </entry>
* </row>
* <row>
+ * <entry>padding-top</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>padding-top: 5;</entry>
+ * </row>
+ * <row>
+ * <entry>padding-left</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>padding-left: 5;</entry>
+ * </row>
+ * <row>
+ * <entry>padding-bottom</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>padding-bottom: 5;</entry>
+ * </row>
+ * <row>
+ * <entry>padding-right</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>padding-right: 5;</entry>
+ * </row>
+ * <row>
* <entry>padding</entry>
* </row>
* <row>
* </entry>
* </row>
* <row>
- * <entry>border-width</entry>
+ * <entry>background-repeat</entry>
+ * <entry>[repeat|no-repeat]</entry>
+ * <entry>internal</entry>
+ * <entry><literallayout>background-repeat: no-repeat;</literallayout>
+ * If not specified, the style doesn't respect the CSS3
+ * specification, since the background will be
+ * stretched to fill the area.
+ * </entry>
+ * </row>
+ * <row>
+ * <entry>border-top-width</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>border-top-width: 5;</entry>
+ * </row>
+ * <row>
+ * <entry>border-left-width</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>border-left-width: 5;</entry>
+ * </row>
+ * <row>
+ * <entry>border-bottom-width</entry>
+ * <entry>integer</entry>
+ * <entry>#gint</entry>
+ * <entry>border-bottom-width: 5;</entry>
+ * </row>
+ * <row>
+ * <entry>border-right-width</entry>
* <entry>integer</entry>
* <entry>#gint</entry>
- * <entry>border-width: 5;</entry>
+ * <entry>border-right-width: 5;</entry>
+ * </row>
+ * <row>
+ * <entry>border-width</entry>
+ * <entry morerows="1">#GtkBorder</entry>
+ * <entry morerows="1"><literallayout>border-width: 1;
+ * border-width: 1 2;
+ * border-width: 1 2 3;
+ * border-width: 1 2 3 5;</literallayout>
+ * </entry>
* </row>
* <row>
* <entry>border-radius</entry>
* </entry>
* </row>
* <row>
+ * <entry>text-shadow</entry>
+ * <entry>shadow list (see above)</entry>
+ * <entry>internal use only</entry>
+ * <entry><literallayout>text-shadow: 1 1 0 blue, -4 -4 red;</literallayout></entry>
+ * </row>
+ * <row>
* <entry>transition</entry>
* <entry>transition (see above)</entry>
* <entry>internal use only</entry>
* </refsect2>
*/
-typedef struct SelectorElement SelectorElement;
-typedef struct SelectorPath SelectorPath;
-typedef struct SelectorStyleInfo SelectorStyleInfo;
-typedef struct _GtkCssScannerPrivate GtkCssScannerPrivate;
-typedef enum SelectorElementType SelectorElementType;
-typedef enum CombinatorType CombinatorType;
+typedef struct GtkCssRuleset GtkCssRuleset;
+typedef struct _GtkCssScanner GtkCssScanner;
+typedef struct _PropertyValue PropertyValue;
+typedef struct _WidgetPropertyValue WidgetPropertyValue;
typedef enum ParserScope ParserScope;
typedef enum ParserSymbol ParserSymbol;
-enum SelectorElementType {
- SELECTOR_TYPE_NAME,
- SELECTOR_NAME,
- SELECTOR_GTYPE,
- SELECTOR_REGION,
- SELECTOR_CLASS,
- SELECTOR_GLOB
-};
-
-enum CombinatorType {
- COMBINATOR_DESCENDANT, /* No direct relation needed */
- COMBINATOR_CHILD /* Direct child */
+struct _PropertyValue {
+ GtkCssStyleProperty *property;
+ GtkCssValue *value;
+ GtkCssSection *section;
};
-struct SelectorElement
-{
- SelectorElementType elem_type;
- CombinatorType combinator;
-
- union
- {
- GQuark name;
- GType type;
-
- struct
- {
- GQuark name;
- GtkRegionFlags flags;
- } region;
- };
-};
+struct _WidgetPropertyValue {
+ WidgetPropertyValue *next;
+ char *name;
+ char *value;
-struct SelectorPath
-{
- GSList *elements;
- GtkStateFlags state;
- guint ref_count;
+ GtkCssSection *section;
};
-struct SelectorStyleInfo
+struct GtkCssRuleset
{
- SelectorPath *path;
- GHashTable *style;
+ GtkCssSelector *selector;
+ GtkCssSelectorTree *selector_match;
+ WidgetPropertyValue *widget_style;
+ PropertyValue *styles;
+ GtkBitmask *set_styles;
+ guint n_styles;
+ guint owns_styles : 1;
+ guint owns_widget_style : 1;
};
-struct _GtkCssScannerPrivate
+struct _GtkCssScanner
{
- GFile *file;
- GFile *base;
+ GtkCssProvider *provider;
+ GtkCssParser *parser;
+ GtkCssSection *section;
+ GtkCssScanner *parent;
GSList *state;
- GSList *cur_selectors;
- GHashTable *cur_properties;
};
struct _GtkCssProviderPrivate
GScanner *scanner;
GHashTable *symbolic_colors;
+ GHashTable *keyframes;
- GPtrArray *selectors_info;
-};
-
-enum ParserScope {
- SCOPE_SELECTOR,
- SCOPE_PSEUDO_CLASS,
- SCOPE_NTH_CHILD,
- SCOPE_DECLARATION,
- SCOPE_VALUE,
- SCOPE_BINDING_SET
-};
-
-/* Extend GtkStateType, since these
- * values are also used as symbols
- */
-enum ParserSymbol {
- /* Scope: pseudo-class */
- SYMBOL_NTH_CHILD = GTK_STATE_FOCUSED + 1,
- SYMBOL_FIRST_CHILD,
- SYMBOL_LAST_CHILD,
- SYMBOL_SORTED_CHILD,
-
- /* Scope: nth-child */
- SYMBOL_NTH_CHILD_EVEN,
- SYMBOL_NTH_CHILD_ODD,
- SYMBOL_NTH_CHILD_FIRST,
- SYMBOL_NTH_CHILD_LAST
+ GArray *rulesets;
+ GtkCssSelectorTree *tree;
+ GResource *resource;
};
enum {
LAST_SIGNAL
};
+static gboolean gtk_keep_css_sections = FALSE;
+
static guint css_provider_signals[LAST_SIGNAL] = { 0 };
static void gtk_css_provider_finalize (GObject *object);
static void gtk_css_style_provider_iface_init (GtkStyleProviderIface *iface);
+static void gtk_css_style_provider_private_iface_init (GtkStyleProviderPrivateInterface *iface);
+static void widget_property_value_list_free (WidgetPropertyValue *head);
-static void scanner_apply_scope (GScanner *scanner,
- ParserScope scope);
-static gboolean gtk_css_provider_load_from_path_internal (GtkCssProvider *css_provider,
- const gchar *path,
- gboolean reset,
- GError **error);
+static gboolean
+gtk_css_provider_load_internal (GtkCssProvider *css_provider,
+ GtkCssScanner *scanner,
+ GFile *file,
+ const char *data,
+ GError **error);
GQuark
gtk_css_provider_error_quark (void)
G_DEFINE_TYPE_EXTENDED (GtkCssProvider, gtk_css_provider, G_TYPE_OBJECT, 0,
G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER,
- gtk_css_style_provider_iface_init));
+ gtk_css_style_provider_iface_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER_PRIVATE,
+ gtk_css_style_provider_private_iface_init));
static void
gtk_css_provider_parsing_error (GtkCssProvider *provider,
- const gchar *path,
- guint line,
- guint position,
- const GError * error)
+ GtkCssSection *section,
+ const GError *error)
{
/* Only emit a warning when we have no error handlers. This is our
* default handlers. And in this case erroneous CSS files are a bug
0,
TRUE))
{
- g_warning ("Theme parsing error: %s:%u:%u: %s", path ? path : "<unknown>", line, position, error->message);
+ char *s = _gtk_css_section_to_string (section);
+
+ g_warning ("Theme parsing error: %s: %s",
+ s,
+ error->message);
+
+ g_free (s);
}
}
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ if (g_getenv ("GTK_CSS_DEBUG"))
+ gtk_keep_css_sections = TRUE;
+
/**
* GtkCssProvider::parsing-error:
* @provider: the provider that had a parsing error
- * @path: path to the parsed file or %NULL if the file cannot be
- * identified or the data was not loaded from a file
- * @line: line in the file or data or 0 if unknown
- * @position: offset into the current line or 0 if unknown or the
- * whole line is affected
+ * @section: section the error happened in
* @error: The parsing error
*
* Signals that a parsing error occured. the @path, @line and @position
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkCssProviderClass, parsing_error),
NULL, NULL,
- _gtk_marshal_VOID__STRING_UINT_UINT_BOXED,
- G_TYPE_NONE, 4,
- G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_ERROR);
+ _gtk_marshal_VOID__BOXED_BOXED,
+ G_TYPE_NONE, 2, GTK_TYPE_CSS_SECTION, G_TYPE_ERROR);
object_class->finalize = gtk_css_provider_finalize;
}
static void
-gtk_css_provider_take_error_full (GtkCssProvider *provider,
- GFile *file,
- guint line,
- guint position,
- GError *error)
-{
- char *filename;
-
- if (file)
- filename = g_file_get_path (file);
- else
- filename = NULL;
+gtk_css_ruleset_init_copy (GtkCssRuleset *new,
+ GtkCssRuleset *ruleset,
+ GtkCssSelector *selector)
+{
+ memcpy (new, ruleset, sizeof (GtkCssRuleset));
+
+ new->selector = selector;
+ /* First copy takes over ownership */
+ if (ruleset->owns_styles)
+ ruleset->owns_styles = FALSE;
+ if (ruleset->owns_widget_style)
+ ruleset->owns_widget_style = FALSE;
+ if (new->set_styles)
+ new->set_styles = _gtk_bitmask_copy (new->set_styles);
+}
- g_signal_emit (provider, css_provider_signals[PARSING_ERROR], 0,
- filename, line, position, error);
+static void
+gtk_css_ruleset_clear (GtkCssRuleset *ruleset)
+{
+ if (ruleset->owns_styles)
+ {
+ guint i;
- g_free (filename);
- g_error_free (error);
+ for (i = 0; i < ruleset->n_styles; i++)
+ {
+ _gtk_css_value_unref (ruleset->styles[i].value);
+ ruleset->styles[i].value = NULL;
+ if (ruleset->styles[i].section)
+ gtk_css_section_unref (ruleset->styles[i].section);
+ }
+ g_free (ruleset->styles);
+ }
+ if (ruleset->set_styles)
+ _gtk_bitmask_free (ruleset->set_styles);
+ if (ruleset->owns_widget_style)
+ widget_property_value_list_free (ruleset->widget_style);
+ if (ruleset->selector)
+ _gtk_css_selector_free (ruleset->selector);
+
+ memset (ruleset, 0, sizeof (GtkCssRuleset));
}
-static SelectorPath *
-selector_path_new (void)
+static WidgetPropertyValue *
+widget_property_value_new (char *name, GtkCssSection *section)
{
- SelectorPath *path;
+ WidgetPropertyValue *value;
- path = g_slice_new0 (SelectorPath);
- path->ref_count = 1;
+ value = g_slice_new0 (WidgetPropertyValue);
- return path;
+ value->name = name;
+ if (gtk_keep_css_sections)
+ value->section = gtk_css_section_ref (section);
+
+ return value;
}
-static SelectorPath *
-selector_path_ref (SelectorPath *path)
+static void
+widget_property_value_free (WidgetPropertyValue *value)
{
- path->ref_count++;
- return path;
+ g_free (value->value);
+ g_free (value->name);
+ if (value->section)
+ gtk_css_section_unref (value->section);
+
+ g_slice_free (WidgetPropertyValue, value);
}
static void
-selector_path_unref (SelectorPath *path)
+widget_property_value_list_free (WidgetPropertyValue *head)
+{
+ WidgetPropertyValue *l, *next;
+ for (l = head; l != NULL; l = next)
+ {
+ next = l->next;
+ widget_property_value_free (l);
+ }
+}
+
+static WidgetPropertyValue *
+widget_property_value_list_remove_name (WidgetPropertyValue *head, const char *name)
{
- path->ref_count--;
+ WidgetPropertyValue *l, **last;
- if (path->ref_count > 0)
- return;
+ last = &head;
- while (path->elements)
+ for (l = head; l != NULL; l = l->next)
{
- g_slice_free (SelectorElement, path->elements->data);
- path->elements = g_slist_delete_link (path->elements, path->elements);
+ if (strcmp (l->name, name) == 0)
+ {
+ *last = l->next;
+ widget_property_value_free (l);
+ break;
+ }
+
+ last = &l->next;
}
- g_slice_free (SelectorPath, path);
+ return head;
+}
+
+static void
+gtk_css_ruleset_add_style (GtkCssRuleset *ruleset,
+ char *name,
+ WidgetPropertyValue *value)
+{
+ value->next = widget_property_value_list_remove_name (ruleset->widget_style, name);
+ ruleset->widget_style = value;
+ ruleset->owns_widget_style = TRUE;
}
static void
-selector_path_prepend_type (SelectorPath *path,
- const gchar *type_name)
+gtk_css_ruleset_add (GtkCssRuleset *ruleset,
+ GtkCssStyleProperty *property,
+ GtkCssValue *value,
+ GtkCssSection *section)
{
- SelectorElement *elem;
- GType type;
+ guint i;
- elem = g_slice_new (SelectorElement);
- elem->combinator = COMBINATOR_DESCENDANT;
- type = g_type_from_name (type_name);
+ g_return_if_fail (ruleset->owns_styles || ruleset->n_styles == 0);
- if (type == G_TYPE_INVALID)
+ if (ruleset->set_styles == NULL)
+ ruleset->set_styles = _gtk_bitmask_new ();
+
+ ruleset->set_styles = _gtk_bitmask_set (ruleset->set_styles,
+ _gtk_css_style_property_get_id (property),
+ TRUE);
+
+ ruleset->owns_styles = TRUE;
+
+ for (i = 0; i < ruleset->n_styles; i++)
{
- elem->elem_type = SELECTOR_TYPE_NAME;
- elem->name = g_quark_from_string (type_name);
+ if (ruleset->styles[i].property == property)
+ {
+ _gtk_css_value_unref (ruleset->styles[i].value);
+ ruleset->styles[i].value = NULL;
+ if (ruleset->styles[i].section)
+ gtk_css_section_unref (ruleset->styles[i].section);
+ break;
+ }
}
- else
+ if (i == ruleset->n_styles)
{
- elem->elem_type = SELECTOR_GTYPE;
- elem->type = type;
+ ruleset->n_styles++;
+ ruleset->styles = g_realloc (ruleset->styles, ruleset->n_styles * sizeof (PropertyValue));
+ ruleset->styles[i].value = NULL;
+ ruleset->styles[i].property = property;
}
- path->elements = g_slist_prepend (path->elements, elem);
+ ruleset->styles[i].value = value;
+ if (gtk_keep_css_sections)
+ ruleset->styles[i].section = gtk_css_section_ref (section);
+ else
+ ruleset->styles[i].section = NULL;
}
static void
-selector_path_prepend_glob (SelectorPath *path)
+gtk_css_scanner_destroy (GtkCssScanner *scanner)
{
- SelectorElement *elem;
+ if (scanner->section)
+ gtk_css_section_unref (scanner->section);
+ g_object_unref (scanner->provider);
+ _gtk_css_parser_free (scanner->parser);
- elem = g_slice_new (SelectorElement);
- elem->elem_type = SELECTOR_GLOB;
- elem->combinator = COMBINATOR_DESCENDANT;
-
- path->elements = g_slist_prepend (path->elements, elem);
+ g_slice_free (GtkCssScanner, scanner);
}
static void
-selector_path_prepend_region (SelectorPath *path,
- const gchar *name,
- GtkRegionFlags flags)
+gtk_css_provider_emit_error (GtkCssProvider *provider,
+ GtkCssScanner *scanner,
+ const GError *error)
{
- SelectorElement *elem;
-
- elem = g_slice_new (SelectorElement);
- elem->combinator = COMBINATOR_DESCENDANT;
- elem->elem_type = SELECTOR_REGION;
+ g_signal_emit (provider, css_provider_signals[PARSING_ERROR], 0,
+ scanner != NULL ? scanner->section : NULL, error);
+}
- elem->region.name = g_quark_from_string (name);
- elem->region.flags = flags;
+static void
+gtk_css_scanner_parser_error (GtkCssParser *parser,
+ const GError *error,
+ gpointer user_data)
+{
+ GtkCssScanner *scanner = user_data;
- path->elements = g_slist_prepend (path->elements, elem);
+ gtk_css_provider_emit_error (scanner->provider,
+ scanner,
+ error);
}
-static void
-selector_path_prepend_name (SelectorPath *path,
- const gchar *name)
+static GtkCssScanner *
+gtk_css_scanner_new (GtkCssProvider *provider,
+ GtkCssScanner *parent,
+ GtkCssSection *section,
+ GFile *file,
+ const gchar *text)
{
- SelectorElement *elem;
+ GtkCssScanner *scanner;
+
+ scanner = g_slice_new0 (GtkCssScanner);
- elem = g_slice_new (SelectorElement);
- elem->combinator = COMBINATOR_DESCENDANT;
- elem->elem_type = SELECTOR_NAME;
+ g_object_ref (provider);
+ scanner->provider = provider;
+ scanner->parent = parent;
+ if (section)
+ scanner->section = gtk_css_section_ref (section);
- elem->name = g_quark_from_string (name);
+ scanner->parser = _gtk_css_parser_new (text,
+ file,
+ gtk_css_scanner_parser_error,
+ scanner);
- path->elements = g_slist_prepend (path->elements, elem);
+ return scanner;
}
-static void
-selector_path_prepend_class (SelectorPath *path,
- const gchar *name)
+static gboolean
+gtk_css_scanner_would_recurse (GtkCssScanner *scanner,
+ GFile *file)
{
- SelectorElement *elem;
-
- elem = g_slice_new (SelectorElement);
- elem->combinator = COMBINATOR_DESCENDANT;
- elem->elem_type = SELECTOR_CLASS;
+ while (scanner)
+ {
+ GFile *parser_file = _gtk_css_parser_get_file (scanner->parser);
+ if (parser_file && g_file_equal (parser_file, file))
+ return TRUE;
- elem->name = g_quark_from_string (name);
+ scanner = scanner->parent;
+ }
- path->elements = g_slist_prepend (path->elements, elem);
+ return FALSE;
}
static void
-selector_path_prepend_combinator (SelectorPath *path,
- CombinatorType combinator)
+gtk_css_scanner_push_section (GtkCssScanner *scanner,
+ GtkCssSectionType section_type)
{
- SelectorElement *elem;
+ GtkCssSection *section;
- g_assert (path->elements != NULL);
+ section = _gtk_css_section_new (scanner->section,
+ section_type,
+ scanner->parser);
- /* It is actually stored in the last element */
- elem = path->elements->data;
- elem->combinator = combinator;
+ if (scanner->section)
+ gtk_css_section_unref (scanner->section);
+ scanner->section = section;
}
-static gint
-selector_path_depth (SelectorPath *path)
+static void
+gtk_css_scanner_pop_section (GtkCssScanner *scanner,
+ GtkCssSectionType check_type)
{
- return g_slist_length (path->elements);
-}
+ GtkCssSection *parent;
+
+ g_assert (gtk_css_section_get_section_type (scanner->section) == check_type);
-static SelectorStyleInfo *
-selector_style_info_new (SelectorPath *path)
-{
- SelectorStyleInfo *info;
+ parent = gtk_css_section_get_parent (scanner->section);
+ if (parent)
+ gtk_css_section_ref (parent);
- info = g_slice_new0 (SelectorStyleInfo);
- info->path = selector_path_ref (path);
+ _gtk_css_section_end (scanner->section);
+ gtk_css_section_unref (scanner->section);
- return info;
+ scanner->section = parent;
}
static void
-selector_style_info_free (SelectorStyleInfo *info)
+gtk_css_provider_init (GtkCssProvider *css_provider)
{
- if (info->style)
- g_hash_table_unref (info->style);
+ GtkCssProviderPrivate *priv;
+
+ priv = css_provider->priv = G_TYPE_INSTANCE_GET_PRIVATE (css_provider,
+ GTK_TYPE_CSS_PROVIDER,
+ GtkCssProviderPrivate);
- if (info->path)
- selector_path_unref (info->path);
+ priv->rulesets = g_array_new (FALSE, FALSE, sizeof (GtkCssRuleset));
- g_slice_free (SelectorStyleInfo, info);
+ priv->symbolic_colors = g_hash_table_new_full (g_str_hash, g_str_equal,
+ (GDestroyNotify) g_free,
+ (GDestroyNotify) _gtk_css_value_unref);
+ priv->keyframes = g_hash_table_new_full (g_str_hash, g_str_equal,
+ (GDestroyNotify) g_free,
+ (GDestroyNotify) _gtk_css_value_unref);
}
static void
-selector_style_info_set_style (SelectorStyleInfo *info,
- GHashTable *style)
+verify_tree_match_results (GtkCssProvider *provider,
+ const GtkCssMatcher *matcher,
+ GPtrArray *tree_rules)
{
- if (info->style)
- g_hash_table_unref (info->style);
+#ifdef VERIFY_TREE
+ GtkCssProviderPrivate *priv = provider->priv;
+ GtkCssRuleset *ruleset;
+ gboolean should_match;
+ int i, j;
- if (style)
- info->style = g_hash_table_ref (style);
- else
- info->style = NULL;
+ for (i = 0; i < priv->rulesets->len; i++)
+ {
+ gboolean found = FALSE;
+
+ ruleset = &g_array_index (priv->rulesets, GtkCssRuleset, i);
+
+ for (j = 0; j < tree_rules->len; j++)
+ {
+ if (ruleset == tree_rules->pdata[j])
+ {
+ found = TRUE;
+ break;
+ }
+ }
+ should_match = _gtk_css_selector_matches (ruleset->selector, matcher);
+ if (found != !!should_match)
+ {
+ g_error ("expected rule '%s' to %s, but it %s\n",
+ _gtk_css_selector_to_string (ruleset->selector),
+ should_match ? "match" : "not match",
+ found ? "matched" : "didn't match");
+ }
+ }
+#endif
}
static void
-property_value_free (GValue *value)
+verify_tree_get_change_results (GtkCssProvider *provider,
+ const GtkCssMatcher *matcher,
+ GtkCssChange change)
{
- if (G_IS_VALUE (value))
- g_value_unset (value);
-
- g_slice_free (GValue, value);
+#ifdef VERIFY_TREE
+ {
+ GtkCssChange verify_change = 0;
+ GPtrArray *tree_rules;
+ int i;
+
+ tree_rules = _gtk_css_selector_tree_match_all (provider->priv->tree, matcher);
+ verify_tree_match_results (provider, matcher, tree_rules);
+
+ for (i = tree_rules->len - 1; i >= 0; i--)
+ {
+ GtkCssRuleset *ruleset;
+
+ ruleset = tree_rules->pdata[i];
+
+ verify_change |= _gtk_css_selector_tree_match_get_change (ruleset->selector_match);
+ }
+
+ if (change != verify_change)
+ {
+ GString *s;
+
+ s = g_string_new ("");
+ g_string_append_printf (s, "expected change 0x%x, but it was 0x%x", verify_change, change);
+ if ((change & ~verify_change) != 0)
+ g_string_append_printf (s, ", unexpectedly set: 0x%x", change & ~verify_change);
+ if ((~change & verify_change) != 0)
+ g_string_append_printf (s, ", unexpectedly no set: 0x%x", ~change & verify_change);
+ g_warning (s->str);
+ g_string_free (s, TRUE);
+ }
+
+ g_ptr_array_free (tree_rules, TRUE);
+ }
+#endif
}
-static void
-gtk_css_scanner_reset (GScanner *scanner)
-{
- GtkCssScannerPrivate *priv = scanner->user_data;
- g_slist_free (priv->state);
- priv->state = NULL;
+static gboolean
+gtk_css_provider_get_style_property (GtkStyleProvider *provider,
+ GtkWidgetPath *path,
+ GtkStateFlags state,
+ GParamSpec *pspec,
+ GValue *value)
+{
+ GtkCssProvider *css_provider = GTK_CSS_PROVIDER (provider);
+ GtkCssProviderPrivate *priv = css_provider->priv;
+ WidgetPropertyValue *val;
+ GPtrArray *tree_rules;
+ GtkCssMatcher matcher;
+ gboolean found = FALSE;
+ gchar *prop_name;
+ gint i;
- g_slist_foreach (priv->cur_selectors, (GFunc) selector_path_unref, NULL);
- g_slist_free (priv->cur_selectors);
- priv->cur_selectors = NULL;
+ if (!_gtk_css_matcher_init (&matcher, path, state))
+ return FALSE;
- if (priv->cur_properties)
- g_hash_table_unref (priv->cur_properties);
+ tree_rules = _gtk_css_selector_tree_match_all (priv->tree, &matcher);
+ verify_tree_match_results (css_provider, &matcher, tree_rules);
- priv->cur_properties = g_hash_table_new_full (g_str_hash,
- g_str_equal,
- (GDestroyNotify) g_free,
- (GDestroyNotify) property_value_free);
+ prop_name = g_strdup_printf ("-%s-%s",
+ g_type_name (pspec->owner_type),
+ pspec->name);
- scanner_apply_scope (scanner, SCOPE_SELECTOR);
-}
+ for (i = tree_rules->len - 1; i >= 0; i--)
+ {
+ GtkCssRuleset *ruleset = tree_rules->pdata[i];
-static void
-gtk_css_scanner_destroy (GScanner *scanner)
-{
- GtkCssScannerPrivate *priv = scanner->user_data;
+ if (ruleset->widget_style == NULL)
+ continue;
- gtk_css_scanner_reset (scanner);
+ for (val = ruleset->widget_style; val != NULL; val = val->next)
+ {
+ if (strcmp (val->name, prop_name) == 0)
+ {
+ GtkCssScanner *scanner;
- if (priv->file)
- g_object_unref (priv->file);
- g_hash_table_destroy (priv->cur_properties);
- g_slice_free (GtkCssScannerPrivate, priv);
-
- g_scanner_destroy (scanner);
-}
+ scanner = gtk_css_scanner_new (css_provider,
+ NULL,
+ val->section,
+ val->section != NULL ? gtk_css_section_get_file (val->section) : NULL,
+ val->value);
-static GScanner *
-gtk_css_scanner_new (GFile *file,
- const gchar *data,
- gsize length)
-{
- GtkCssScannerPrivate *priv;
- GScanner *scanner;
+ found = _gtk_css_style_parse_value (value,
+ scanner->parser);
- scanner = g_scanner_new (NULL);
+ gtk_css_scanner_destroy (scanner);
- priv = scanner->user_data = g_slice_new0 (GtkCssScannerPrivate);
+ break;
+ }
+ }
- if (file)
- {
- priv->file = g_object_ref (file);
- priv->base = g_file_get_parent (file);
- }
- else
- {
- char *dir = g_get_current_dir ();
- priv->base = g_file_new_for_path (dir);
- g_free (dir);
+ if (found)
+ break;
}
- priv->cur_properties = g_hash_table_new_full (g_str_hash,
- g_str_equal,
- (GDestroyNotify) g_free,
- (GDestroyNotify) property_value_free);
-
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "active", GUINT_TO_POINTER (GTK_STATE_ACTIVE));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "prelight", GUINT_TO_POINTER (GTK_STATE_PRELIGHT));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "hover", GUINT_TO_POINTER (GTK_STATE_PRELIGHT));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "selected", GUINT_TO_POINTER (GTK_STATE_SELECTED));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "insensitive", GUINT_TO_POINTER (GTK_STATE_INSENSITIVE));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "inconsistent", GUINT_TO_POINTER (GTK_STATE_INCONSISTENT));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "focused", GUINT_TO_POINTER (GTK_STATE_FOCUSED));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "focus", GUINT_TO_POINTER (GTK_STATE_FOCUSED));
-
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "nth-child", GUINT_TO_POINTER (SYMBOL_NTH_CHILD));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "first-child", GUINT_TO_POINTER (SYMBOL_FIRST_CHILD));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "last-child", GUINT_TO_POINTER (SYMBOL_LAST_CHILD));
- g_scanner_scope_add_symbol (scanner, SCOPE_PSEUDO_CLASS, "sorted", GUINT_TO_POINTER (SYMBOL_SORTED_CHILD));
-
- g_scanner_scope_add_symbol (scanner, SCOPE_NTH_CHILD, "even", GUINT_TO_POINTER (SYMBOL_NTH_CHILD_EVEN));
- g_scanner_scope_add_symbol (scanner, SCOPE_NTH_CHILD, "odd", GUINT_TO_POINTER (SYMBOL_NTH_CHILD_ODD));
- g_scanner_scope_add_symbol (scanner, SCOPE_NTH_CHILD, "first", GUINT_TO_POINTER (SYMBOL_NTH_CHILD_FIRST));
- g_scanner_scope_add_symbol (scanner, SCOPE_NTH_CHILD, "last", GUINT_TO_POINTER (SYMBOL_NTH_CHILD_LAST));
+ g_free (prop_name);
+ g_ptr_array_free (tree_rules, TRUE);
- scanner_apply_scope (scanner, SCOPE_SELECTOR);
+ return found;
+}
- if (length > G_MAXUINT32)
- g_warning ("CSS file too large, truncating");
+static void
+gtk_css_style_provider_iface_init (GtkStyleProviderIface *iface)
+{
+ iface->get_style_property = gtk_css_provider_get_style_property;
+}
- g_scanner_input_text (scanner, data, length);
+static GtkCssValue *
+gtk_css_style_provider_get_color (GtkStyleProviderPrivate *provider,
+ const char *name)
+{
+ GtkCssProvider *css_provider = GTK_CSS_PROVIDER (provider);
- return scanner;
+ return g_hash_table_lookup (css_provider->priv->symbolic_colors, name);
}
-static GFile *
-gtk_css_scanner_get_base_url (GScanner *scanner)
+static GtkCssKeyframes *
+gtk_css_style_provider_get_keyframes (GtkStyleProviderPrivate *provider,
+ const char *name)
{
- GtkCssScannerPrivate *priv = scanner->user_data;
+ GtkCssProvider *css_provider = GTK_CSS_PROVIDER (provider);
- return priv->base;
+ return g_hash_table_lookup (css_provider->priv->keyframes, name);
}
static void
-gtk_css_provider_init (GtkCssProvider *css_provider)
+gtk_css_style_provider_lookup (GtkStyleProviderPrivate *provider,
+ const GtkCssMatcher *matcher,
+ GtkCssLookup *lookup)
{
+ GtkCssProvider *css_provider;
GtkCssProviderPrivate *priv;
+ GtkCssRuleset *ruleset;
+ guint j;
+ int i;
+ GPtrArray *tree_rules;
- priv = css_provider->priv = G_TYPE_INSTANCE_GET_PRIVATE (css_provider,
- GTK_TYPE_CSS_PROVIDER,
- GtkCssProviderPrivate);
+ css_provider = GTK_CSS_PROVIDER (provider);
+ priv = css_provider->priv;
- priv->selectors_info = g_ptr_array_new_with_free_func ((GDestroyNotify) selector_style_info_free);
+ tree_rules = _gtk_css_selector_tree_match_all (priv->tree, matcher);
+ verify_tree_match_results (css_provider, matcher, tree_rules);
- priv->symbolic_colors = g_hash_table_new_full (g_str_hash, g_str_equal,
- (GDestroyNotify) g_free,
- (GDestroyNotify) gtk_symbolic_color_unref);
-}
+ for (i = tree_rules->len - 1; i >= 0; i--)
+ {
+ ruleset = tree_rules->pdata[i];
-typedef struct ComparePathData ComparePathData;
+ if (ruleset->styles == NULL)
+ continue;
-struct ComparePathData
-{
- guint64 score;
- SelectorPath *path;
- GSList *iter;
-};
+ if (!_gtk_bitmask_intersects (_gtk_css_lookup_get_missing (lookup),
+ ruleset->set_styles))
+ continue;
-static gboolean
-compare_selector_element (GtkWidgetPath *path,
- guint index,
- SelectorElement *elem,
- guint8 *score)
-{
- *score = 0;
-
- if (elem->elem_type == SELECTOR_TYPE_NAME)
- {
- const gchar *type_name;
- GType resolved_type;
-
- /* Resolve the type name */
- type_name = g_quark_to_string (elem->name);
- resolved_type = g_type_from_name (type_name);
-
- if (resolved_type == G_TYPE_INVALID)
- {
- /* Type couldn't be resolved, so the selector
- * clearly doesn't affect the given widget path
- */
- return FALSE;
- }
-
- elem->elem_type = SELECTOR_GTYPE;
- elem->type = resolved_type;
- }
-
- if (elem->elem_type == SELECTOR_GTYPE)
- {
- GType type;
-
- type = gtk_widget_path_iter_get_object_type (path, index);
-
- if (!g_type_is_a (type, elem->type))
- return FALSE;
-
- if (type == elem->type)
- *score |= 0xF;
- else
- {
- guint diff = g_type_depth (type) - g_type_depth (elem->type);
-
- if (G_UNLIKELY (diff > 0xE))
- {
- g_warning ("Hierarchy is higher than expected.");
- diff = 0xE;
- }
-
- *score = 0XF - diff;
- }
-
- return TRUE;
- }
- else if (elem->elem_type == SELECTOR_REGION)
- {
- GtkRegionFlags flags;
-
- if (!gtk_widget_path_iter_has_qregion (path, index,
- elem->region.name,
- &flags))
- return FALSE;
-
- if (elem->region.flags != 0 &&
- (flags & elem->region.flags) == 0)
- return FALSE;
-
- *score = 0xF;
- return TRUE;
- }
- else if (elem->elem_type == SELECTOR_GLOB)
- {
- /* Treat as lowest matching type */
- *score = 1;
- return TRUE;
- }
- else if (elem->elem_type == SELECTOR_NAME)
- {
- if (!gtk_widget_path_iter_has_qname (path, index, elem->name))
- return FALSE;
-
- *score = 0xF;
- return TRUE;
- }
- else if (elem->elem_type == SELECTOR_CLASS)
- {
- if (!gtk_widget_path_iter_has_qclass (path, index, elem->name))
- return FALSE;
-
- *score = 0xF;
- return TRUE;
- }
-
- return FALSE;
-}
-
-static guint64
-compare_selector (GtkWidgetPath *path,
- SelectorPath *selector)
-{
- GSList *elements = selector->elements;
- gboolean match = TRUE, first = TRUE, first_match = FALSE;
- guint64 score = 0;
- gint i;
-
- i = gtk_widget_path_length (path) - 1;
-
- while (elements && match && i >= 0)
- {
- SelectorElement *elem;
- guint8 elem_score;
-
- elem = elements->data;
-
- match = compare_selector_element (path, i, elem, &elem_score);
-
- if (match && first)
- first_match = TRUE;
-
- /* Only move on to the next index if there is no match
- * with the current element (whether to continue or not
- * handled right after in the combinator check), or a
- * GType or glob has just been matched.
- *
- * Region and widget names do not trigger this because
- * the next element in the selector path could also be
- * related to the same index.
- */
- if (!match ||
- (elem->elem_type == SELECTOR_GTYPE ||
- elem->elem_type == SELECTOR_GLOB))
- i--;
-
- if (!match &&
- elem->elem_type != SELECTOR_TYPE_NAME &&
- elem->combinator == COMBINATOR_DESCENDANT)
+ for (j = 0; j < ruleset->n_styles; j++)
{
- /* With descendant combinators there may
- * be intermediate chidren in the hierarchy
- */
- match = TRUE;
- }
- else if (match)
- elements = elements->next;
+ GtkCssStyleProperty *prop = ruleset->styles[j].property;
+ guint id = _gtk_css_style_property_get_id (prop);
- if (match)
- {
- /* Only 4 bits are actually used */
- score <<= 4;
- score |= elem_score;
- }
-
- first = FALSE;
- }
-
- /* If there are pending selector
- * elements to compare, it's not
- * a match.
- */
- if (elements)
- match = FALSE;
-
- if (!match)
- score = 0;
- else if (first_match)
- {
- /* Assign more weight to these selectors
- * that matched right from the first element.
- */
- score <<= 4;
- }
-
- return score;
-}
-
-typedef struct StylePriorityInfo StylePriorityInfo;
-
-struct StylePriorityInfo
-{
- guint64 score;
- GHashTable *style;
- GtkStateFlags state;
-};
-
-static GArray *
-css_provider_get_selectors (GtkCssProvider *css_provider,
- GtkWidgetPath *path)
-{
- GtkCssProviderPrivate *priv;
- GArray *priority_info;
- guint i, j;
-
- priv = css_provider->priv;
- priority_info = g_array_new (FALSE, FALSE, sizeof (StylePriorityInfo));
-
- for (i = 0; i < priv->selectors_info->len; i++)
- {
- SelectorStyleInfo *info;
- StylePriorityInfo new;
- gboolean added = FALSE;
- guint64 score;
-
- info = g_ptr_array_index (priv->selectors_info, i);
- score = compare_selector (path, info->path);
-
- if (score <= 0)
- continue;
-
- new.score = score;
- new.style = info->style;
- new.state = info->path->state;
-
- for (j = 0; j < priority_info->len; j++)
- {
- StylePriorityInfo *cur;
-
- cur = &g_array_index (priority_info, StylePriorityInfo, j);
+ if (!_gtk_css_lookup_is_missing (lookup, id))
+ continue;
- if (cur->score > new.score)
- {
- g_array_insert_val (priority_info, j, new);
- added = TRUE;
- break;
- }
+ _gtk_css_lookup_set (lookup,
+ id,
+ ruleset->styles[j].section,
+ ruleset->styles[j].value);
}
- if (!added)
- g_array_append_val (priority_info, new);
+ if (_gtk_bitmask_is_empty (_gtk_css_lookup_get_missing (lookup)))
+ break;
}
- return priority_info;
-}
-
-static void
-css_provider_dump_symbolic_colors (GtkCssProvider *css_provider,
- GtkStyleProperties *props)
-{
- GtkCssProviderPrivate *priv;
- GHashTableIter iter;
- gpointer key, value;
-
- priv = css_provider->priv;
- g_hash_table_iter_init (&iter, priv->symbolic_colors);
-
- while (g_hash_table_iter_next (&iter, &key, &value))
- {
- const gchar *name;
- GtkSymbolicColor *color;
-
- name = key;
- color = value;
-
- gtk_style_properties_map_color (props, name, color);
- }
+ g_ptr_array_free (tree_rules, TRUE);
}
-static GtkStyleProperties *
-gtk_css_provider_get_style (GtkStyleProvider *provider,
- GtkWidgetPath *path)
+static GtkCssChange
+gtk_css_style_provider_get_change (GtkStyleProviderPrivate *provider,
+ const GtkCssMatcher *matcher)
{
GtkCssProvider *css_provider;
- GtkStyleProperties *props;
- GArray *priority_info;
- guint i;
+ GtkCssProviderPrivate *priv;
+ GtkCssChange change;
css_provider = GTK_CSS_PROVIDER (provider);
- props = gtk_style_properties_new ();
-
- css_provider_dump_symbolic_colors (css_provider, props);
- priority_info = css_provider_get_selectors (css_provider, path);
-
- for (i = 0; i < priority_info->len; i++)
- {
- StylePriorityInfo *info;
- GHashTableIter iter;
- gpointer key, value;
-
- info = &g_array_index (priority_info, StylePriorityInfo, i);
- g_hash_table_iter_init (&iter, info->style);
-
- while (g_hash_table_iter_next (&iter, &key, &value))
- {
- gchar *prop = key;
-
- /* Properties starting with '-' may be both widget style properties
- * or custom properties from the theming engine, so check whether
- * the type is registered or not.
- */
- if (prop[0] == '-' &&
- !gtk_style_properties_lookup_property (prop, NULL, NULL))
- continue;
-
- gtk_style_properties_set_property (props, key, info->state, value);
- }
- }
-
- g_array_free (priority_info, TRUE);
-
- return props;
-}
-
-static gboolean
-gtk_css_provider_get_style_property (GtkStyleProvider *provider,
- GtkWidgetPath *path,
- GtkStateFlags state,
- GParamSpec *pspec,
- GValue *value)
-{
- GArray *priority_info;
- gboolean found = FALSE;
- gchar *prop_name;
- gint i;
-
- prop_name = g_strdup_printf ("-%s-%s",
- g_type_name (pspec->owner_type),
- pspec->name);
-
- priority_info = css_provider_get_selectors (GTK_CSS_PROVIDER (provider), path);
-
- for (i = priority_info->len - 1; i >= 0; i--)
- {
- StylePriorityInfo *info;
- GValue *val;
-
- info = &g_array_index (priority_info, StylePriorityInfo, i);
- val = g_hash_table_lookup (info->style, prop_name);
-
- if (val &&
- (info->state == 0 ||
- info->state == state ||
- ((info->state & state) != 0 &&
- (info->state & ~(state)) == 0)))
- {
- GError *error = NULL;
-
- found = _gtk_css_value_from_string (value,
- NULL,
- g_value_get_string (val),
- &error);
+ priv = css_provider->priv;
- if (found)
- break;
-
- /* error location should be _way_ better */
- gtk_css_provider_take_error_full (GTK_CSS_PROVIDER (provider),
- NULL,
- 0, 0,
- error);
- }
- }
+ change = _gtk_css_selector_tree_get_change_all (priv->tree, matcher);
- g_array_free (priority_info, TRUE);
- g_free (prop_name);
+ verify_tree_get_change_results (css_provider, matcher, change);
- return found;
+ return change;
}
static void
-gtk_css_style_provider_iface_init (GtkStyleProviderIface *iface)
+gtk_css_style_provider_private_iface_init (GtkStyleProviderPrivateInterface *iface)
{
- iface->get_style = gtk_css_provider_get_style;
- iface->get_style_property = gtk_css_provider_get_style_property;
+ iface->get_color = gtk_css_style_provider_get_color;
+ iface->get_keyframes = gtk_css_style_provider_get_keyframes;
+ iface->lookup = gtk_css_style_provider_lookup;
+ iface->get_change = gtk_css_style_provider_get_change;
}
static void
{
GtkCssProvider *css_provider;
GtkCssProviderPrivate *priv;
+ guint i;
css_provider = GTK_CSS_PROVIDER (object);
priv = css_provider->priv;
- g_ptr_array_free (priv->selectors_info, TRUE);
+ for (i = 0; i < priv->rulesets->len; i++)
+ gtk_css_ruleset_clear (&g_array_index (priv->rulesets, GtkCssRuleset, i));
+
+ g_array_free (priv->rulesets, TRUE);
+ _gtk_css_selector_tree_free (priv->tree);
- if (priv->symbolic_colors)
- g_hash_table_destroy (priv->symbolic_colors);
+ g_hash_table_destroy (priv->symbolic_colors);
+ g_hash_table_destroy (priv->keyframes);
+
+ if (priv->resource)
+ {
+ g_resources_unregister (priv->resource);
+ g_resource_unref (priv->resource);
+ priv->resource = NULL;
+ }
G_OBJECT_CLASS (gtk_css_provider_parent_class)->finalize (object);
}
static void
gtk_css_provider_take_error (GtkCssProvider *provider,
- GScanner *scanner,
+ GtkCssScanner *scanner,
GError *error)
{
- GtkCssScannerPrivate *priv = scanner->user_data;
+ gtk_css_provider_emit_error (provider,
+ scanner,
+ error);
- gtk_css_provider_take_error_full (provider,
- priv->file,
- scanner->line,
- scanner->position,
- error);
+ g_error_free (error);
}
static void
gtk_css_provider_error_literal (GtkCssProvider *provider,
- GScanner *scanner,
+ GtkCssScanner *scanner,
GQuark domain,
gint code,
const char *message)
static void
gtk_css_provider_error (GtkCssProvider *provider,
- GScanner *scanner,
+ GtkCssScanner *scanner,
GQuark domain,
gint code,
const char *format,
...) G_GNUC_PRINTF (5, 6);
static void
gtk_css_provider_error (GtkCssProvider *provider,
- GScanner *scanner,
+ GtkCssScanner *scanner,
GQuark domain,
gint code,
const char *format,
static void
gtk_css_provider_invalid_token (GtkCssProvider *provider,
- GScanner *scanner,
+ GtkCssScanner *scanner,
const char *expected)
{
gtk_css_provider_error (provider,
"expected a valid %s", expected);
}
-static void
-scanner_apply_scope (GScanner *scanner,
- ParserScope scope)
+static void
+css_provider_commit (GtkCssProvider *css_provider,
+ GSList *selectors,
+ GtkCssRuleset *ruleset)
{
- g_scanner_set_scope (scanner, scope);
+ GtkCssProviderPrivate *priv;
+ GSList *l;
- if (scope == SCOPE_VALUE)
- {
- scanner->config->cset_identifier_first = G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "@#-_";
- scanner->config->cset_identifier_nth = G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "@#-_ +(),.%\t\n'/\"";
- scanner->config->scan_identifier_1char = TRUE;
- }
- else if (scope == SCOPE_BINDING_SET)
- {
- scanner->config->cset_identifier_first = G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "@#-_";
- scanner->config->cset_identifier_nth = G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "@#-_ +(){}<>,.%\t\n'/\"";
- scanner->config->scan_identifier_1char = TRUE;
- }
- else if (scope == SCOPE_SELECTOR)
- {
- scanner->config->cset_identifier_first = G_CSET_a_2_z G_CSET_A_2_Z "*@";
- scanner->config->cset_identifier_nth = G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "-_#.";
- scanner->config->scan_identifier_1char = TRUE;
- }
- else if (scope == SCOPE_PSEUDO_CLASS ||
- scope == SCOPE_NTH_CHILD ||
- scope == SCOPE_DECLARATION)
+ priv = css_provider->priv;
+
+ if (ruleset->styles == NULL && ruleset->widget_style == NULL)
{
- scanner->config->cset_identifier_first = G_CSET_a_2_z G_CSET_A_2_Z "-_";
- scanner->config->cset_identifier_nth = G_CSET_a_2_z G_CSET_A_2_Z G_CSET_DIGITS "-_";
- scanner->config->scan_identifier_1char = FALSE;
+ g_slist_free_full (selectors, (GDestroyNotify) _gtk_css_selector_free);
+ return;
}
- else
- g_assert_not_reached ();
- scanner->config->scan_float = FALSE;
- scanner->config->cpair_comment_single = NULL;
-}
+ for (l = selectors; l; l = l->next)
+ {
+ GtkCssRuleset new;
-static void
-gtk_css_scanner_push_scope (GScanner *scanner,
- ParserScope scope)
-{
- GtkCssScannerPrivate *priv;
+ gtk_css_ruleset_init_copy (&new, ruleset, l->data);
- priv = scanner->user_data;
- priv->state = g_slist_prepend (priv->state, GUINT_TO_POINTER (scope));
+ g_array_append_val (priv->rulesets, new);
+ }
- scanner_apply_scope (scanner, scope);
+ g_slist_free (selectors);
}
static void
-gtk_css_scanner_pop_scope (GScanner *scanner)
+gtk_css_provider_reset (GtkCssProvider *css_provider)
{
- GtkCssScannerPrivate *priv;
- ParserScope scope = SCOPE_SELECTOR;
+ GtkCssProviderPrivate *priv;
+ guint i;
- priv = scanner->user_data;
+ priv = css_provider->priv;
- if (!priv->state)
+ if (priv->resource)
{
- g_warning ("Push/pop calls to parser scope aren't paired");
- scanner_apply_scope (scanner, SCOPE_SELECTOR);
- return;
+ g_resources_unregister (priv->resource);
+ g_resource_unref (priv->resource);
+ priv->resource = NULL;
}
- priv->state = g_slist_delete_link (priv->state, priv->state);
+ g_hash_table_remove_all (priv->symbolic_colors);
+ g_hash_table_remove_all (priv->keyframes);
- /* Fetch new scope */
- if (priv->state)
- scope = GPOINTER_TO_INT (priv->state->data);
+ for (i = 0; i < priv->rulesets->len; i++)
+ gtk_css_ruleset_clear (&g_array_index (priv->rulesets, GtkCssRuleset, i));
+ g_array_set_size (priv->rulesets, 0);
+ _gtk_css_selector_tree_free (priv->tree);
+ priv->tree = NULL;
- scanner_apply_scope (scanner, scope);
}
static void
-css_provider_commit (GtkCssProvider *css_provider,
- GScanner *scanner)
+gtk_css_provider_propagate_error (GtkCssProvider *provider,
+ GtkCssSection *section,
+ const GError *error,
+ GError **propagate_to)
{
- GtkCssScannerPrivate *scanner_priv;
- GtkCssProviderPrivate *priv;
- GSList *l;
- priv = css_provider->priv;
- scanner_priv = scanner->user_data;
+ char *s;
- l = scanner_priv->cur_selectors;
+ /* don't fail for deprecations */
+ if (g_error_matches (error, GTK_CSS_PROVIDER_ERROR, GTK_CSS_PROVIDER_ERROR_DEPRECATED))
+ {
+ s = _gtk_css_section_to_string (section);
+ g_warning ("Theme parsing error: %s: %s", s, error->message);
+ g_free (s);
+ return;
+ }
- if (g_hash_table_size (scanner_priv->cur_properties) == 0)
+ /* we already set an error. And we'd like to keep the first one */
+ if (*propagate_to)
return;
- while (l)
+ *propagate_to = g_error_copy (error);
+ if (section)
{
- SelectorPath *path = l->data;
- SelectorStyleInfo *info;
-
- info = selector_style_info_new (path);
- selector_style_info_set_style (info, scanner_priv->cur_properties);
-
- g_ptr_array_add (priv->selectors_info, info);
- l = l->next;
+ s = _gtk_css_section_to_string (section);
+ g_prefix_error (propagate_to, "%s", s);
+ g_free (s);
}
}
-static GTokenType
-parse_nth_child (GtkCssProvider *css_provider,
- GScanner *scanner,
- GtkRegionFlags *flags)
+static gboolean
+parse_import (GtkCssScanner *scanner)
{
- ParserSymbol symbol;
-
- g_scanner_get_next_token (scanner);
-
- if (scanner->token != G_TOKEN_SYMBOL)
- return G_TOKEN_SYMBOL;
+ GFile *file;
- symbol = GPOINTER_TO_INT (scanner->value.v_symbol);
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_IMPORT);
- if (symbol == SYMBOL_NTH_CHILD)
+ if (!_gtk_css_parser_try (scanner->parser, "@import", TRUE))
{
- g_scanner_get_next_token (scanner);
-
- if (scanner->token != G_TOKEN_LEFT_PAREN)
- return G_TOKEN_LEFT_PAREN;
-
- gtk_css_scanner_push_scope (scanner, SCOPE_NTH_CHILD);
- g_scanner_get_next_token (scanner);
-
- if (scanner->token != G_TOKEN_SYMBOL)
- return G_TOKEN_SYMBOL;
-
- symbol = GPOINTER_TO_INT (scanner->value.v_symbol);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_IMPORT);
+ return FALSE;
+ }
- switch (symbol)
- {
- case SYMBOL_NTH_CHILD_EVEN:
- *flags = GTK_REGION_EVEN;
- break;
- case SYMBOL_NTH_CHILD_ODD:
- *flags = GTK_REGION_ODD;
- break;
- case SYMBOL_NTH_CHILD_FIRST:
- *flags = GTK_REGION_FIRST;
- break;
- case SYMBOL_NTH_CHILD_LAST:
- *flags = GTK_REGION_LAST;
- break;
- default:
- break;
- }
+ if (_gtk_css_parser_is_string (scanner->parser))
+ {
+ char *uri;
- g_scanner_get_next_token (scanner);
+ uri = _gtk_css_parser_read_string (scanner->parser);
+ file = _gtk_css_parser_get_file_for_path (scanner->parser, uri);
+ g_free (uri);
+ }
+ else
+ {
+ file = _gtk_css_parser_read_url (scanner->parser);
+ }
- if (scanner->token != G_TOKEN_RIGHT_PAREN)
- return G_TOKEN_RIGHT_PAREN;
+ if (file == NULL)
+ {
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_IMPORT);
+ return TRUE;
+ }
- gtk_css_scanner_pop_scope (scanner);
+ if (!_gtk_css_parser_try (scanner->parser, ";", FALSE))
+ {
+ gtk_css_provider_invalid_token (scanner->provider, scanner, "semicolon");
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ }
+ else if (gtk_css_scanner_would_recurse (scanner, file))
+ {
+ char *path = g_file_get_path (file);
+ gtk_css_provider_error (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_IMPORT,
+ "Loading '%s' would recurse",
+ path);
+ g_free (path);
}
- else if (symbol == SYMBOL_FIRST_CHILD)
- *flags = GTK_REGION_FIRST;
- else if (symbol == SYMBOL_LAST_CHILD)
- *flags = GTK_REGION_LAST;
- else if (symbol == SYMBOL_SORTED_CHILD)
- *flags = GTK_REGION_SORTED;
else
{
- *flags = 0;
- return G_TOKEN_SYMBOL;
+ gtk_css_provider_load_internal (scanner->provider,
+ scanner,
+ file,
+ NULL,
+ NULL);
}
- return G_TOKEN_NONE;
-}
+ g_object_unref (file);
-static GTokenType
-parse_pseudo_class (GtkCssProvider *css_provider,
- GScanner *scanner,
- SelectorPath *selector)
-{
- GtkStateType state;
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_IMPORT);
+ _gtk_css_parser_skip_whitespace (scanner->parser);
- g_scanner_get_next_token (scanner);
+ return TRUE;
+}
- if (scanner->token != G_TOKEN_SYMBOL)
- return G_TOKEN_SYMBOL;
+static gboolean
+parse_color_definition (GtkCssScanner *scanner)
+{
+ GtkCssValue *color;
+ char *name;
- state = GPOINTER_TO_INT (scanner->value.v_symbol);
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_COLOR_DEFINITION);
- switch (state)
+ if (!_gtk_css_parser_try (scanner->parser, "@define-color", TRUE))
{
- case GTK_STATE_ACTIVE:
- selector->state |= GTK_STATE_FLAG_ACTIVE;
- break;
- case GTK_STATE_PRELIGHT:
- selector->state |= GTK_STATE_FLAG_PRELIGHT;
- break;
- case GTK_STATE_SELECTED:
- selector->state |= GTK_STATE_FLAG_SELECTED;
- break;
- case GTK_STATE_INSENSITIVE:
- selector->state |= GTK_STATE_FLAG_INSENSITIVE;
- break;
- case GTK_STATE_INCONSISTENT:
- selector->state |= GTK_STATE_FLAG_INCONSISTENT;
- break;
- case GTK_STATE_FOCUSED:
- selector->state |= GTK_STATE_FLAG_FOCUSED;
- break;
- default:
- return G_TOKEN_SYMBOL;
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_COLOR_DEFINITION);
+ return FALSE;
}
- return G_TOKEN_NONE;
-}
-
-/* Parses a number of concatenated classes */
-static void
-parse_classes (SelectorPath *path,
- const gchar *str)
-{
- gchar *pos;
-
- if ((pos = strchr (str, '.')) != NULL)
+ name = _gtk_css_parser_try_name (scanner->parser, TRUE);
+ if (name == NULL)
{
- /* Leave the last class to the call after the loop */
- while (pos)
- {
- *pos = '\0';
- selector_path_prepend_class (path, str);
-
- str = pos + 1;
- pos = strchr (str, '.');
- }
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Not a valid color name");
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_COLOR_DEFINITION);
+ return TRUE;
}
- selector_path_prepend_class (path, str);
-}
-
-static gboolean
-is_widget_class_name (const gchar *str)
-{
- /* Do a pretty lax check here, not all
- * widget class names contain only CamelCase
- * (gtkmm widgets don't), but at least part of
- * the name will be CamelCase, so check for
- * the first uppercase char
- */
- while (*str)
+ color = _gtk_css_color_value_parse (scanner->parser);
+ if (color == NULL)
{
- if (g_ascii_isupper (*str))
- return TRUE;
+ g_free (name);
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_COLOR_DEFINITION);
+ return TRUE;
+ }
- str++;
+ if (!_gtk_css_parser_try (scanner->parser, ";", TRUE))
+ {
+ g_free (name);
+ _gtk_css_value_unref (color);
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Missing semicolon at end of color definition");
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_COLOR_DEFINITION);
+ return TRUE;
}
- return FALSE;
+ g_hash_table_insert (scanner->provider->priv->symbolic_colors, name, color);
+
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_COLOR_DEFINITION);
+ return TRUE;
}
-static GTokenType
-parse_selector (GtkCssProvider *css_provider,
- GScanner *scanner,
- SelectorPath **selector_out)
+static gboolean
+parse_binding_set (GtkCssScanner *scanner)
{
- SelectorPath *path;
-
- path = selector_path_new ();
- *selector_out = path;
+ GtkBindingSet *binding_set;
+ char *name;
- if (scanner->token != ':' &&
- scanner->token != '#' &&
- scanner->token != '.' &&
- scanner->token != G_TOKEN_IDENTIFIER)
- return G_TOKEN_IDENTIFIER;
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_BINDING_SET);
- while (scanner->token == '#' ||
- scanner->token == '.' ||
- scanner->token == G_TOKEN_IDENTIFIER)
+ if (!_gtk_css_parser_try (scanner->parser, "@binding-set", TRUE))
{
- if (scanner->token == '#' ||
- scanner->token == '.')
- {
- gboolean is_class;
- gchar *pos;
-
- is_class = (scanner->token == '.');
-
- g_scanner_get_next_token (scanner);
-
- if (scanner->token != G_TOKEN_IDENTIFIER)
- return G_TOKEN_IDENTIFIER;
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_BINDING_SET);
+ return FALSE;
+ }
- selector_path_prepend_glob (path);
- selector_path_prepend_combinator (path, COMBINATOR_CHILD);
+ name = _gtk_css_parser_try_ident (scanner->parser, TRUE);
+ if (name == NULL)
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Expected name for binding set");
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ goto skip_semicolon;
+ }
- if (is_class)
- parse_classes (path, scanner->value.v_identifier);
- else
- {
- if ((pos = strchr (scanner->value.v_identifier, '.')) != NULL)
- *pos = '\0';
+ binding_set = gtk_binding_set_find (name);
+ if (!binding_set)
+ {
+ binding_set = gtk_binding_set_new (name);
+ binding_set->parsed = TRUE;
+ }
+ g_free (name);
- selector_path_prepend_name (path, scanner->value.v_identifier);
+ if (!_gtk_css_parser_try (scanner->parser, "{", TRUE))
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Expected '{' for binding set");
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ goto skip_semicolon;
+ }
- /* Parse any remaining classes */
- if (pos)
- parse_classes (path, pos + 1);
- }
- }
- else if (is_widget_class_name (scanner->value.v_identifier))
+ while (!_gtk_css_parser_is_eof (scanner->parser) &&
+ !_gtk_css_parser_begins_with (scanner->parser, '}'))
+ {
+ name = _gtk_css_parser_read_value (scanner->parser);
+ if (name == NULL)
{
- gchar *pos;
-
- if ((pos = strchr (scanner->value.v_identifier, '#')) != NULL ||
- (pos = strchr (scanner->value.v_identifier, '.')) != NULL)
- {
- gchar *type_name, *name;
- gboolean is_class;
-
- is_class = (*pos == '.');
-
- /* Widget type and name/class put together */
- name = pos + 1;
- *pos = '\0';
- type_name = scanner->value.v_identifier;
-
- selector_path_prepend_type (path, type_name);
-
- /* This is only so there is a direct relationship
- * between widget type and its name.
- */
- selector_path_prepend_combinator (path, COMBINATOR_CHILD);
-
- if (is_class)
- parse_classes (path, name);
- else
- {
- if ((pos = strchr (name, '.')) != NULL)
- *pos = '\0';
-
- selector_path_prepend_name (path, name);
-
- /* Parse any remaining classes */
- if (pos)
- parse_classes (path, pos + 1);
- }
- }
- else
- selector_path_prepend_type (path, scanner->value.v_identifier);
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
+ continue;
}
- else if (_gtk_style_context_check_region_name (scanner->value.v_identifier))
- {
- GtkRegionFlags flags = 0;
- gchar *region_name;
- region_name = g_strdup (scanner->value.v_identifier);
-
- if (g_scanner_peek_next_token (scanner) == ':')
- {
- ParserSymbol symbol;
-
- g_scanner_get_next_token (scanner);
- gtk_css_scanner_push_scope (scanner, SCOPE_PSEUDO_CLASS);
-
- /* Check for the next token being nth-child, parse in that
- * case, and fallback into common state parsing if not.
- */
- if (g_scanner_peek_next_token (scanner) != G_TOKEN_SYMBOL)
- return G_TOKEN_SYMBOL;
-
- symbol = GPOINTER_TO_INT (scanner->next_value.v_symbol);
-
- if (symbol == SYMBOL_FIRST_CHILD ||
- symbol == SYMBOL_LAST_CHILD ||
- symbol == SYMBOL_NTH_CHILD ||
- symbol == SYMBOL_SORTED_CHILD)
- {
- GTokenType token;
-
- if ((token = parse_nth_child (css_provider, scanner, &flags)) != G_TOKEN_NONE)
- return token;
-
- gtk_css_scanner_pop_scope (scanner);
- }
- else
- {
- gtk_css_scanner_pop_scope (scanner);
- selector_path_prepend_region (path, region_name, 0);
- g_free (region_name);
- break;
- }
- }
-
- selector_path_prepend_region (path, region_name, flags);
- g_free (region_name);
+ if (gtk_binding_entry_add_signal_from_string (binding_set, name) != G_TOKEN_NONE)
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Failed to parse binding set.");
}
- else if (scanner->value.v_identifier[0] == '*')
- selector_path_prepend_glob (path);
- else
- return G_TOKEN_IDENTIFIER;
- g_scanner_get_next_token (scanner);
+ g_free (name);
- if (scanner->token == '>')
+ if (!_gtk_css_parser_try (scanner->parser, ";", TRUE))
{
- selector_path_prepend_combinator (path, COMBINATOR_CHILD);
- g_scanner_get_next_token (scanner);
+ if (!_gtk_css_parser_begins_with (scanner->parser, '}') &&
+ !_gtk_css_parser_is_eof (scanner->parser))
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Expected semicolon");
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
+ }
}
}
- if (scanner->token == ':')
+ if (!_gtk_css_parser_try (scanner->parser, "}", TRUE))
{
- /* Add glob selector if path is empty */
- if (selector_path_depth (path) == 0)
- selector_path_prepend_glob (path);
-
- gtk_css_scanner_push_scope (scanner, SCOPE_PSEUDO_CLASS);
-
- while (scanner->token == ':')
- {
- GTokenType token;
-
- if ((token = parse_pseudo_class (css_provider, scanner, path)) != G_TOKEN_NONE)
- return token;
-
- g_scanner_get_next_token (scanner);
- }
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "expected '}' after declarations");
+ if (!_gtk_css_parser_is_eof (scanner->parser))
+ _gtk_css_parser_resync (scanner->parser, FALSE, 0);
+ }
- gtk_css_scanner_pop_scope (scanner);
+skip_semicolon:
+ if (_gtk_css_parser_begins_with (scanner->parser, ';'))
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_DEPRECATED,
+ "Nonstandard semicolon at end of binding set");
+ _gtk_css_parser_try (scanner->parser, ";", TRUE);
}
- return G_TOKEN_NONE;
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_BINDING_SET);
+
+ return TRUE;
}
-static void
-resolve_binding_sets (const gchar *value_str,
- GValue *value)
+static gboolean
+parse_keyframes (GtkCssScanner *scanner)
{
- GPtrArray *array;
- gchar **bindings, **str;
+ GtkCssKeyframes *keyframes;
+ char *name;
- bindings = g_strsplit (value_str, ",", -1);
- array = g_ptr_array_new ();
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_KEYFRAMES);
- for (str = bindings; *str; str++)
+ if (!_gtk_css_parser_try (scanner->parser, "@keyframes", TRUE))
{
- GtkBindingSet *binding_set;
-
- binding_set = gtk_binding_set_find (g_strstrip (*str));
-
- if (!binding_set)
- continue;
-
- g_ptr_array_add (array, binding_set);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_KEYFRAMES);
+ return FALSE;
}
- g_value_take_boxed (value, array);
- g_strfreev (bindings);
-}
-
-static GTokenType
-parse_rule (GtkCssProvider *css_provider,
- GScanner *scanner)
-{
- GtkCssScannerPrivate *priv;
- GTokenType expected_token;
- SelectorPath *selector;
-
- priv = scanner->user_data;
-
- gtk_css_scanner_push_scope (scanner, SCOPE_SELECTOR);
+ name = _gtk_css_parser_try_ident (scanner->parser, TRUE);
+ if (name == NULL)
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Expected name for keyframes");
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ goto exit;
+ }
- /* Handle directives */
- if (scanner->token == G_TOKEN_IDENTIFIER &&
- scanner->value.v_identifier[0] == '@')
+ if (!_gtk_css_parser_try (scanner->parser, "{", TRUE))
{
- gchar *directive;
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Expected '{' for keyframes");
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ g_free (name);
+ goto exit;
+ }
- directive = &scanner->value.v_identifier[1];
+ keyframes = _gtk_css_keyframes_parse (scanner->parser);
+ if (keyframes == NULL)
+ {
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
+ g_free (name);
+ goto exit;
+ }
- if (strcmp (directive, "define-color") == 0)
- {
- GtkSymbolicColor *color;
- gchar *color_name, *color_str;
- GError *error = NULL;
+ g_hash_table_insert (scanner->provider->priv->keyframes, name, keyframes);
- /* Directive is a color mapping */
- g_scanner_get_next_token (scanner);
+ if (!_gtk_css_parser_try (scanner->parser, "}", TRUE))
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "expected '}' after declarations");
+ if (!_gtk_css_parser_is_eof (scanner->parser))
+ _gtk_css_parser_resync (scanner->parser, FALSE, 0);
+ }
- if (scanner->token != G_TOKEN_IDENTIFIER)
- {
- gtk_css_provider_invalid_token (css_provider, scanner, "Color name");
- return G_TOKEN_IDENTIFIER;
- }
+exit:
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_KEYFRAMES);
- color_name = g_strdup (scanner->value.v_identifier);
- gtk_css_scanner_push_scope (scanner, SCOPE_VALUE);
- g_scanner_get_next_token (scanner);
+ return TRUE;
+}
- if (scanner->token != G_TOKEN_IDENTIFIER)
- {
- gtk_css_provider_invalid_token (css_provider, scanner, "Color definition");
- return G_TOKEN_IDENTIFIER;
- }
+static void
+parse_at_keyword (GtkCssScanner *scanner)
+{
+ if (parse_import (scanner))
+ return;
+ if (parse_color_definition (scanner))
+ return;
+ if (parse_binding_set (scanner))
+ return;
+ if (parse_keyframes (scanner))
+ return;
- color_str = g_strstrip (scanner->value.v_identifier);
- color = _gtk_css_parse_symbolic_color (color_str, &error);
- if (!color)
- {
- gtk_css_provider_take_error (css_provider, scanner, error);
- return G_TOKEN_IDENTIFIER;
- }
+ else
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "unknown @ rule");
+ _gtk_css_parser_resync (scanner->parser, TRUE, 0);
+ }
+}
- g_hash_table_insert (css_provider->priv->symbolic_colors, color_name, color);
+static GSList *
+parse_selector_list (GtkCssScanner *scanner)
+{
+ GSList *selectors = NULL;
- gtk_css_scanner_pop_scope (scanner);
- g_scanner_get_next_token (scanner);
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_SELECTOR);
- if (scanner->token != ';')
- return ';';
+ do {
+ GtkCssSelector *select = _gtk_css_selector_parse (scanner->parser);
- return G_TOKEN_NONE;
- }
- else if (strcmp (directive, "import") == 0)
+ if (select == NULL)
{
- gboolean loaded;
- gchar *path = NULL;
- GFile *actual;
- GError *error = NULL;
-
- gtk_css_scanner_push_scope (scanner, SCOPE_VALUE);
- g_scanner_get_next_token (scanner);
-
- if (scanner->token == G_TOKEN_IDENTIFIER &&
- g_str_has_prefix (scanner->value.v_identifier, "url"))
- path = g_strstrip (scanner->value.v_identifier);
- else if (scanner->token == G_TOKEN_STRING)
- path = g_strstrip (scanner->value.v_string);
- else
- {
- gtk_css_provider_invalid_token (css_provider, scanner, "File URL");
- return G_TOKEN_IDENTIFIER;
- }
-
- actual = _gtk_css_parse_url (gtk_css_scanner_get_base_url (scanner),
- path,
- NULL,
- &error);
-
- if (actual == NULL)
- {
- gtk_css_provider_take_error (css_provider, scanner, error);
- return G_TOKEN_IDENTIFIER;
- }
-
- gtk_css_scanner_pop_scope (scanner);
- g_scanner_get_next_token (scanner);
-
- if (scanner->token != ';')
- {
- g_object_unref (actual);
- return ';';
- }
-
- path = g_file_get_path (actual);
- g_object_unref (actual);
-
- /* FIXME: Avoid recursive importing */
- loaded = gtk_css_provider_load_from_path_internal (css_provider, path,
- FALSE, NULL);
-
- /* Restore previous state */
- g_free (path);
-
- if (!loaded)
- return G_TOKEN_IDENTIFIER;
- else
- return G_TOKEN_NONE;
+ g_slist_free_full (selectors, (GDestroyNotify) _gtk_css_selector_free);
+ _gtk_css_parser_resync (scanner->parser, FALSE, 0);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_SELECTOR);
+ return NULL;
}
- else if (strcmp (directive, "binding-set") == 0)
- {
- GtkBindingSet *binding_set;
- gchar *binding_set_name;
-
- g_scanner_get_next_token (scanner);
-
- if (scanner->token != G_TOKEN_IDENTIFIER)
- {
- gtk_css_provider_invalid_token (css_provider, scanner, "Binding name");
- return G_TOKEN_IDENTIFIER;
- }
-
- binding_set_name = scanner->value.v_identifier;
- binding_set = gtk_binding_set_find (binding_set_name);
-
- if (!binding_set)
- {
- binding_set = gtk_binding_set_new (binding_set_name);
- binding_set->parsed = TRUE;
- }
- g_scanner_get_next_token (scanner);
-
- if (scanner->token != G_TOKEN_LEFT_CURLY)
- return G_TOKEN_LEFT_CURLY;
-
- gtk_css_scanner_push_scope (scanner, SCOPE_BINDING_SET);
- g_scanner_get_next_token (scanner);
-
- do
- {
- GTokenType ret;
-
- if (scanner->token != G_TOKEN_IDENTIFIER)
- {
- gtk_css_provider_invalid_token (css_provider, scanner, "Binding definition");
- return G_TOKEN_IDENTIFIER;
- }
-
- ret = gtk_binding_entry_add_signal_from_string (binding_set,
- scanner->value.v_identifier);
- if (ret != G_TOKEN_NONE)
- {
- gtk_css_provider_invalid_token (css_provider, scanner, "Binding definition");
- return ret;
- }
-
- g_scanner_get_next_token (scanner);
+ selectors = g_slist_prepend (selectors, select);
+ }
+ while (_gtk_css_parser_try (scanner->parser, ",", TRUE));
- if (scanner->token != ';')
- return ';';
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_SELECTOR);
- g_scanner_get_next_token (scanner);
- }
- while (scanner->token != G_TOKEN_RIGHT_CURLY);
+ return selectors;
+}
- gtk_css_scanner_pop_scope (scanner);
- g_scanner_get_next_token (scanner);
+static void
+parse_declaration (GtkCssScanner *scanner,
+ GtkCssRuleset *ruleset)
+{
+ GtkStyleProperty *property;
+ char *name;
- return G_TOKEN_NONE;
- }
- else
- {
- gtk_css_provider_invalid_token (css_provider, scanner, "Directive");
- return G_TOKEN_IDENTIFIER;
- }
- }
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_DECLARATION);
- expected_token = parse_selector (css_provider, scanner, &selector);
+ name = _gtk_css_parser_try_ident (scanner->parser, TRUE);
+ if (name == NULL)
+ goto check_for_semicolon;
- if (expected_token != G_TOKEN_NONE)
+ property = _gtk_style_property_lookup (name);
+ if (property == NULL && name[0] != '-')
{
- selector_path_unref (selector);
- gtk_css_provider_invalid_token (css_provider, scanner, "Selector");
- return expected_token;
+ gtk_css_provider_error (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_NAME,
+ "'%s' is not a valid property name",
+ name);
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
+ g_free (name);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_DECLARATION);
+ return;
}
- priv->cur_selectors = g_slist_prepend (priv->cur_selectors, selector);
-
- while (scanner->token == ',')
+ if (!_gtk_css_parser_try (scanner->parser, ":", TRUE))
{
- g_scanner_get_next_token (scanner);
-
- expected_token = parse_selector (css_provider, scanner, &selector);
-
- if (expected_token != G_TOKEN_NONE)
- {
- selector_path_unref (selector);
- gtk_css_provider_invalid_token (css_provider, scanner, "Selector");
- return expected_token;
- }
-
- priv->cur_selectors = g_slist_prepend (priv->cur_selectors, selector);
+ gtk_css_provider_invalid_token (scanner->provider, scanner, "':'");
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
+ g_free (name);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_DECLARATION);
+ return;
}
- gtk_css_scanner_pop_scope (scanner);
+ if (property)
+ {
+ GtkCssValue *value;
- if (scanner->token != G_TOKEN_LEFT_CURLY)
- return G_TOKEN_LEFT_CURLY;
+ g_free (name);
- /* Declarations parsing */
- gtk_css_scanner_push_scope (scanner, SCOPE_DECLARATION);
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_VALUE);
- g_scanner_get_next_token (scanner);
-
- while (scanner->token != G_TOKEN_RIGHT_CURLY &&
- !g_scanner_eof (scanner))
- {
- gchar *value_str = NULL;
- GtkStylePropertyParser parse_func = NULL;
- GParamSpec *pspec = NULL;;
- gchar *prop;
+ value = _gtk_style_property_parse_value (property,
+ scanner->parser);
- if (scanner->token == ';')
+ if (value == NULL)
{
- g_scanner_get_next_token (scanner);
- continue;
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_VALUE);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_DECLARATION);
+ return;
}
- if (scanner->token != G_TOKEN_IDENTIFIER)
+ if (!_gtk_css_parser_begins_with (scanner->parser, ';') &&
+ !_gtk_css_parser_begins_with (scanner->parser, '}') &&
+ !_gtk_css_parser_is_eof (scanner->parser))
{
- gtk_css_provider_error_literal (css_provider,
+ gtk_css_provider_error_literal (scanner->provider,
scanner,
GTK_CSS_PROVIDER_ERROR,
- GTK_CSS_PROVIDER_ERROR_PROPERTY_NAME,
- "Expected a valid property name");
- goto find_end_of_declaration;
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Junk at end of value");
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_VALUE);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_DECLARATION);
+ return;
}
- prop = g_strdup (scanner->value.v_identifier);
+ if (GTK_IS_CSS_SHORTHAND_PROPERTY (property))
+ {
+ GtkCssShorthandProperty *shorthand = GTK_CSS_SHORTHAND_PROPERTY (property);
+ guint i;
- if (!gtk_style_properties_lookup_property (prop, &parse_func, &pspec) &&
- prop[0] != '-')
+ for (i = 0; i < _gtk_css_shorthand_property_get_n_subproperties (shorthand); i++)
+ {
+ GtkCssStyleProperty *child = _gtk_css_shorthand_property_get_subproperty (shorthand, i);
+ GtkCssValue *sub = _gtk_css_array_value_get_nth (value, i);
+
+ gtk_css_ruleset_add (ruleset, child, _gtk_css_value_ref (sub), scanner->section);
+ }
+
+ _gtk_css_value_unref (value);
+ }
+ else if (GTK_IS_CSS_STYLE_PROPERTY (property))
{
- gtk_css_provider_error (css_provider,
- scanner,
- GTK_CSS_PROVIDER_ERROR,
- GTK_CSS_PROVIDER_ERROR_PROPERTY_NAME,
- "'%s' is not a valid property name",
- prop);
- g_free (prop);
- goto find_end_of_declaration;
+ gtk_css_ruleset_add (ruleset, GTK_CSS_STYLE_PROPERTY (property), value, scanner->section);
+ }
+ else
+ {
+ g_assert_not_reached ();
+ _gtk_css_value_unref (value);
}
- g_scanner_get_next_token (scanner);
- if (scanner->token != ':')
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_VALUE);
+ }
+ else if (name[0] == '-')
+ {
+ char *value_str;
+
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_VALUE);
+
+ value_str = _gtk_css_parser_read_value (scanner->parser);
+ if (value_str)
{
- g_free (prop);
- gtk_css_provider_invalid_token (css_provider, scanner, "':'");
- goto find_end_of_declaration;
- }
+ WidgetPropertyValue *val;
- gtk_css_scanner_push_scope (scanner, SCOPE_VALUE);
- g_scanner_get_next_token (scanner);
+ val = widget_property_value_new (name, scanner->section);
+ val->value = value_str;
- if (scanner->token != G_TOKEN_IDENTIFIER)
+ gtk_css_ruleset_add_style (ruleset, name, val);
+ }
+ else
{
- g_free (prop);
- /* the error value here is hacky. But strings should be used for
- * strings really, so a string is not a syntax error but a broken
- * value for everything that we support. */
- gtk_css_provider_error (css_provider,
- scanner,
- GTK_CSS_PROVIDER_ERROR,
- scanner->token == G_TOKEN_STRING ? GTK_CSS_PROVIDER_ERROR_PROPERTY_VALUE
- : GTK_CSS_PROVIDER_ERROR_SYNTAX,
- "Not a property value");
- gtk_css_scanner_pop_scope (scanner);
- goto find_end_of_declaration;
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_VALUE);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_DECLARATION);
+ return;
}
- value_str = scanner->value.v_identifier;
- g_strchomp (value_str);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_VALUE);
+ }
+ else
+ g_free (name);
- gtk_css_scanner_pop_scope (scanner);
- g_scanner_peek_next_token (scanner);
+check_for_semicolon:
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_DECLARATION);
- if (scanner->next_token != ';' &&
- scanner->next_token != G_TOKEN_RIGHT_CURLY &&
- scanner->next_token != G_TOKEN_EOF)
+ if (!_gtk_css_parser_try (scanner->parser, ";", TRUE))
+ {
+ if (!_gtk_css_parser_begins_with (scanner->parser, '}') &&
+ !_gtk_css_parser_is_eof (scanner->parser))
{
- gtk_css_provider_invalid_token (css_provider, scanner, "';'");
- g_free (prop);
- goto find_end_of_declaration;
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "Expected semicolon");
+ _gtk_css_parser_resync (scanner->parser, TRUE, '}');
}
+ }
+}
- if (pspec)
- {
- GValue *val;
-
- val = g_slice_new0 (GValue);
- g_value_init (val, pspec->value_type);
+static void
+parse_declarations (GtkCssScanner *scanner,
+ GtkCssRuleset *ruleset)
+{
+ while (!_gtk_css_parser_is_eof (scanner->parser) &&
+ !_gtk_css_parser_begins_with (scanner->parser, '}'))
+ {
+ parse_declaration (scanner, ruleset);
+ }
+}
- if (strcmp (value_str, "none") == 0)
- {
- /* Insert the default value, so it has an opportunity
- * to override other style providers when merged
- */
- g_param_value_set_default (pspec, val);
- g_hash_table_insert (priv->cur_properties, prop, val);
- }
- else if (strcmp (prop, "gtk-key-bindings") == 0)
- {
- /* Private property holding the binding sets */
- resolve_binding_sets (value_str, val);
- g_hash_table_insert (priv->cur_properties, prop, val);
- }
- else if (pspec->value_type == G_TYPE_STRING)
- {
- g_value_set_string (val, value_str);
- g_hash_table_insert (priv->cur_properties, prop, val);
- }
- else if (parse_func)
- {
- GError *error = NULL;
-
- if ((*parse_func) (value_str, val, &error))
- g_hash_table_insert (priv->cur_properties, prop, val);
- else
- gtk_css_provider_take_error (css_provider, scanner, error);
- }
- else
- {
- GError *error = NULL;
-
- if (_gtk_css_value_from_string (val,
- gtk_css_scanner_get_base_url (scanner),
- value_str,
- &error))
- {
- g_hash_table_insert (priv->cur_properties, prop, val);
- }
- else
- {
- g_value_unset (val);
- g_slice_free (GValue, val);
- g_free (prop);
-
- gtk_css_provider_take_error (css_provider, scanner, error);
- }
- }
- }
- else if (prop[0] == '-')
- {
- GValue *val;
+static void
+parse_ruleset (GtkCssScanner *scanner)
+{
+ GSList *selectors;
+ GtkCssRuleset ruleset = { 0, };
- val = g_slice_new0 (GValue);
- g_value_init (val, G_TYPE_STRING);
- g_value_set_string (val, value_str);
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_RULESET);
- g_hash_table_insert (priv->cur_properties, prop, val);
- }
- else
- g_free (prop);
+ selectors = parse_selector_list (scanner);
+ if (selectors == NULL)
+ {
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_RULESET);
+ return;
+ }
- g_scanner_get_next_token (scanner);
+ if (!_gtk_css_parser_try (scanner->parser, "{", TRUE))
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "expected '{' after selectors");
+ _gtk_css_parser_resync (scanner->parser, FALSE, 0);
+ g_slist_free_full (selectors, (GDestroyNotify) _gtk_css_selector_free);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_RULESET);
+ return;
+ }
+
+ parse_declarations (scanner, &ruleset);
- if (g_scanner_eof (scanner))
+ if (!_gtk_css_parser_try (scanner->parser, "}", TRUE))
+ {
+ gtk_css_provider_error_literal (scanner->provider,
+ scanner,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_SYNTAX,
+ "expected '}' after declarations");
+ if (!_gtk_css_parser_is_eof (scanner->parser))
{
- gtk_css_provider_invalid_token (css_provider, scanner, "}");
- break;
+ _gtk_css_parser_resync (scanner->parser, FALSE, 0);
+ g_slist_free_full (selectors, (GDestroyNotify) _gtk_css_selector_free);
+ gtk_css_ruleset_clear (&ruleset);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_RULESET);
}
-
-find_end_of_declaration:
- while (scanner->token != ';' &&
- scanner->token != G_TOKEN_RIGHT_CURLY &&
- !g_scanner_eof (scanner))
- g_scanner_get_next_token (scanner);
}
- gtk_css_scanner_pop_scope (scanner);
+ css_provider_commit (scanner->provider, selectors, &ruleset);
+ gtk_css_ruleset_clear (&ruleset);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_RULESET);
+}
- return G_TOKEN_NONE;
+static void
+parse_statement (GtkCssScanner *scanner)
+{
+ if (_gtk_css_parser_begins_with (scanner->parser, '@'))
+ parse_at_keyword (scanner);
+ else
+ parse_ruleset (scanner);
}
static void
-gtk_css_provider_reset (GtkCssProvider *css_provider)
+parse_stylesheet (GtkCssScanner *scanner)
{
- GtkCssProviderPrivate *priv;
+ gtk_css_scanner_push_section (scanner, GTK_CSS_SECTION_DOCUMENT);
- priv = css_provider->priv;
+ _gtk_css_parser_skip_whitespace (scanner->parser);
+
+ while (!_gtk_css_parser_is_eof (scanner->parser))
+ {
+ if (_gtk_css_parser_try (scanner->parser, "<!--", TRUE) ||
+ _gtk_css_parser_try (scanner->parser, "-->", TRUE))
+ continue;
+
+ parse_statement (scanner);
+ }
- if (priv->selectors_info->len > 0)
- g_ptr_array_remove_range (priv->selectors_info, 0, priv->selectors_info->len);
+ gtk_css_scanner_pop_section (scanner, GTK_CSS_SECTION_DOCUMENT);
}
-static void
-gtk_css_provider_propagate_error (GtkCssProvider *provider,
- const gchar *path,
- guint line,
- guint position,
- const GError *error,
- GError **propagate_to)
+static int
+gtk_css_provider_compare_rule (gconstpointer a_,
+ gconstpointer b_)
{
- /* we already set an error. And we'd like to keep the first one */
- if (*propagate_to)
- return;
+ const GtkCssRuleset *a = (const GtkCssRuleset *) a_;
+ const GtkCssRuleset *b = (const GtkCssRuleset *) b_;
+ int compare;
- *propagate_to = g_error_copy (error);
- g_prefix_error (propagate_to, "%s:%u:%u: ", path ? path : "<unknown>", line, position);
+ compare = _gtk_css_selector_compare (a->selector, b->selector);
+ if (compare != 0)
+ return compare;
+
+ return 0;
}
static void
-parse_stylesheet (GtkCssProvider *css_provider,
- GScanner *scanner)
+gtk_css_provider_postprocess (GtkCssProvider *css_provider)
{
- g_scanner_get_next_token (scanner);
+ GtkCssProviderPrivate *priv = css_provider->priv;
+ GtkCssSelectorTreeBuilder *builder;
+ guint i;
+
+ g_array_sort (priv->rulesets, gtk_css_provider_compare_rule);
- while (!g_scanner_eof (scanner))
+ builder = _gtk_css_selector_tree_builder_new ();
+ for (i = 0; i < priv->rulesets->len; i++)
{
- GTokenType expected_token;
+ GtkCssRuleset *ruleset;
- expected_token = parse_rule (css_provider, scanner);
+ ruleset = &g_array_index (priv->rulesets, GtkCssRuleset, i);
- if (expected_token != G_TOKEN_NONE)
- {
- while (!g_scanner_eof (scanner) &&
- scanner->token != G_TOKEN_RIGHT_CURLY)
- g_scanner_get_next_token (scanner);
- }
- else
- css_provider_commit (css_provider, scanner);
+ _gtk_css_selector_tree_builder_add (builder,
+ ruleset->selector,
+ &ruleset->selector_match,
+ ruleset);
+ }
+
+ priv->tree = _gtk_css_selector_tree_builder_build (builder);
+ _gtk_css_selector_tree_builder_free (builder);
+
+#ifndef VERIFY_TREE
+ for (i = 0; i < priv->rulesets->len; i++)
+ {
+ GtkCssRuleset *ruleset;
+
+ ruleset = &g_array_index (priv->rulesets, GtkCssRuleset, i);
- g_scanner_get_next_token (scanner);
-
- gtk_css_scanner_reset (scanner);
+ _gtk_css_selector_free (ruleset->selector);
+ ruleset->selector = NULL;
}
+#endif
}
static gboolean
gtk_css_provider_load_internal (GtkCssProvider *css_provider,
+ GtkCssScanner *parent,
GFile *file,
- const char *data,
- gsize length,
+ const char *text,
GError **error)
{
- GScanner *scanner;
+ GtkCssScanner *scanner;
gulong error_handler;
- char *free_data;
+ char *free_data = NULL;
if (error)
error_handler = g_signal_connect (css_provider,
else
error_handler = 0; /* silence gcc */
- if (data == NULL)
+ if (text == NULL)
{
GError *load_error = NULL;
if (g_file_load_contents (file, NULL,
- &free_data, &length,
+ &free_data, NULL,
NULL, &load_error))
{
- data = free_data;
+ text = free_data;
}
else
{
- gtk_css_provider_take_error_full (css_provider,
- file,
- 0, 0,
- load_error);
+ GtkCssSection *section;
+
+ if (parent)
+ section = gtk_css_section_ref (parent->section);
+ else
+ section = _gtk_css_section_new_for_file (GTK_CSS_SECTION_DOCUMENT, file);
+
+ gtk_css_provider_error (css_provider,
+ parent,
+ GTK_CSS_PROVIDER_ERROR,
+ GTK_CSS_PROVIDER_ERROR_IMPORT,
+ "Failed to import: %s",
+ load_error->message);
+
+ gtk_css_section_unref (section);
}
}
- else
- free_data = NULL;
- if (data)
+ if (text)
{
- scanner = gtk_css_scanner_new (file, data, length);
+ scanner = gtk_css_scanner_new (css_provider,
+ parent,
+ parent ? parent->section : NULL,
+ file,
+ text);
- parse_stylesheet (css_provider, scanner);
+ parse_stylesheet (scanner);
gtk_css_scanner_destroy (scanner);
+
+ if (parent == NULL)
+ gtk_css_provider_postprocess (css_provider);
}
+ g_free (free_data);
+
if (error)
{
g_signal_handler_disconnect (css_provider, error_handler);
-
+
if (*error)
{
/* We clear all contents from the provider for backwards compat reasons */
/**
* gtk_css_provider_load_from_data:
* @css_provider: a #GtkCssProvider
- * @data: CSS data loaded in memory
- * @length: the length of @data in bytes, or -1 for NUL terminated strings
+ * @data: (array length=length) (element-type guint8): CSS data loaded in memory
+ * @length: the length of @data in bytes, or -1 for NUL terminated strings. If
+ * @length is not -1, the code will assume it is not NUL terminated and will
+ * potentially do a copy.
* @error: (out) (allow-none): return location for a #GError, or %NULL
*
* Loads @data into @css_provider, making it clear any previously loaded
* information.
*
- * Returns: %TRUE if the data could be loaded.
+ * Returns: %TRUE. The return value is deprecated and %FALSE will only be
+ * returned for backwards compatibility reasons if an @error is not
+ * %NULL and a loading error occured. To track errors while loading
+ * CSS, connect to the GtkCssProvider::parsing-error signal.
**/
gboolean
gtk_css_provider_load_from_data (GtkCssProvider *css_provider,
gssize length,
GError **error)
{
+ char *free_data;
+ gboolean ret;
+
g_return_val_if_fail (GTK_IS_CSS_PROVIDER (css_provider), FALSE);
g_return_val_if_fail (data != NULL, FALSE);
if (length < 0)
- length = strlen (data);
+ {
+ length = strlen (data);
+ free_data = NULL;
+ }
+ else
+ {
+ free_data = g_strndup (data, length);
+ data = free_data;
+ }
gtk_css_provider_reset (css_provider);
- return gtk_css_provider_load_internal (css_provider, NULL, data, length, error);
+ ret = gtk_css_provider_load_internal (css_provider, NULL, NULL, data, error);
+
+ g_free (free_data);
+
+ _gtk_style_provider_private_changed (GTK_STYLE_PROVIDER_PRIVATE (css_provider));
+
+ return ret;
}
/**
* Loads the data contained in @file into @css_provider, making it
* clear any previously loaded information.
*
- * Returns: %TRUE if the data could be loaded.
+ * Returns: %TRUE. The return value is deprecated and %FALSE will only be
+ * returned for backwards compatibility reasons if an @error is not
+ * %NULL and a loading error occured. To track errors while loading
+ * CSS, connect to the GtkCssProvider::parsing-error signal.
**/
gboolean
gtk_css_provider_load_from_file (GtkCssProvider *css_provider,
GFile *file,
GError **error)
{
+ gboolean success;
+
g_return_val_if_fail (GTK_IS_CSS_PROVIDER (css_provider), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
gtk_css_provider_reset (css_provider);
- return gtk_css_provider_load_internal (css_provider, file, NULL, 0, error);
-}
-
-static gboolean
-gtk_css_provider_load_from_path_internal (GtkCssProvider *css_provider,
- const gchar *path,
- gboolean reset,
- GError **error)
-{
- GtkCssProviderPrivate *priv;
- GError *internal_error = NULL;
- GMappedFile *mapped_file;
- const gchar *data;
- gsize length;
- GFile *file;
- gboolean ret;
-
- priv = css_provider->priv;
-
- mapped_file = g_mapped_file_new (path, FALSE, &internal_error);
-
- if (internal_error)
- {
- g_propagate_error (error, internal_error);
- return FALSE;
- }
-
- length = g_mapped_file_get_length (mapped_file);
- data = g_mapped_file_get_contents (mapped_file);
-
- if (!data)
- data = "";
+ success = gtk_css_provider_load_internal (css_provider, NULL, file, NULL, error);
- if (reset)
- gtk_css_provider_reset (css_provider);
+ _gtk_style_provider_private_changed (GTK_STYLE_PROVIDER_PRIVATE (css_provider));
- file = g_file_new_for_path (path);
-
- ret = gtk_css_provider_load_internal (css_provider, file, data, length, error);
-
- g_object_unref (file);
- g_mapped_file_unref (mapped_file);
-
- return ret;
+ return success;
}
/**
* Loads the data contained in @path into @css_provider, making it clear
* any previously loaded information.
*
- * Returns: %TRUE if the data could be loaded.
+ * Returns: %TRUE. The return value is deprecated and %FALSE will only be
+ * returned for backwards compatibility reasons if an @error is not
+ * %NULL and a loading error occured. To track errors while loading
+ * CSS, connect to the GtkCssProvider::parsing-error signal.
**/
gboolean
gtk_css_provider_load_from_path (GtkCssProvider *css_provider,
const gchar *path,
GError **error)
{
+ GFile *file;
+ gboolean result;
+
g_return_val_if_fail (GTK_IS_CSS_PROVIDER (css_provider), FALSE);
g_return_val_if_fail (path != NULL, FALSE);
- return gtk_css_provider_load_from_path_internal (css_provider, path,
- TRUE, error);
+ file = g_file_new_for_path (path);
+
+ result = gtk_css_provider_load_from_file (css_provider, file, error);
+
+ g_object_unref (file);
+
+ return result;
+}
+
+static void
+gtk_css_provider_load_from_resource (GtkCssProvider *css_provider,
+ const gchar *resource_path)
+{
+ GFile *file;
+ char *uri, *escaped;
+
+ g_return_if_fail (GTK_IS_CSS_PROVIDER (css_provider));
+ g_return_if_fail (resource_path != NULL);
+
+ escaped = g_uri_escape_string (resource_path,
+ G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, FALSE);
+ uri = g_strconcat ("resource://", escaped, NULL);
+ g_free (escaped);
+
+ file = g_file_new_for_uri (uri);
+ g_free (uri);
+
+ gtk_css_provider_load_from_file (css_provider, file, NULL);
+
+ g_object_unref (file);
}
/**
if (G_UNLIKELY (!provider))
{
- const gchar *str =
- "@define-color fg_color #000; \n"
- "@define-color bg_color #dcdad5; \n"
- "@define-color text_color #000; \n"
- "@define-color base_color #fff; \n"
- "@define-color selected_bg_color #4b6983; \n"
- "@define-color selected_fg_color #fff; \n"
- "@define-color tooltip_bg_color #eee1b3; \n"
- "@define-color tooltip_fg_color #000; \n"
- "@define-color placeholder_text_color #808080; \n"
- "\n"
- "@define-color info_fg_color rgb (181, 171, 156);\n"
- "@define-color info_bg_color rgb (252, 252, 189);\n"
- "@define-color warning_fg_color rgb (173, 120, 41);\n"
- "@define-color warning_bg_color rgb (250, 173, 61);\n"
- "@define-color question_fg_color rgb (97, 122, 214);\n"
- "@define-color question_bg_color rgb (138, 173, 212);\n"
- "@define-color error_fg_color rgb (166, 38, 38);\n"
- "@define-color error_bg_color rgb (237, 54, 54);\n"
- "\n"
- "* {\n"
- " background-color: @bg_color;\n"
- " color: @fg_color;\n"
- " border-color: shade (@bg_color, 0.6);\n"
- " padding: 2;\n"
- " border-width: 0;\n"
- "}\n"
- "\n"
- "*:prelight {\n"
- " background-color: shade (@bg_color, 1.05);\n"
- " color: shade (@fg_color, 1.3);\n"
- "}\n"
- "\n"
- "*:selected {\n"
- " background-color: @selected_bg_color;\n"
- " color: @selected_fg_color;\n"
- "}\n"
- "\n"
- ".expander, GtkTreeView.view.expander {\n"
- " color: #fff;\n"
- "}\n"
- "\n"
- ".expander:prelight,\n"
- "GtkTreeView.view.expander:selected:prelight {\n"
- " color: @text_color;\n"
- "}\n"
- "\n"
- ".expander:active {\n"
- " transition: 200ms linear;\n"
- "}\n"
- "\n"
- "*:insensitive {\n"
- " border-color: shade (@bg_color, 0.7);\n"
- " background-color: shade (@bg_color, 0.9);\n"
- " color: shade (@bg_color, 0.7);\n"
- "}\n"
- "\n"
- ".view {\n"
- " border-width: 0;\n"
- " border-radius: 0;\n"
- " background-color: @base_color;\n"
- " color: @text_color;\n"
- "}\n"
- ".view:selected {\n"
- " background-color: shade (@bg_color, 0.9);\n"
- " color: @fg_color;\n"
- "}\n"
- "\n"
- ".view:selected:focused {\n"
- " background-color: @selected_bg_color;\n"
- " color: @selected_fg_color;\n"
- "}\n"
- "\n"
- ".view column:sorted row,\n"
- ".view column:sorted row:prelight {\n"
- " background-color: shade (@bg_color, 0.85);\n"
- "}\n"
- "\n"
- ".view column:sorted row:nth-child(odd),\n"
- ".view column:sorted row:nth-child(odd):prelight {\n"
- " background-color: shade (@bg_color, 0.8);\n"
- "}\n"
- "\n"
- ".view row,\n"
- ".view row:prelight {\n"
- " background-color: @base_color;\n"
- " color: @text_color;\n"
- "}\n"
- "\n"
- ".view row:nth-child(odd),\n"
- ".view row:nth-child(odd):prelight {\n"
- " background-color: shade (@base_color, 0.93); \n"
- "}\n"
- "\n"
- ".view row:selected:focused {\n"
- " background-color: @selected_bg_color;\n"
- "}\n"
- "\n"
- ".view row:selected {\n"
- " background-color: darker (@bg_color);\n"
- " color: @selected_fg_color;\n"
- "}\n"
- "\n"
- ".view.cell.trough,\n"
- ".view.cell.trough:hover,\n"
- ".view.cell.trough:selected,\n"
- ".view.cell.trough:selected:focused {\n"
- " background-color: @bg_color;\n"
- " color: @fg_color;\n"
- "}\n"
- "\n"
- ".view.cell.progressbar,\n"
- ".view.cell.progressbar:hover,\n"
- ".view.cell.progressbar:selected,\n"
- ".view.cell.progressbar:selected:focused {\n"
- " background-color: @selected_bg_color;\n"
- " color: @selected_fg_color;\n"
- "}\n"
- "\n"
- ".rubberband {\n"
- " background-color: alpha (@fg_color, 0.25);\n"
- " border-color: @fg_color;\n"
- " border-style: solid;\n"
- " border-width: 1;\n"
- "}\n"
- "\n"
- ".tooltip {\n"
- " background-color: @tooltip_bg_color; \n"
- " color: @tooltip_fg_color; \n"
- " border-color: @tooltip_fg_color; \n"
- " border-width: 1;\n"
- " border-style: solid;\n"
- "}\n"
- "\n"
- ".button,\n"
- ".slider {\n"
- " border-style: outset; \n"
- " border-width: 2; \n"
- "}\n"
- "\n"
- ".button:active {\n"
- " background-color: shade (@bg_color, 0.7);\n"
- " border-style: inset; \n"
- "}\n"
- "\n"
- ".button:prelight,\n"
- ".slider:prelight {\n"
- " background-color: @selected_bg_color;\n"
- " color: @selected_fg_color;\n"
- " border-color: shade (@selected_bg_color, 0.7);\n"
- "}\n"
- "\n"
- ".trough {\n"
- " background-color: darker (@bg_color);\n"
- " border-style: inset;\n"
- " border-width: 1;\n"
- " padding: 0;\n"
- "}\n"
- "\n"
- ".entry {\n"
- " border-style: inset;\n"
- " border-width: 2;\n"
- " background-color: @base_color;\n"
- " color: @text_color;\n"
- "}\n"
- "\n"
- ".entry:insensitive {\n"
- " background-color: shade (@base_color, 0.9);\n"
- " color: shade (@base_color, 0.7);\n"
- "}\n"
- ".entry:active {\n"
- " background-color: #c4c2bd;\n"
- " color: #000;\n"
- "}\n"
- "\n"
- ".progressbar,\n"
- ".entry.progressbar, \n"
- ".cell.progressbar {\n"
- " background-color: @selected_bg_color;\n"
- " border-color: shade (@selected_bg_color, 0.7);\n"
- " color: @selected_fg_color;\n"
- " border-style: outset;\n"
- " border-width: 1;\n"
- "}\n"
- "\n"
- "GtkCheckButton:hover,\n"
- "GtkCheckButton:selected,\n"
- "GtkRadioButton:hover,\n"
- "GtkRadioButton:selected {\n"
- " background-color: shade (@bg_color, 1.05);\n"
- "}\n"
- "\n"
- ".check, .radio,"
- ".cell.check, .cell.radio,\n"
- ".cell.check:hover, .cell.radio:hover {\n"
- " border-style: solid;\n"
- " border-width: 1;\n"
- " background-color: @base_color;\n"
- " border-color: @fg_color;\n"
- "}\n"
- "\n"
- ".check:active, .radio:active,\n"
- ".check:hover, .radio:hover {\n"
- " background-color: @base_color;\n"
- " border-color: @fg_color;\n"
- " color: @text_color;\n"
- "}\n"
- "\n"
- ".check:selected, .radio:selected {\n"
- " background-color: darker (@bg_color);\n"
- " color: @selected_fg_color;\n"
- " border-color: @selected_fg_color;\n"
- "}\n"
- "\n"
- ".check:selected:focused, .radio:selected:focused {\n"
- " background-color: @selected_bg_color;\n"
- "}\n"
- "\n"
- ".menu.check, .menu.radio {\n"
- " color: @fg_color;\n"
- " border-style: none;\n"
- " border-width: 0;\n"
- "}\n"
- "\n"
- ".popup {\n"
- " border-style: outset;\n"
- " border-width: 1;\n"
- "}\n"
- "\n"
- ".viewport {\n"
- " border-style: inset;\n"
- " border-width: 2;\n"
- "}\n"
- "\n"
- ".notebook {\n"
- " border-style: outset;\n"
- " border-width: 1;\n"
- "}\n"
- "\n"
- ".frame {\n"
- " border-style: inset;\n"
- " border-width: 1;\n"
- "}\n"
- "\n"
- "GtkScrolledWindow.frame {\n"
- " padding: 0;\n"
- "}\n"
- "\n"
- ".menu,\n"
- ".menubar,\n"
- ".toolbar {\n"
- " border-style: outset;\n"
- " border-width: 1;\n"
- "}\n"
- "\n"
- ".menu:hover,\n"
- ".menubar:hover,\n"
- ".menu.check:hover,\n"
- ".menu.radio:hover {\n"
- " background-color: @selected_bg_color;\n"
- " color: @selected_fg_color;\n"
- "}\n"
- "\n"
- "GtkSpinButton.button {\n"
- " border-width: 1;\n"
- "}\n"
- "\n"
- ".scale.slider:hover,\n"
- "GtkSpinButton.button:hover {\n"
- " background-color: shade (@bg_color, 1.05);\n"
- " border-color: shade (@bg_color, 0.8);\n"
- "}\n"
- "\n"
- "GtkSwitch.trough:active {\n"
- " background-color: @selected_bg_color;\n"
- " color: @selected_fg_color;\n"
- "}\n"
- "\n"
- "GtkToggleButton.button:inconsistent {\n"
- " border-style: outset;\n"
- " border-width: 1px;\n"
- " background-color: shade (@bg_color, 0.9);\n"
- " border-color: shade (@bg_color, 0.7);\n"
- "}\n"
- "\n"
- "GtkLabel:selected {\n"
- " background-color: shade (@bg_color, 0.9);\n"
- "}\n"
- "\n"
- "GtkLabel:selected:focused {\n"
- " background-color: @selected_bg_color;\n"
- "}\n"
- "\n"
- ".spinner:active {\n"
- " transition: 750ms linear loop;\n"
- "}\n"
- "\n"
- ".info {\n"
- " background-color: @info_bg_color;\n"
- " color: @info_fg_color;\n"
- "}\n"
- "\n"
- ".warning {\n"
- " background-color: @warning_bg_color;\n"
- " color: @warning_fg_color;\n"
- "}\n"
- "\n"
- ".question {\n"
- " background-color: @question_bg_color;\n"
- " color: @question_fg_color;\n"
- "}\n"
- "\n"
- ".error {\n"
- " background-color: @error_bg_color;\n"
- " color: @error_fg_color;\n"
- "}\n"
- "\n"
- ".highlight {\n"
- " background-color: @selected_bg_color;\n"
- " color: @selected_fg_color;\n"
- "}\n"
- "\n"
- ".light-area-focus {\n"
- " color: #000;\n"
- "}\n"
- "\n"
- ".dark-area-focus {\n"
- " color: #fff;\n"
- "}\n"
- "GtkCalendar.view {\n"
- " border-width: 1;\n"
- " border-style: inset;\n"
- " padding: 1;\n"
- "}\n"
- "\n"
- "GtkCalendar.view:inconsistent {\n"
- " color: darker (@bg_color);\n"
- "}\n"
- "\n"
- "GtkCalendar.header {\n"
- " background-color: @bg_color;\n"
- " border-style: outset;\n"
- " border-width: 2;\n"
- "}\n"
- "\n"
- "GtkCalendar.highlight {\n"
- " border-width: 0;\n"
- "}\n"
- "\n"
- "GtkCalendar.button {\n"
- " background-color: @bg_color;\n"
- "}\n"
- "\n"
- "GtkCalendar.button:hover {\n"
- " background-color: lighter (@bg_color);\n"
- " color: @fg_color;\n"
- "}\n"
- "\n"
- ".menu * {\n"
- " border-width: 0;\n"
- " padding: 2;\n"
- "}\n"
- "\n";
-
provider = gtk_css_provider_new ();
- if (!gtk_css_provider_load_from_data (provider, str, -1, NULL))
- {
- g_error ("Failed to load the internal default CSS.");
- }
}
return provider;
if (var)
path = g_build_filename (var, "share", "themes", NULL);
else
- path = g_build_filename (GTK_DATA_PREFIX, "share", "themes", NULL);
+ path = g_build_filename (_gtk_get_data_prefix (), "share", "themes", NULL);
return path;
}
/**
- * gtk_css_provider_get_named:
+ * _gtk_css_provider_load_named:
+ * @provider: a #GtkCssProvider
* @name: A theme name
* @variant: (allow-none): variant to load, for example, "dark", or
* %NULL for the default
*
- * Loads a theme from the usual theme paths
- *
- * Returns: (transfer none): a #GtkCssProvider with the theme loaded.
- * This memory is owned by GTK+, and you must not free it.
- */
-GtkCssProvider *
-gtk_css_provider_get_named (const gchar *name,
- const gchar *variant)
+ * Loads a theme from the usual theme paths. The actual process of
+ * finding the theme might change between releases, but it is
+ * guaranteed that this function uses the same mechanism to load the
+ * theme than GTK uses for loading its own theme.
+ **/
+void
+_gtk_css_provider_load_named (GtkCssProvider *provider,
+ const gchar *name,
+ const gchar *variant)
{
- static GHashTable *themes = NULL;
- GtkCssProvider *provider;
- gchar *key;
+ gchar *subpath, *path;
+ gchar *resource_path;
- if (G_UNLIKELY (!themes))
- themes = g_hash_table_new (g_str_hash, g_str_equal);
+ g_return_if_fail (GTK_IS_CSS_PROVIDER (provider));
+ g_return_if_fail (name != NULL);
- if (variant == NULL)
- key = (gchar *)name;
- else
- key = g_strconcat (name, "-", variant, NULL);
+ gtk_css_provider_reset (provider);
- provider = g_hash_table_lookup (themes, key);
+ /* try loading the resource for the theme. This is mostly meant for built-in
+ * themes.
+ */
+ if (variant)
+ resource_path = g_strdup_printf ("/org/gtk/libgtk/%s-%s.css", name, variant);
+ else
+ resource_path = g_strdup_printf ("/org/gtk/libgtk/%s.css", name);
- if (!provider)
+ if (g_resources_get_info (resource_path, 0, NULL, NULL, NULL))
{
- const gchar *home_dir;
- gchar *subpath, *path = NULL;
-
- if (variant)
- subpath = g_strdup_printf ("gtk-3.0" G_DIR_SEPARATOR_S "gtk-%s.css", variant);
- else
- subpath = g_strdup ("gtk-3.0" G_DIR_SEPARATOR_S "gtk.css");
+ gtk_css_provider_load_from_resource (provider, resource_path);
+ g_free (resource_path);
+ return;
+ }
+ g_free (resource_path);
- /* First look in the users home directory
- */
- home_dir = g_get_home_dir ();
- if (home_dir)
- {
- path = g_build_filename (home_dir, ".themes", name, subpath, NULL);
- if (!g_file_test (path, G_FILE_TEST_EXISTS))
- {
- g_free (path);
- path = NULL;
- }
- }
+ /* Next try looking for files in the various theme directories.
+ */
+ if (variant)
+ subpath = g_strdup_printf ("gtk-3.0" G_DIR_SEPARATOR_S "gtk-%s.css", variant);
+ else
+ subpath = g_strdup ("gtk-3.0" G_DIR_SEPARATOR_S "gtk.css");
- if (!path)
+ /* First look in the user's config directory
+ */
+ path = g_build_filename (g_get_user_data_dir (), "themes", name, subpath, NULL);
+ if (!g_file_test (path, G_FILE_TEST_EXISTS))
+ {
+ g_free (path);
+ /* Next look in the user's home directory
+ */
+ path = g_build_filename (g_get_home_dir (), ".themes", name, subpath, NULL);
+ if (!g_file_test (path, G_FILE_TEST_EXISTS))
{
gchar *theme_dir;
+ g_free (path);
+
+ /* Finally, try in the default theme directory */
theme_dir = _gtk_css_provider_get_theme_dir ();
path = g_build_filename (theme_dir, name, subpath, NULL);
g_free (theme_dir);
path = NULL;
}
}
+ }
- g_free (subpath);
+ g_free (subpath);
- if (path)
- {
- GError *error;
+ if (path)
+ {
+ char *dir, *resource_file;
+ GResource *resource;
- provider = gtk_css_provider_new ();
- error = NULL;
- if (!gtk_css_provider_load_from_path (provider, path, &error))
- {
- g_warning ("Could not load named theme \"%s\": %s", name, error->message);
- g_error_free (error);
+ dir = g_path_get_dirname (path);
+ resource_file = g_build_filename (dir, "gtk.gresource", NULL);
+ resource = g_resource_load (resource_file, NULL);
+ g_free (resource_file);
- g_object_unref (provider);
- provider = NULL;
- }
- else
- g_hash_table_insert (themes, g_strdup (key), provider);
+ if (resource != NULL)
+ g_resources_register (resource);
- g_free (path);
+ gtk_css_provider_load_from_path (provider, path, NULL);
+
+ /* Only set this after load, as load_from_path will clear it */
+ provider->priv->resource = resource;
+
+ g_free (path);
+ g_free (dir);
+ }
+ else
+ {
+ /* Things failed! Fall back! Fall back! */
+
+ if (variant)
+ {
+ /* If there was a variant, try without */
+ _gtk_css_provider_load_named (provider, name, NULL);
+ }
+ else
+ {
+ /* Worst case, fall back to Raleigh */
+ g_return_if_fail (!g_str_equal (name, "Raleigh")); /* infloop protection */
+ _gtk_css_provider_load_named (provider, "Raleigh", NULL);
}
}
+}
+
+/**
+ * gtk_css_provider_get_named:
+ * @name: A theme name
+ * @variant: (allow-none): variant to load, for example, "dark", or
+ * %NULL for the default
+ *
+ * Loads a theme from the usual theme paths
+ *
+ * Returns: (transfer none): a #GtkCssProvider with the theme loaded.
+ * This memory is owned by GTK+, and you must not free it.
+ */
+GtkCssProvider *
+gtk_css_provider_get_named (const gchar *name,
+ const gchar *variant)
+{
+ static GHashTable *themes = NULL;
+ GtkCssProvider *provider;
+ gchar *key;
+
+ if (variant == NULL)
+ key = g_strdup (name);
+ else
+ key = g_strconcat (name, "-", variant, NULL);
+ if (G_UNLIKELY (!themes))
+ themes = g_hash_table_new (g_str_hash, g_str_equal);
- if (key != name)
- g_free (key);
+ provider = g_hash_table_lookup (themes, key);
+
+ if (!provider)
+ {
+ provider = gtk_css_provider_new ();
+ _gtk_css_provider_load_named (provider, name, variant);
+ g_hash_table_insert (themes, g_strdup (key), provider);
+ }
+
+ g_free (key);
return provider;
}
+static int
+compare_properties (gconstpointer a, gconstpointer b, gpointer style)
+{
+ const guint *ua = a;
+ const guint *ub = b;
+ PropertyValue *styles = style;
+
+ return strcmp (_gtk_style_property_get_name (GTK_STYLE_PROPERTY (styles[*ua].property)),
+ _gtk_style_property_get_name (GTK_STYLE_PROPERTY (styles[*ub].property)));
+}
+
+static int
+compare_names (gconstpointer a, gconstpointer b)
+{
+ const WidgetPropertyValue *aa = a;
+ const WidgetPropertyValue *bb = b;
+ return strcmp (aa->name, bb->name);
+}
+
static void
-selector_path_print (const SelectorPath *path,
- GString * str)
+gtk_css_ruleset_print (const GtkCssRuleset *ruleset,
+ GString *str)
{
- GSList *walk, *reverse;
+ GList *values, *walk;
+ WidgetPropertyValue *widget_value;
+ guint i;
- reverse = g_slist_copy (path->elements);
- reverse = g_slist_reverse (reverse);
+ _gtk_css_selector_tree_match_print (ruleset->selector_match, str);
+
+ g_string_append (str, " {\n");
- for (walk = reverse; walk; walk = walk->next)
+ if (ruleset->styles)
{
- SelectorElement *elem = walk->data;
+ guint *sorted = g_new (guint, ruleset->n_styles);
- switch (elem->elem_type)
- {
- case SELECTOR_TYPE_NAME:
- case SELECTOR_NAME:
- g_string_append (str, g_quark_to_string (elem->name));
- break;
- case SELECTOR_GTYPE:
- g_string_append (str, g_type_name (elem->type));
- break;
- case SELECTOR_REGION:
- g_string_append (str, g_quark_to_string (elem->region.name));
- if (elem->region.flags)
- {
- char * flag_names[] = {
- "nth-child(even)",
- "nth-child(odd)",
- "first-child",
- "last-child",
- "sorted"
- };
- guint i;
-
- for (i = 0; i < G_N_ELEMENTS (flag_names); i++)
- {
- if (elem->region.flags & (1 << i))
- {
- g_string_append_c (str, ':');
- g_string_append (str, flag_names[i]);
- }
- }
- }
- break;
- case SELECTOR_CLASS:
- g_string_append_c (str, '.');
- g_string_append (str, g_quark_to_string (elem->name));
- break;
- case SELECTOR_GLOB:
- if (walk->next == NULL ||
- elem->combinator != COMBINATOR_CHILD ||
- ((SelectorElement *) walk->next->data)->elem_type != SELECTOR_CLASS)
- g_string_append (str, "*");
- break;
- default:
- g_assert_not_reached ();
- }
+ for (i = 0; i < ruleset->n_styles; i++)
+ sorted[i] = i;
- if (walk->next)
+ /* so the output is identical for identical selector styles */
+ g_qsort_with_data (sorted, ruleset->n_styles, sizeof (guint), compare_properties, ruleset->styles);
+
+ for (i = 0; i < ruleset->n_styles; i++)
{
- switch (elem->combinator)
- {
- case COMBINATOR_DESCENDANT:
- if (elem->elem_type != SELECTOR_CLASS ||
- ((SelectorElement *) walk->next->data)->elem_type != SELECTOR_CLASS)
- g_string_append_c (str, ' ');
- break;
- case COMBINATOR_CHILD:
- if (((SelectorElement *) walk->next->data)->elem_type != SELECTOR_CLASS)
- g_string_append (str, " > ");
- break;
- default:
- g_assert_not_reached ();
- }
+ PropertyValue *prop = &ruleset->styles[sorted[i]];
+ g_string_append (str, " ");
+ g_string_append (str, _gtk_style_property_get_name (GTK_STYLE_PROPERTY (prop->property)));
+ g_string_append (str, ": ");
+ _gtk_css_value_print (prop->value, str);
+ g_string_append (str, ";\n");
}
-
+
+ g_free (sorted);
}
- if (path->state)
+ if (ruleset->widget_style)
{
- char * state_names[] = {
- "active",
- "hover",
- "selected",
- "insensitive",
- "inconsistent",
- "focus"
- };
- guint i;
+ values = NULL;
+ for (widget_value = ruleset->widget_style; widget_value != NULL; widget_value = widget_value->next)
+ values = g_list_prepend (values, widget_value);
+
+ /* so the output is identical for identical selector styles */
+ values = g_list_sort (values, compare_names);
- for (i = 0; i < G_N_ELEMENTS (state_names); i++)
+ for (walk = values; walk; walk = walk->next)
{
- if (path->state & (1 << i))
- {
- g_string_append_c (str, ':');
- g_string_append (str, state_names[i]);
- }
+ widget_value = walk->data;
+
+ g_string_append (str, " ");
+ g_string_append (str, widget_value->name);
+ g_string_append (str, ": ");
+ g_string_append (str, widget_value->value);
+ g_string_append (str, ";\n");
}
+
+ g_list_free (values);
}
- g_slist_free (reverse);
+ g_string_append (str, "}\n");
}
static void
-selector_style_info_print (const SelectorStyleInfo *info,
- GString *str)
+gtk_css_provider_print_colors (GHashTable *colors,
+ GString *str)
{
GList *keys, *walk;
- char *s;
- selector_path_print (info->path, str);
-
- g_string_append (str, " {\n");
-
- keys = g_hash_table_get_keys (info->style);
- /* so the output is identical for identical selector styles */
+ keys = g_hash_table_get_keys (colors);
+ /* so the output is identical for identical styles */
keys = g_list_sort (keys, (GCompareFunc) strcmp);
for (walk = keys; walk; walk = walk->next)
{
const char *name = walk->data;
- const GValue *value = g_hash_table_lookup (info->style, (gpointer) name);
+ GtkCssValue *color = g_hash_table_lookup (colors, (gpointer) name);
- g_string_append (str, " ");
+ g_string_append (str, "@define-color ");
g_string_append (str, name);
- g_string_append (str, ": ");
- s = _gtk_css_value_to_string (value);
- g_string_append (str, s);
- g_free (s);
+ g_string_append (str, " ");
+ _gtk_css_value_print (color, str);
g_string_append (str, ";\n");
}
g_list_free (keys);
-
- g_string_append (str, "}\n");
}
static void
-gtk_css_provider_print_colors (GHashTable *colors,
- GString *str)
+gtk_css_provider_print_keyframes (GHashTable *keyframes,
+ GString *str)
{
GList *keys, *walk;
- char *s;
- keys = g_hash_table_get_keys (colors);
+ keys = g_hash_table_get_keys (keyframes);
/* so the output is identical for identical styles */
keys = g_list_sort (keys, (GCompareFunc) strcmp);
for (walk = keys; walk; walk = walk->next)
{
const char *name = walk->data;
- GtkSymbolicColor *symbolic = g_hash_table_lookup (colors, (gpointer) name);
+ GtkCssKeyframes *keyframe = g_hash_table_lookup (keyframes, (gpointer) name);
- g_string_append (str, "@define-color ");
+ if (str->len > 0)
+ g_string_append (str, "\n");
+ g_string_append (str, "@keyframes ");
g_string_append (str, name);
- g_string_append (str, " ");
- s = gtk_symbolic_color_to_string (symbolic);
- g_string_append (str, s);
- g_free (s);
- g_string_append (str, ";\n");
+ g_string_append (str, " {\n");
+ _gtk_css_keyframes_print (keyframe, str);
+ g_string_append (str, "}\n");
}
g_list_free (keys);
* this @provider.
*
* Returns: a new string representing the @provider.
+ *
+ * Since: 3.2
**/
char *
gtk_css_provider_to_string (GtkCssProvider *provider)
str = g_string_new ("");
gtk_css_provider_print_colors (priv->symbolic_colors, str);
+ gtk_css_provider_print_keyframes (priv->keyframes, str);
- for (i = 0; i < priv->selectors_info->len; i++)
+ for (i = 0; i < priv->rulesets->len; i++)
{
- if (i > 0)
+ if (str->len != 0)
g_string_append (str, "\n");
- selector_style_info_print (g_ptr_array_index (priv->selectors_info, i),
- str);
+ gtk_css_ruleset_print (&g_array_index (priv->rulesets, GtkCssRuleset, i), str);
}
return g_string_free (str, FALSE);
projects / ~andy / gtk / blobdiff