cssparser: Move symbolic color parser to gtksymboliccolor.c

symboliccolor: Turn this into a GtkCssValue

css: Add a shorthand 'transition' property

shorthand: Add ',' to value_is_done_parsing()

css: Remove old animation code

Deprecate public API where appropriate and make it no-ops.
Remove all calls to it.
Get rid of the 'transition' css property.

For now, this means spinners don't animate anymore.

css: Remove GtkCssNumber

It's completely replaced by GtkCssNumberValue now.

linear-gradient: Convert from GtkCssNumber to GtkCssValue

cssvalue: Convert border-image-width to border value

cssvalue: Add a border value

.. and parse border-image-slice with it.

cssvalue: Add a cssvalue for background-size

cssvalue: Add a custom value for repeats

In particular, that's background-repeat and border-image-repeat.

Also, fix up the border-image shorthand to allow any order.

cssvalue: Add a value for background-position

cssvalue: Add a css value for engines

cssstyleproperty: Convert binding sets

Instead of keeping a custom GPtrArray, keep it as a GtkCssArrayValue of
GtkCssStringValue. This way, we gain equality comparisons and print
functions for free.

cssvalue: Add a value for border-radius corner properties

... and convert those properties to this value.

css: Make outline-offset a number property

shadow: Add equal and transition support

... and enable transitions for the shadow properties.

cssvalue: Add GtkCssShadowsValue

This is necessary because shadows get treated differently from other
lists when transitioning.

tests: Add a parsing test for shadows

shadow: Rewrite to store contents as values

shadow: Make color a GtkCssValue

cssvalue: Make GtkCssShadowValue only hold one shadow

All the properties now are a GtkCssArrayValue of GtkCssSadowValue.
GtkCssArrayValue already does everything we want, so no need to
duplicate its funtionality.

themingengine: Make _gtk_theming_engine_paint_spinner() args const

cssarrayvalue: Redo parsing arrays

Does 3 things:
1) Introduce a "none" array signleton
2) Get rid of memleaks in error paths
3) Reduce code in parse funcs

stylecontext: Don't queue_resize() all the time

When a parent style context exists, there's no need to queue_resize() on
the widget, because the parent widget will call
gtk_style_context_validate() on us and _then_ we can call queue_resize()
if we have to.

cssstyleproperty: Mark all animatable properties

Only the ones that can be animated are marked of course. So more work is
needed.
This is important for
  transition-property: all;
because it'll just animate all the properties that can be.

cssstyleproperty: Add _gtk_css_style_property_is_animated()

css: Move enum to the only source file using it

cssvalue: Add transition support for images

cssimage: Add GtkCssImageCrossFade

Supports the cross-fade() css notation the way the old CSS3 specs did.

The main reason for adding it is supporting image transitions though.

cssvalue: Add _gtk_css_value_to_string()

This is a tiny wrapper around _gtk_css_value_print().
It's intended for usage in gdb and printf debugging.

cssstyleproperty: Add transition properties

cssvalue: Add GtkCssEaseValue

This is supposed to hold the transition-easing-function and
animation-easing-function values.

cssvalue: Add a GtkCssValue for idents

css: Add <time> type to css number stuff

computedvalues: Fix signage error

css: Remove _gtk_css_computed_values_get_value_by_name()

Now that we use an enum for the IDs, we don't need that function
anymore.

stylecontext: Convert _gtk_style_context_peek_property()

Take the property id instead of the name.

css: Add an enum for all the style properties

So instead of using
  _gtk_css_style_property_get_id (GTK_CSS_STYLE_PROPERTY
        (_gtk_style_property_lookup ("name")))
one can now use
  GTK_CSS_PROPERTY_NAME

Esaier, eh?

cssvalue: Add _gtk_css_value_transition()

Returns a value that transitions between start and end or %NULL if the
values cannot be transitioned.

So far, all implementations but numbers and rgba return NULL.

cssvalue: Do a hacky conversion of font-size to a number value

Just store the value as px for now.

The font-size property needs a complete makeover anyway.

cssvalue: Convert 'font-family'

It's now a CssArrayValue filled with CssStringValue

cssvalue: Add a custom value for strings

cssprovider: Store widget style value as string

There's no need to turn it into a GtkCssValue, it's always a string.

cssvalue: Add GtkCssArea to the enum values

... and get rid of its GType.

This makes it non-queryable using gtk_style_context_get() but it used to
be a private struct anyway.

switch: Set ACTIVE state flag with is_active property

stylecontext: Keep the main style data around until revalidation

stylecontext: Keep per-styleinfo data

Instead of having one global data structure, keep it per style info.
This means that we can do special tricks on the "global" style data.

stylecontext: Make style_data_lookup() not take a state anymore

Instead, use the current state of the style context.

widget-factory: Add spinners

Doesn't look very well, but if somebody cares about that, he can fix it
(hint hint)

cssvalue: Add a cssvalue for images

cssvalue: Add enum values for the pango enums

