GtkStyleContext: Add the start of a default set of class names/regions.

Theming documentation fixes

2 functions were not in -sections.txt, and GtkStyleSet was renamed
to GtkStyleProperties.

GtkStyleContext: Fix merging of local and global providers.

GtkStyleProperties: Merge font descriptions on merge()

This is necessary so incomplete font descriptions are ensured to have
family and size.

GtkSymbolicColor: Take const GdkRGBA in new_literal().

Document gtk_render_* functions.

Add gtk_render_activity()

This method will render progress bars and spinners, these should
handle active and inconsistent states' animation progress in order
to perform animations.

GtkThemingEngine: draw resize grip through render_handle().

GtkJunctionSides is used instead of GdkWindowEdge, GtkStyle
implementation has changed to use GtkStyleContext's.

GtkWidget: Trigger state change transitions on state flags change.

This makes state transitions automatic for non-complex widgets, complex
widgets such as GtkTreeView still need to notify state updates themselves.

GtkToolItemGroup: Set widget state as state flags.

GtkToggleButton: Set widget state as state flags.

GtkRadioButton: Set widget state as state flags.

GtkNotebook: Set widget state as state flags.

GtkMenuItem: Set widget state as state flags.

GtkMenu: Set widget state as state flags.

GtkExpander: Set widget state as state flags.

GtkEntry: Set widget state as state flags.

GtkComboBox: Set widget state as state flags.

GtkButton: Set widget state as state flags.

Implement widget states as a set of flags

gtk_widget_(set|unset|get)_state_flags() has been added, using GtkStateFlags
to represent the widget state. GtkStateType API has been implemented on top
of the new one.

Document missing value in GtkStateFlags

s/GtkStyleSet/GtkStyleProperties/

The former name had oddities such as gtk_style_set_set() and such,
so the new name is nicer in that regard and not much longer.

GtkWidget: Ensure name changes involve a style context update.

Rely only on fg/bg colors.

"foreground-color" has been renamed to just "color" as in regular CSS,
and the "text-color" and "base-color" properties have been removed. The
default CSS has been changed to have widgets cope with this change.

GtkCssProvider: Fix parsing of concatenated classes.

Now selectors such as:

 GtkWidget#name.class1.class2
 #name.class1.class2
 .class1.class2

are parsed correctly, being meaningful for a widget defining several
classes.

GtkThemingEngine: Use ::name when registering style props.

GtkThemingEngine: Add ::name construct only property

This property is to be set by theming engines, the name set will be favored
over the object type name when registering custom properties, making possible
something like:

-Clearlooks-border: blah;

GtkStyleSet: Prevent from possible underflow.

GtkCssProvider: Parse alpha() symbolic colors.

The "alpha" symbolic color modifies a passed color's alpha by a factor,
the syntax would accept things like:

background-color: alpha (@bg_color, 0.8);
foreground-color: alpha (shade (@fg_color, 0.8), 0.5);

GtkSymbolicColor: Add gtk_symbolic_color_new_alpha()

This function modifies the alpha channel of a color, multiplying
it by a factor.

GtkCssProvider: Make default style depend more on custom colors.

GtkStyle: Get to style GtkCellRendererText text.

GtkThemingEngine: render 0-radius frames with 3D-like 45° corner effect

GtkThemingEngine: Clear the background for .background class

GtkStyle: translate active state in paint_flat_box().

GtkCssProvider: Update end string when misparsing symbolic colors.

GtkCssProvider: Allow '\t' when parsing values.

GtkSymbolicColor: Initialize alpha when resolving shades.

GtkThemingEngine: Improve rendering of inset/outset borders.

GtkCssProvider: Improve default CSS.

GtkStyle: Handle scrollbar buttons.

Do not shade alpha values.

GtkStyle: Match "trough" and "slider" detail strings.

This is so scrollbars can be themed throught the "trough" and
"slider" classes.

Use GdkRGBA all around in GtkStyleContext.

GtkStyleSet: Register the border-style and border-color properties

This is also implemented in the theming engine, although the default
CSS should be using it in order to theme buttons, troughs, sliders
and such.

GtkStyleContext: '_' prefix the structs, gtk-doc prefers this.

GtkWidgetPath: turn into a boxed type.

GtkStyleContext: s/set/add/ and s/unset/remove/ for classes/regions.

Several classes and regions may be set to GtkStyleContext, so rename
the functions to be more intuitive.

GtkThemingEngine: Honor border-radius in render_background().

GtkStyleSet: Register the "border-radius" property

GtkStyleContext: Update function declaration in header.

GtkCssProvider: Make it able to parse enums.

GtkCssProvider: Run through the widget path in the correct order.

Comparing a selector with a widget path was being done backwards since
the change to use GtkContainer::get_path_for_child().

Make loading of theming engines from modules work

GtkStyleContext: Add gtk_style_context_new().

