menubar: Port to draw vfunc

textview: Port to draw vfunc

separatortoolitem: Port to draw vfunc

toolbar: Port to draw vfunc

toolbar: Don't propagate events to placeholders

In particular don't when that's done using uninitialized memory

toolpalette: Port to draw vfunc

treeview: Port to draw vfunc

treeview: Update rubberbanding code to Cairo

treeview: Do not put different windows in else if branches anymore

treeview: Use Cairo for all bin window drawing

treeview: Invalidate on expander changes, don't just repaint

Repaints are supposed to be initiated by GDK, not by random repaints.

treeview: Draw empty tree view with Cairo

API: Add gtk_container_propagate_draw()

Equivalent to gtk_container_propagate_expose(), just for the draw event.
Also port GtkContainer to the draw vfunc

widget: Store the expose event in the cairo_t, not just the window

This way we can grab it for propagating expose events. Not sure if we
need to do this once we're all Cairo, but for now we do.

accellabel: Port to draw vfunc

label: Port to draw vfunc

scale: Port to draw vfunc

range: Port to draw vfunc

range: Make drawing use a single cairo context

tests: Remove ability to set backend from testfilechooser

There's no backends anymore

arrow: Port to draw vfunc

calendar: Port to draw vfunc

calendar: Fix drawing order for windows

calendar: Create one cairo_t per expose event and pass it around

cellview: Port to draw vfunc

spinner: Port to draw vfunc

image: Port to draw vfunc

image: Always render the whole image

Otherwise effects like blur etc will have funny seams on repaints.
Oh, and also, the draw vfunc doesn't have an equivalent to event->area
;)

spinbutton: Port to draw vfunc

entry: Remove gtk_entry_is_drawable() checks when painting

entry: Port to draw signal

entry: Split else ifs into separate if statements

Preparation for the draw vfunc

entry: Add bug reference to workaround

API: Add gtk_cairo_should_draw_window()

See the function documentation for its purpose and the next commit(s)
for examples on how to use it.

ruler: Port to draw signal

API: ruler: Change draw_pos vfunc to take a cr, width and height

Also refactor code to use it

API: ruler: Remove private ruler draw functions from header

ruler: Change the way the ruler handles exposes

1) Don't directly draw in motion-notify, instead call
   gtk_widget_queue_draw()
2) Don't draw ticks in expose events anymore, only when they were
   changed

API: ruler: Change draw_ticks vfunc

We now pass in a cairo_t of the backbuffer and the width and height of
the widget/backbuffer, so the vfunc has a place to draw to.

ruler: Don't create two cairo_t's

separator: Convert to draw signal

hsv: Convert to draw signal

progressbar: Port to new draw signal

widget: Add draw signal

For now, the draw signal is emitted by default from the expose event, so
widgets can chose to either implement the expose event or the draw
function.
This is for the transitional period from expose event to draw signal.

Note that for now subclasses can only implement the draw function when
none of their parents implemented the expose event.

API: Add API to query width and height when rendering

The functions are gtk_widget_get_allocated_width() and
gtk_widget_get_allocated_height().

They are currently identical to using width/height of
gtk_widget_get_allocation(), but are introduced for ease of use (no need
to use a custom struct) and to free people from having to think about
allocation.x and allocation.y (which is where the origin of the cairo
context in GtkWidget::draw is located).

API: add gdk_cairo_get_clip_rectangle() convenience API

build: Depend on cairo-gobject

We want to use cairo types for signals and properties, so we need to
depend on the library providing them.

Create cairo context after running validate_visible_area()

validate_visible_area() can change the vertical adjustment and thus
trigger window moves/scrolls.  This seems to change the surface for
which gtk_tree_view_bin_expose() just created a cairo context.  Creating
the cairo context after the call to validate_visible_area() fixes
such crashes.

quartz: Get size from wrapper, not drawable

Make the docs build

API: Remove GdkColormap

gdk: Remove nonexisting function from internal header

API: Remove colormap handling from GdkScreen

In particular, the following functions are gone:
- gdk_screen_get_default_colormap()
- gdk_screen_set_default_colormap()
- gdk_screen_get_system_colormap()
- gdk_screen_get_rgba_colormap()

API: Remove gdk_drawable_get_colormap()

And with it, remove any notion of colormaps from GdkWindow. In
particular, X11 windows will now not set attrs.colormap when calling
XCreateWindow.

x11: Keep a default X Colormap in every visual to construct windows with

This way, we can specify a colormap when constructing windows. And ew
must do that to avoid BadMatch from XCreateWindow when we use a
different visual.

x11: Use G_DEFINE_TYPE() to define GdkVisual

Also add a priv pointer to GdkVisual and use it for the GdkVisualPrivate
structure. Then Make GdkVisualPrivate actually private to
gdkvisual-x11.c and make other callers use proper function calls to
access it.

x11: Set background color bypassing colormaps

Direct and TrueColor visuals don't alloc colors, so they don't need to
fiddle with colormaps. Just copy the code that computes the pixel value
from gdkcolor-x11.c and use it. For other visual types, don't set the
background color and fallback to background = None.