And fix the parser to conform to the CSS spec while at it.

cssvalue: Make border styles be their own value

... and add them via gtkcssenumvalue.[ch] which will be used for all
enums.

cssvalue: Add a custom RGBA value

Note: custom CSS properties still use the default GtkCssValue and always
will.
So there is a difference in css values used between those, even though
they both carry a GdkRGBA payload.

cssstyleproperty: Make assign_value a vfunc

customproperty: Implement assign vfunc

I'm going to overwrite the GtkCssStyleProperty one, so better keep this
one.

shadow: Also rename files

shadow: Rename to GtkCssShadowValue

I don't want to confuse css values with other stuff, so there.

cssvalue: Remove unused function

shadow: Move parse function into GtkShadow

This way, we have less public API.
And gtkcssstylepropertyimpl.c looks less scary (only 1624 lines now).

shadow: Make this a GtkCssValue

shadow: Remove _gtk_shadow_get_resolved()

It's unused

stylepropertyimpl: Make shadows unqueryable

Normal APIs couldn't use GtkShadow anyway as the type was private.

theming: Use peek_property() calls to query shadows

cssvalue: Split number values into their own class

cssstyleproperty: Make query func a vfunc

This will be needed soon.

customproperty: Add our own query_value function

I'm about to change the CssStyleProperty one, so better copy things
here.

cssstyelproperty: Rempove specified-type and computed-type props

This removes the necessity to keep a GType associated with style
properties and code can now make use of GtkCssValue completely.

styleproperty: Remove default parse function

... and assert every style property brings its own.

stylepropertyimpl: Add remaining parse functions

styleproperty: Simplify compute_value function

The compute_value fallback path is only needed for custom properties,
the real style properties have custom compute functions if they need
them already.

css: Move shadow parse/print/compute funcs

They don't belong in the style funcs, as those are for custom
properties, and the shadow type is private.

stylepropertyimpl: Add parse funcs for enums

stylepropertyimpl: Add color parsing function

This is in preparation for removing the specified type and computed type
properties from GtkCssStyleProperty, which is in preparation for really
using GtkCssValue classes and not GTypes.

customproperty: Don't rely on querying style property

This way, we can remove type madness from GtkCssStyleProperty later.

styleproperty: Make gtk_style_property_register() not be valist

Instead, make the caller create a GtkCssValue in advance.

cssvalue: Add _gtk_css_value_equal()

For now, we return FALSE for all default css values, so this is not very
useful.

I also think of this as an optimization equal, not a guaranteed equal,
because we don't even have a notion of what "equal" means.

For example, for background-repeat, "repeat, repeat" and "repeat"
are functionally equivalent. But the cssvalue has no idea that it's used
for background-repeat.
As a more complicated example, "repeat, no-repeat" and "repeat" are
equal to what one sees as long as there's only one image listed
background-image-source. But once you start transition'ing to an image
with 2 sources, it's different...

tests: Change expected errors to conform with output

This change isn't strictly correct, but I can't be bothered until we get
a tokenizer that can really differentiate between allowed values and
invalid syntax.

cssparser: Use _gtk_css_parser_error_full()

cssparser: Add _gtk_css_parser_error_full()

styleproperty: Make _gtk_style_property_parse_value() return a CssValue

Also split out initial/inherit handling into a custom GtkCssValue class.

css: Remove _gtk_css_style_property_is_specified_type()

That check is going to be refactored away.

cssvalue: Add a CSS value for arrays

Make the value auto-cycle its child values, so it can be used for
background properties.

cssvalue: Remove _gtk_css_value_new_take_gvalue()

Having two constructors from GValues complicates refactorings, so I'd
rather not have them.

cssvalue: Get rid of unused functions

styleproperty: Make _gtk_style_property_query() take a GValue

... and don't make it return a GtkCssValue. We want to use this for
compat with the old GValue APIs after all...

styleproperty: Make print_func take a GtkCssValue

Also, constify GtkCssValue getters, so we can pass a const GtkCssValue
to the print_func.

cssvalue: Make the structure vtable-based

Don't use real classes, just a vtable.

styleproperty: Add support for equal_func

stylecontext: Don't clear cache when only state changes

This takes more memory, but changes to backdrop or active state are
quite expensive otherwise.

cssmatcher: Use quarks for classes

styleproperty: Add a function to compare values for equality

and default to never compare them as equal.

cssvalue: Constify a bunch of APIs

cssvalue: Remove unused functions

stylecontext: Really queue style changes

Instead of instantly applying a new style, just mark the context as
invalid. Only apply the new style at layout time.

stylecontext: Optimize the common case of "style didn't change"

gtk: Make widget only invalidate widget positions

Instead of resetting them completely

window: Set parent context instead of just resetting style

Otherwise the inherit properties won't inherit properly.

widget: Replace reset_style() calls

... with finer grained _gtk_widget_invalidate_style_context() calls.

widget: Don't go via path when resetting style

Instead, invalidate the path when the style context changes. And
invalidate the style context directly.