css: Make property parsing functions take a css parser

Instead of reading a string and then passing that in, let the parse
functions use the full power of the parser.

css: Move binding set parsing to strfuncs

cssstringfuncs: Read colors as symbolic colors always

... and then try to resolve them, so static colors get resolved in
advance, just like it was before.

symboliccolor: Allow props == NULL when resolving

If props == NULL in gtk_symbolic_color_resolve(), fail sanely for named
colors. The docs used to say it was not allowed to pass NULL for named
color, but that had problems:
1) You do not know if a color was created that way. This is especially
   hard for generic users (like language bindings).
2) It wasn't even true. Colors using other symbolic colors would also
   fail when trying to resolve their named colors, but the docs didn't
   say so.
And because I want to use the function to resolve static colors early
where possible, I changed things.

cssprovider: Cache if rulesets have inheritable style properties

This provides a huge speedup as we only need to preprocess style
properties when they are indeed inherited. This roughly doubles the
performance of the CSS matcher and brings the time taken by
gtk_css_provider_get_style() from 19% to 7% in my favorite benchmark.

cssprovider: Keep two hash tables per ruleset

One for the style properties, one for the widget style properties.
This way we can make one hash table by pspec which means we don't have
to repeat the pspec lookup.

cssprovider: Add a new setter for rulesets

We now have set-by-pspec (which is used for normal style properties) and
set-by-name (which is used by widget properties).

cssprovider: Refactor handling of rulesets

Keep rulesets as an on-stack/heap structure instead of allocating all
instances separately.
Also, pass a ruleset to the ruleset parser, so we can make the ruleset
parser do lots of fancy things that might be useful for performance.

cssprovider: Refactor code to have a gtk_css_ruleset_matches()

cssprovider: Rename "SelectorStyleInfo" to "Ruleset"

No code changes, just clarification of the name

css: Implement inherit properties

Huge performance hit (slows down things roughly by a factor of 3), but
necessary for CSS conformance and for implementing "inherit" and
percentages.

reftests: Check style property order

Ensure that style properties are read in the correct order, by having a
property twice with vastly different values.

css: Refactor code to do property lookups earlier

We want to ook up the property in the CSS parser, so we can do fancy
things with it. We currently don't but we want to later.

styleproperties: Speed up by not optimizing

g_quark_try_string() takes a lock and then does a hashtable lookup. So
just using a string hash table for properties is faster.

styleproperties: Speed up style_property_lookup()

Use the already existing bsearch version instead of iterating the array
manually.

styleproperties: Use the pspec as the hash table key

The code used the quarked name before, but when we already have the
pspec we want to have a lookup that does not involve quarking. And
lookup is equally fast if we only have the name.

css: Make _gtk_css_selector_matches() take a path length

This will be necessary when handling inherit.

cssprovider: Simplify code

Don't go through an intermediate array when matching styles.

styleproperties: Mark "color" and "font" as inherit

Keeping it identical to CSS 2.1 again

API: Add API to set style properties to be inherit

The API is not used anywhere yet.

cssprovider: Speed up gtk_widget_style_get() property lookups

Previously we got the list of all matching rules and then iterated it to
find the first one that had the property. Now we look while matching
rules, so we don't lookup rules that we don't need.

css: Don't query type for regions

Regions are regions and don't match by type.

reftests: Add a test ensuring selectors don't match children

Previously, the selector "Foo" would not only match Foo widgets, but
also all widgets that are descendants of Foo.

reftests: Add a test for descendant CSS selectors match

In widget hierarchy like "Foo Bar Bar Baz", we want the selector "Foo >
Bar Baz" to match, because it matches the elements 1, 2 and 4.
Previously, the selector only matches the Bar at position 3 and then
failed because it wasn't preceded by a Foo.

reftests: Add a test that checks that * matches regions

reftests: Unset background-image in CSS of test

Otherwise the test screws up when it's set

reftests: Add a check for matching regions only once

tests: Add a test for enum values

css: Raised SYNTAX error when enum value can't be parsed

reftests: Add a test for matching by class

reftests: Add a test for matching by name

reftests: Add a test for matching by subtype

reftests: Add test to check that matching by type works

tests: Add a test to ensure we handle unknown pseudo-classes correctly

1) We want to throw an unknown value
2) We want to skip the whole rule

tests: Add a test for all selector combination

The test contains an error where we complain about a duplicate value for
":hover:hover"

css: No more special code for regions

Just treat regions the same as elements.

css: Rewrite selectors

Selectors now go into their own C file. The new selectors are modeled a
lot closer to the CSS spec. In particular the specificity computation
matches CSS 2.1 exactly.

For details about the why, see also:
http://mail.gnome.org/archives/gtk-devel-list/2011-May/msg00061.html
https://bugzilla.gnome.org/show_bug.cgi?id=649798

cssprovider: Remove a bunch of commented-out code

The code was only kept for reference while writing the new parser, it's
not necessary anhymore.

tests: Be more verbose in error messages.

Also, it makes it easier to copy/paste diffs from the message log...

tests: Add test that ensures we properly parse the color red

tests: Add another parsing test from the css spec

tests: Add parsing test from the css spec

tests: Make the parser fail without assertions

Use the new g_test_fail() function. This way, the testsuite usually
doesn't crash, but actually finishes.

css: Rewrite the parser

Instead of relying on GScanner and its idea of syntax, code up a parser
that obeys the CSS spec.
This also has the great side effect of reporting correct line numbers
and positions.

Also included is a reorganization of the returned error values. Instead
of error values describing what type of syntax error was returned, the
code just returns SYNTAX_ERROR. Other messages exist for when actual
values don't work or when errors shouldn't be fatal due to backwards
compatibility.