API: Remove colormap member from GdkWindowAttr

Also remove all code that cares about differing colormaps for child
windows.

quartz: Compare visuals for RGBA, not colormaps

API: Remove gdk_drawable_get_display()

gdk: gdk_drawable_get_display() => gdk_window_get_display()

gtk: gdk_drawable_get_display() => gdk_window_get_display()

API: Add gdk_window_get_display()

x11: Use gdk_window_get_screen() in the testutils

API: Remove drawable getters for visual, screen and depth

Removed and replaced are:
gdk_drawable_get_visual() => gdk_window_get_visual()
gdk_drawable_get_screen() => gdk_window_get_screen()
gdk_drawable_get_depth()  => gdk_visual_get_depth
                                          (gdk_window_get_visual())

quartz: Remove unused _gdk_quartz_colormap_get_cgcolor_from_pixel()

gdk: gdk_drawable_get_screen/visual => gdk_window_get_screen/visual

gtk: gdk_drawable_get_screen/visual => gdk_window_get_screen/visual

API: Add gdk_window_get_visual() and gdk_window_get_screen()

Now that we store the visual in the GdkWindow, these are rather trivial
accessors.

gdk: store the visual in the GdkWindowObject

API: Remove gdk_drawable_set_colormap()

API: gdk_pixbuf_get_from_drawable() => gdk_pixbuf_get_from_window()

The Colormap argument needed to be removed, so the renaming is just a
side effect.

dnd: Remove unused colormap code

API: Remove setters and getters for default colormaps

This removes:
gtk_widget_set_default_colormap()
gtk_widget_get_default_colormap()
gtk_widget_get_default_visual()

Colormaps are gone, and the default visual is the system visual of the
default screen.

API: Remove colormap setting and getting from GtkWidget

gtk_widget_get_colormap() and gtk_widget_set_colormap() are gone. They
are replaced by visuals.

style: Move from colormaps to visuals

testgtk: Check visual, not colormap for RGBA availability

gtk-demo: Remove colormaps from window attributes

gdk: Create paint surfaces of the same content as the window

Previously, we failed to create RGBA double buffers for RGBA windows.

trayicon: Use XClearArea

gdk_window_clear_area() isn't smart enough to clear to a parent pixmap
that is part of a window that GDK doesn't manage.

testgtk: gtk_widget_set_colormap() => gtk_window_set_visual()

trayicon: Change to use gtk_window_set_visual()

One less user of colormaps, and the code is cleaner, too!

window: Keep track of own visual

Add gtk_window_set_visual() and a "visual" property. This allows
changing the window visual to the rgba one and other awesome things
(like implementing the trayicon spec).

gtk: Change gtk_widget_get_visual()

We now return the visual of the topmost widget in widget's stack that
has a window. If no such widget exists, but a GtkWindow is a parent, we
return its visual (note: GtkWindow Will gain support for setting visuals
soon). If a window doesn't exist, we return the system visual of the
default screen.

This change has multiple reasons:
- Colormaps are gone
  Now visuals are the most important resource for creating GDK windows.
- Allow widgets to change visuals for themselves and their children
  By walking the hierarchy, we ensure that child windows have the same
  visual as their parents by default. But widgets can still select a
  different visual in their realize handler when creating the GDK
  window.
- Have a replacement for gtk_widget_set_colormap()
  That function is going to die with colormaps, so a replacement was
  needed. That replacement is going to be gdk_window_set_visual().
- Make a future transition to no-window GTK easy
  Should we ever attempt a change to make all GTK widgets no-window, a
  gtk_widget_set_visual() would be silly, as only widgets with windows
  can have their own visuals. So only toplevels will gain the ability to
  change it.

tests: Don't set colormap when creating offscreen windows

testgtk: Don't set colormap when creating GDK windows

gtk: Don't set colormap anymore when creating GDK windows

Colormaps are about to be removed, so not using them sounds like an
awesome idea.

testgtk: No need to set a custom colourmap here

spinner: We're a no-window widget, so setting a colormap does nothing

style: Remove depth member from GtkStyle

gdk: Remove _gdk_drawable_get_source_drawable()

Now that we don't create pixmaps anymore, this function is not needed
anymore. The indirection it did previously is now basically moved to
gdk_window_create_similar_surface()

style: Remove depth checks in render functions

There's no need for them anymore now that we render with Cairo.

x11: Remove some unused macros

x11: s/GDK_DRAWABLE_DISPLAY/GDK_WINDOW_DISPLAY

tests: No need to allocate colors anymore

API: Remove gtk_widget_push_colormap()

And of course, gtk_widget_pop_colormap() is gone, too.
No replacement is necessary, the function is basically unused.

gdk: Remove pixmap debug category

It's not used anywhere anymore.

gdk: Remove GdkPixmap

All iusers of it are gone, so it's now time to let go.
cairo_surface_t is a full replacement, combined with
gdk_window_create_similar_surface().

Include OS X system headers

tests: Remove GdkPixmap from test

It's not used anymore. (Was it ever?)