GtkCssProvider: Parse default/sorted region flags.

GtkCssProvider: Parse missing widget states.

Change semantics of the methods to check whether an animation is running.

It actually messed up with the state being actually set, and having a
transition animation running for it. Now this dichotomy is removed, and
gtk_style_context_state_is_running() only checks whether an animation is
running, leaving state checking to flags & GTK_STATE_FLAG_*.

GtkStyleContext: Actually store region ID when starting an animation.

Add theming docs

Both API and file format is documented, there's still missing
a migration doc though.

Remove GtkOrientation parameter from gtk_render_handle().

The case for paned can be guessed out from the height and width,
for handlebox the orientation parameter doesn't make much sense,
and this way it could also be used for resize grips.

Use cairo gobject support instead of a new boxed type.

GtkGradient: Handle symbolic gradients.

The css parser has been modified to parse correctly radial gradients:

background-image: -gtk-gradient (radial,
                                 center center, 0,
                                 center center, 0.8,
                                 from (#000), to (#fff));

The theming engine has been modified to correctly animate these,
as well as transitions between different pattern types.

Gtk9Slice: Fix stretch case.

GtkWidget: Store GtkStyleContext in private struct.

GtkStyleContext: Cache style properties accross class/region changes.

GtkContainer: Add method to get the GtkWidgetPath for a child.

This is now used throughout in order to have the full path for a given widget,
including intermediate named regions, the default implementation just returns
the GtkContainer's path copy, no intermediate regions between.

GtkStyleContext: Fix animation framework to work with the new draw() semantics.

Invalidation region coalescing now happens recursively as draw() runs, and the
widget's x/y as now drawing coordinates are 0,0 based.

GtkCssProvider: Add support for @import rules

Now other CSS files can be referenced from the currently parsed file:

@import url (other-file.css);
@import url (/some/file.css);

GtkCssProvider: no need for resetting the parser prior to parsing data

This is done anyway on each iteration to parse_rule() in parse_stylesheet()

GtkCssProvider: improve file paths parser.

It will now return a full path, and check about the file being sane.

GtkCssProvider: Transform custom colors to a @define-color rule.

Given there are other rules such as @import (which will be supported),
keep a sane namespace here, so for (re)defining a color name, in the CSS
file it will look like:

@define-color color-name #fff;
@define-color other-color mix (@color-name, #f00, 0.4);

GtkThemingEngine: Do not return a const GtkThemingEngine on load()

Plug some leaks.

Fix typo in the Gtk9Slice parser.

GtkButton: Notify on prelight state change.

GtkThemingEngine: Implement animations between gradients/colors.

GtkSymbolicColor: Use G_DEFINE_BOXED_TYPE

GtkStyleContext: Store animation region for a bunch of paint operations.

GtkStyleContext: Invalidate whole window if no invalidation region is obtained.

GtkCssProvider: use mapped file to read CSS files.

GtkCssProvider: unset filename on load_from_data()

GtkThemingEngine: Use border-image to render borders if an image is available.

GtkCssProvider: Add a parser for 9slice typed properties.

The value it parses is similar to the border-image CSS3 property,
so strings like this will be accepted:

  border-image: url (foo.png) 4 3 4 3 repeat repeat;

the image path is relative to the parsed CSS file dirname if no
absolute path is provided.

Register the border-image property

It will contain a 9-sliced image, so it can be rendered as rectangles with any
dimensions.

Add Gtk9Slice

This is a private boxed object to contain information about a border image
in order to render it in a size independent way.

GtkSettings: Add a new provider for the theme CSS file.

GtkStyleContext: Add gtk_style_context_reset_widgets()

This function recalculates the style for all widgets on a screen.

GtkCssProvider: Add gtk_css_provider_get_named()

This functions loads a CSS file from a installed theme.

Add generic providers per-screen.

The providers are added as soon as gtk GtkSettings object for the screen
is created.

GtkStyleContext: invalidate context when setting the screen

GtkWidget: Set style context's screen before the widget_path.

This is so the style context has all necessary information before
triggering a style change on setting the path.

GtkStyleContext: Add gtk_style_context_[add|remove]_provider_for_screen()

These functions allow per-screen style providers. also, the changed signal
will be emitted whenever a style context changes.

GtkWidget: Add gtk_widget_reset_style().

This function is analogous to gtk_widget_reset_rc_styles(),
updates style recursively on a widget.

GtkWidget: Add the style-updated signal

This signal is emitted whenever the widget's style changes.

GtkStyle: Protect against padding being NULL

GtkStyleContext: Add gtk_style_context_invalidate().

This function will regenerate all styling information.

GtkStyleSet: Fix typo

GtkThemingEngine: use background-image in render_background()

GtkStyleSet: Register a "background-image" property.

Ironically, it currently just handles gradients, the name is to conform
to current CSS gradient implementation trends.