tests: Add a test for importing nonexistant files

tests: Add tests for cyclic imports

tests: Add test for recursively importing an identical file

cssprovider: Don't hardcode strings anymore

cssprovider: Add support for strings

cssprovider: Parse strings as identifiers when parsing property values

cssprovider: Add recursion checks for @import

This is pretty important, because otherwise recursions cause crashes.
And if you accidentally change your theme to one that crashes on load,
all your gonna SEGV and then on reboot, gdm tries to load the theme...

cssprovider: Allow storing the parent stylesheet

cssprovider: Don't fail if an import doesn't work

cssprovider: Reimplement gtk_css_provider_load_from_path()

Call gtk_css_provider_load_from_file() instead of the internal function.
This has two advantages:
1) It simplifies the code a lot
2) It gets rid of GMappedFile usage. GMappedFile does not work
   everywhere, so this is finally portable.

cssprovider: Make @import use the new load_internal() func

cssprovider: Make load_internal() load the contents

This way, we achieve two things:
1) We can unify file loading to one location
2) We can emit the error from file loading using the parsing-error
   signal. This is very useful for @import handling in particular.

cssprovider: Introduce gtk_css_provider_take_error_full()

Emits the error without the need for a scanner. Also simplifies
gtk_css_provider_take_error() because we now can assert an available
scanner at all times.

cssprovider: More error handling into load_internal()

Now the parsing functions starting at parse_stylesheet() don't have to
care about errors anymore.

cssprovider: Add a load_internal function that all loads chain to

tests: Order files by name before adding them as tests

Ensures that the order of tests is not dependant on your hard disk.

cssprovider: Keep base url in the scanner

And provide a nice function to query it. Simplifies a bunch of code.

cssprovider: Move properties to scanner constructor

So we can set them in one place.

cssprovider: Don't store scanner in the struct

Instead, create scanners whenever we actually parse stuff.

cssprovider: Get rid of gtk_css_provider_reset_parser()

Instead call gtk_css_scanner_reset(). There is nothing else we could
need to do.

cssprovider: Keep track of passed in error differently

Instead of having an error member in the CSS provider's private struct,
connect a signal handler when an error is passed in. This has two
advantages:
1) It makes the code clearer as we don't have to keep track of an error
   member anywhere.
2) It causes a non-emission of the g_warning() when an error was passed
   in, because it only triggers when no signal handlers are connected.
   So we get identical behavior to GTK 3.0 where warnings where only
   emitted when no error was passed in.

cssprovider: Do error handling differently

Instead of aborting a parse whenever we encounter an error, parse to the
end. But if a GError was passed in, reset the provider completely as if
nothing had been parsed.

cssprovider: Emit a g_warning() when a css file is erroneous

... and no other error handler is active. See the source code comment
for the reasoning.

cssprovider: No need to restore after @import parsing

With the recent changes, this just resets the error, and we don't the
error reset from subfile parsing.

cssprovider: Store current properties and selectors in scanner

They don't belong in the css provider

cssprovider: Use scanner variable instead of priv->scanner

cssprovider: Pass scanner argument explicitly to error functions

cssprovider: Update the scope modifying functions

Make them take the scanner as an argument, as that's what gets changed,
not the CssProvider.

cssprovider: track state in the scanner

This way, we don't have to do magic copies when we create a new scanner
for a subfile.

cssprovider: Add a private structure to the scanner

So far, it's unused

cssprovider: Add a custom gtk_css_scanner_destroy() function

So far, it does nothing

cssprovider: Pass the scanner explicitly to parse_stylesheet()

This is the first step in decoupling the scanner from the provider.

cssprovider: No need to set user data anymore

tests: Make css-parser test take files as argument

Takes the css files to be tested as argument and runs with it.

tests: Add a test for border parsing

tests: Add new test checking weird behavior for declarations

cssprovider: Clean up declaration parser to conform to more tests

The tests will follow with the next commits

cssprovider: Rework declaration parsing loop

The new loop can cope better with invalid identifiers and manages to
resume parsing properly.

tests: Add CSS integer parsing tests

tests: Add test for booleans to CSS tests

cssprovider: Don't fail with invalid syntax when parsing a value

Instead, raise a PROPERTY_VALUE error, find the next semicolon or
closing bracket and resume parsing.

tests: (Try to) print the actual enum value in the errors file

Instead of gtk-some-error-quark 5, print
GTK_SOME_ERROR_SOMETHING_FAILED.

test: Add a bunch of default properties to the CSS parser

One of each type, so that we can test the parsing of them.

css: Overhaul value parsing

Value parsing only sometimes emitted errors. Sometimes it didn't emit
errors but ignored the value, sometimes it took a default, sometimes it
converted it to something it deemed suitable.

While refactoring, I moved the whole GValue <=> char * conversion
routines to a separate file, to make navigating the core css provider
easier.

cssprovider: Remove now useless variables

cssprovider: Remove scanner_report_warning() function

That function does superbad stuff just to print out something on stderr.
Don't do superbad stuff.

tests: Make CSS parser pass NULL as error.

We are trapping errors via signals now.

tests: Check errors in css test

tests: Change the way the code does diffs

Use a temp file for intermediate storage and properly unlink that
tempfile after the diff is done.

cssprovider: use INVALID_SYNTAX for unexpected token error

cssprovider: Change declaration parsing for error reporting

Previously, we only checked for errors after parsing the full
declaration. Now we detect errors with the property before even
attempting to parse its value.
The benefit here is that the error reporting reports the correct line
and position numbers.

API: cssprovider: Add more error codes

API: cssprovider: Make error a signal

cssprovider: Handle errors completely via new error functions

cssprovider: Provide better API to set errors

cssprovider: Have a private error variable