Updated Hungarian translation

Iconification using _NET_WM_STATE_HIDDEN hint if supported by WM

If the Window Manager supports the _NET_WM_STATE_HIDDEN, we use it to use
the _NET_WM_STATE protocol when de-iconifying windows (iconification is
unchanged, via XIconifyWindow). Additionally, we no longer interpret all
UnmapNotify events for our window as the result of iconification.

(Based on patch by Tomas Frydrych <tf@linux.intel.com>)

Updated POTFILES.in and POTFILES.skip

Annotate gdk_window_get_frame_extents

"rect" is an output parameter

image: handle PROP_STORAGE_TYPE in get_property()

Fallout from GtkIconHelper transition.

GtkColorChooser: Correct the signal registration

xi2: add some debug output for smooth scroll events

gtk-demo: fix the colorsel example

It is necessary to hide the dialog on "response", else it won't
go away.

Updated Spanish translation

Require XInput2.h in X11 backend

Also remove support for XInput.h

reftests: Add a rendering test for sibling matching

tests: Add parsing tests for sibling selectors

selector: Add sibling seletors

"a + b" and "a ~ b" selectors now work, provided the widget supports
siblings.

selector: Pass the sibling id around all the time

The reason for this will become apparent with the followup patches.

selector: Redo from list to array

Should save ~30% of memory

selector: Introduce gtk_css_selector_previous()

tests: Add a test for using the same selector multiple times

css: Rewrite selectors

Previously we kept a Selector object for every "simple selector" (term
from CSS spec). Now we keep one for every match operation. So given the
selector
  ".a b:focus"
we will have 4 elements:
  - pseudoclass ":focus"
  - element "b"
  - match any desendant (the space)
  - class ".a"
Each of those is represented by a "selector class" which is basically
the collection of vfuncs for this selector.

selector: Remove a misleading error message

Duplicate selectors are indeed fine and shouldn't cause errors.
You want to use them to up specificity.

css: Move selector parsing code into a custom function

Quartz: Fix incompatible types in assignment

NSEvent -scrollingDeltaX and -scrollingDeltaY aren't defined before
10.7, so objc assumes that they return a pointer. Trying to cast to a
float generates a compiler error.

Fix compile error from splitting bitmask code

GtkBitMask was typedef'd twice.

Bug 655065 Build failure on OS X 10.7 Lion

Remove LDDADS and setting each object file's LDDAD to it; just set a global LDDAD.

Updated Serbian translation

Fix build with XI2.x for x < 2

range: Use the correct size for scaling

When scaling the scroll delta, always use the 'large' dimension
of a range widget. When dx was 0, the code code accidentally
use the small dimension.

gdk,xi2: Ensure scroll valuators are reset on window/device switch

This is in order to avoid scrolling glitches as the device causing
scrolling to happen or the Window receiving the events changes.

scalebutton: Set GDK_SCROLL_MASK explicitly

selecting for button press/release doesn't suffice anymore to
get scroll events.

spinbutton: Set GDK_SCROLL_MASK explicitly

selecting for button press/release doesn't suffice anymore to
get scroll events.

calendar: Set GDK_SCROLL_MASK explicitly

selecting for button press/release doesn't suffice anymore to
get scroll events.

menu: Handle smooth scrolling

event->scroll.delta_y will be used to scroll the menu contents,
GDK_SMOOTH_SCROLL_MASK has been set as well

viewport: set GDK_SMOOTH_SCROLL_MASK

This is so smooth scroll events are send/handled by the
parent GtkScrolledWindow if any.

treeview: set GDK_SMOOTH_SCROLL_MASK

This is so smooth scroll events are send/handled by the
parent GtkScrolledWindow if any.

layout: set GDK_SMOOTH_SCROLL_MASK

This is so smooth scroll events are send/handled by the
parent GtkScrolledWindow if any.

iconview: set GDK_SMOOTH_SCROLL_MASK

This is so smooth scroll events are send/handled by the
parent GtkScrolledWindow if any.

gtk: Implement smooth scrolling in scrolledwindow/range

If delta_x/y information is provided in scroll events, use it
to modify the underlying adjustment in steps proportional to
the deltas provided.

If the child widget of a scrolledwindow doesn't set
GDK_SMOOTH_SCROLL_MASK, regular scroll events will be dispatched,
and still handled by these 2 widgets.

devicemanager,xi2: Implement smooth scrolling

XInput >= 2.1 allows for implementing smooth scrolling,
reporting the different scrolling axes as valuators.
Any change in those will be reported as GdkEventScroll
events with delta_x/y information.

the older kind of scroll events is still handled, and
emulated in devices able to provide smooth scrolling,
setting _gdk_event_set_pointer_emulated() in that case.

devicemanager,x11: Initialize event->scroll.delta_x/y to 0 on core events

quartz: Implement smooth scrolling

nsevent scrollingDeltaX/Y (available on OSX >= Lion) is used to
provide the smooth scrolling values. In any case, old fashioned
events are still sent, setting _gdk_event_set_pointer_emulated()
if the event contains both smooth and non-smooth values.

gdk: update csw event mask filter to handle smooth scroll

Events of type GDK_SCROLL will be received if the client side window
event mask has either GDK_SCROLL_MASK or GDK_SMOOTH_SCROLL_MASK.

GDK_BUTTON_PRESS_MASK has been removed from type_masks[GDK_SCROLL]
as that bit is often set for other-than-scrolling purposes, and
yet have the window receive scroll events. In GTK+, this forces
non-smooth events bubbling, even if the widgets above want smooth
events, and legitimately set GDK_[SMOOTH_]SCROLL_MASK.

gdk: Filter out either smooth or non-smooth event depending on the evmask

If a device provides both smooth and non-smooth events, the latter will be
flagged with _gdk_event_set_pointer_emulated() so the client side window
receives one or the other. If a device is only able to deliver non-smooth
events, those will be sent, so both direction/deltas may need to be handled.

gdk: Add GDK_SMOOTH_SCROLL_MASK

By setting this event, a GdkWindow will receive scroll events
that provide delta values.

gdk: transfer event->scroll.delta_x/y through csw

gdk: deal with GDK_SMOOTH_SCROLL events as not having a direction

gdk_event_get_scroll_direction() will return FALSE on these, so
gdk_event_get_scroll_deltas() has to be used to retrieve dx/dy

gdk: Add delta_x/y to scroll events

gdk_event_get_scroll_deltas() can be used to retrieve those
values on smooth scroll events.

gdk: Add GDK_SCROLL_SMOOTH to GdkScrollDirection

This value will be used for smooth scroll events, as they'll
express the scrolling direction in terms of dx/dy.

gdk: Get the right event window for pointer emulated events

get_event_window() just checked on GDK_TOUCH_MASK, including for emulated
pointer events, so at the very least those should also match evmasks with
no touch events whatsoever

gdk: Set correct GdkModifierType on pointer emulated events

gdk: translate correctly from touch events into emulated pointer events

gdk: Don't treat touch events as button events

One more place where we assumed that touch events have a button
field.

gdk: Use the last alive grab in order to get the event window

If an active grab kicks in on a different window, _gdk_display_has_device_grab()
would still find the former implicit grab for the window below the pointer, thus
sending events to an unrelated place.

gdk: Don't mutate pointer events to touch events just because a grab says so

If a grab with GDK_TOUCH_MASK kicks in due to a touch sequence emulating pointer
events, don't mutate the sequence into emitting touch events right away.

gdk: Let implicit touch grabs coexist with an implicit pointer grab

Create the backing GdkTouchGrabInfo for touches even if the pointer
emulating touch sequence is already holding an implicit grab on a
window that didn't select for touch events.

gdk: Don't fully destroy the implicit touch grab on ::grab-broken

the backing GdkTouchGrabInfo will be needed if the overriding device
grab finishes before the touch does in order to send events back to
the implicit grab window. Instead, wait until the touch is physically
finished before removing the matching GdkTouchGrabInfo

gdk: Listen to touch events by default on the native window

GDK will only receive touch events when dealing with a multitouch
device, so these must be transformed to pointer events if the
client-side window receiving the event doesn't listen to touch
events, and the touch sequence the event is from does emulate
the pointer.

If a sequence emulates pointer events, it will result in a
button-press, N motions with GDK_BUTTON1_MASK set and a
button-release event, and it will deliver crossing events
as specified by the current device grab.

gdk: Only trigger motion hints machinery on motion events

Touch events have no need for it, plus the concept behind
gdk_event_request_motions() doesn't wrap around multiple
touches within a device.

gdk: Have touch grabs behave like the implicit grab wrt crossing events

These are equivalent to an implicit grab (with !owner_events), so
if the touch leaves or enters the grab window, the other window
won't receive the corresponding counter-event.

gdk: handle implicit touch grabs

If the touch sequence happens on a window with GDK_TOUCH_MASK set,
a GdkTouchGrabInfo is created to back it up. Else a device grab is
only created if the sequence emulates the pointer.

If both a device and a touch grab are present on a window, the later
of them both is obeyed, Any grab on the device happening after a
touch grab generates grab-broken on all the windows an implicit
touch grab was going on.

gdk: Add internal API to deal with touch implicit grabs

The necessary information about a touch implicit grab is stored in
GdkTouchGrabInfo structs, these are meant to be transient to the
touch sequence.

gdk: Don't change window_under_pointer for pure touch events

Only touch events that emulate the pointer do change it.

button: Handle touch events

Touch events don't generate crossing events themselves, so
do not rely on these to determine whether the button release
happened within the event window.

range: Have slider jump to the pointer coordinates on touch devices

This widget is too narrow to make touch interaction tricky enough, so
don't add the penalty of having the slider run farther from the touch
coordinates if it happens to miss the slider.

menus: Don't popdown submenus on button release for touch devices

This is so submenus stay open as the parent menu item is
pressed/released, since the user would typically lift the
finger in order to select a submenu item.

settings: Deprecate gtk-touchscreen-mode

It's not used anywhere in GTK+ anymore.

range: Remove gtk-touchscreen-mode usage

Emulated crossing events with mode GDK_CROSSING_TOUCH_PRESS/RELEASE
already cater dynamically for the "don't prelight on touch devices"
usecase.

togglebutton: Remove gtk-touchcreen-mode usage

Emulated crossing events with mode GDK_CROSSING_TOUCH_PRESS/RELEASE
already cater dynamically for the "don't prelight on touch devices"
usecase.

menushell: Remove gtk-touchscreen-mode usage

This usage in a keybinding signal is hardly related to touchscreens,
so just remove it.

menus: Remove gtk-touchscreen-mode from scrolling code

Scrolling is handled via ::captured-event dynamically, so remove
this now unused code.

menus: Select the first item for touch devices

This was done through gtk-touchscreen-mode. Now it is handled
dynamically on the current event source device.

menus: Implement scrolling through event capture for touch devices

This makes overflown menus scrollable via direct manipulation.
Once past the threshold, the item below the pointer is unselected
and scrolling starts.

menus: Handle item selection for touch devices dynamically

Instead of using gtk-touchscreen-mode, the behavior changes depending
on the source device in use.

tooltips: Use the source device instead of gtk-touchscreen-mode

This makes tooltips behavior dynamic based on the interacting device.

tests: Add new test for kinetic scrolling

tests: Add checkbox to enable kinetic scrolling in scrolled window test

viewport: select for touch events

This makes kinetic scrolling work with viewports where the
content does not otherwise select for button or touch events,
such as testscrolledwindow's label.

scrolledwindow: Kinetic scrolling support

Kinetic scrolling is only done on touch devices, since it is
sort of meaningless on pointer devices, besides it implies
a different input event handling on child widgets that is
unnecessary there.

If the scrolling doesn't start after a long press, the scrolling is
cancelled and events are handled by child widgets normally.

When clicked again close to the previous button press location
(assuming it had ~0 movement), the scrolled window will allow
the child to handle the events immediately.

This is so the user doesn't have to wait to the press-and-hold
timeout in order to operate on the scrolledwindow child.

The innermost scrolled window always gets to capture the events, all
scrolled windows above it just let the event go through. Ideally
reaching a limit on the innermost scrolled window would propagate
the dragging up the hierarchy in order to keep following the touch
coords, although that'd involve rather evil hacks just to cater
for broken UIs.

gdk: Generate crossing events around touch devices' press/release

Anytime a touch device interacts, the crossing events generation
will change to a touch mode where only events with mode
GDK_CROSSING_TOUCH_BEGIN/END are handled, and those are sent
around touch begin/end. Those are virtual as the master
device may still stay on the window.

Whenever there is a switch of slave device (the user starts
using another non-touch device), a crossing event with mode
GDK_CROSSING_DEVICE_SWITCH may generated if needed, and the normal
crossing event handling is resumed.

gtk: Add a way to do event capture

This patch adds a capture phase to GTK+'s event propagation
model. Events are first propagated from the toplevel (or the
grab widget, if a grab is in place) down to the target widget
 and then back up. The second phase is using the existing
::event signal, the new capture phase is using a private
API instead of a public signal for now.

This mechanism can be used in many places where we currently
have to prevent child widgets from getting events by putting
an input-only window over them. It will also be used to implement
kinetic scrolling in subsequent patches.

http://bugzilla.gnome.org/show_bug.cgi?id=641836

We automatically request more motion events in behalf of
the original widget if it listens to motion hints. So
the capturing widget doesn't need to handle such
implementation details.

We are not making event capture part of the public API for 3.4,
which is why there is no ::captured-event signal.

gtk: translate unhandled touch events to button events

We don't want to fallback for 'random' touch sequences, since
that could lead to all kinds of pairedness and other violations.
Since the X server already tells us what touch events it would
have used for emulating pointer events, we just use that information
here.

gtk: Add a separate ::touch-event signal

gdk: Add some debug output for touch events and devices

xi2: Translate touch events

Translate XI_TouchBegin/Update/End to GDK_TOUCH_BEGIN/UPDATE/END
events.

At the same time,
set pointer-emulated flags on button events with XIPointerEmulated
and on touch events emulating the pointer.

gdk: Add touch event types and mask

This commit introduces GDK_TOUCH_BEGIN/UPDATE/END/CANCEL
and a separate GdkEventTouch struct that they use. This
is closer to the touch event API of other platforms and
matches the xi2 events closely, too.

gdk: Add internal API to set "pointer emulated" flag on events

This flag will be used for non-pointer events that are emulated
from eg. touch events, or pointer events being emulated.

gdk: Add GdkEventSequence

GdkEventSequence is an opaque pointer type that is used
to identify sequences of touch events that belong together.

xi2: Use the new device types for touch-capable devices

Any device with a XITouchClassInfo with num_touches > 0
qualifies as multitouch.

gdk: Add device types for touch-capable devices

We introduce GDK_SOURCE_TOUCHSCREEN and GDK_SOURCE_TOUCHPAD
for direct and indirect touch devices, respecively. These
correspond to XIDirectTouch and XIDependentTouch in XI2.

configure: Detect XInput 2.2

xi2: Add major/minor properties to XI2 device manager

This may be used to turn on/off the features that are added to
new XInput2 revisions.

button: don't be active when holding the mouse button outside the bounds

GtkButton currently draws itself as active (pressed down) in case we're
pressing and holding the mouse pointer outside its bounds; this is
misleading though, since we won't activate the button unless the mouse
is released inside the button itself.
Fix this by only setting the ACTIVE state flag when the button is
actually pressed down.

https://bugzilla.gnome.org/show_bug.cgi?id=668141

[l10n] Updated Estonian translation

bitmask: Don't allocate memory for small bitmasks

Code taken more or less verbatim from CoglBitmask.

bitmask: Split bitmask code into two

This does nothing but turn all GtkBitmask functions into static inline
functions that call the gtk_allocated_bitmask_*() equivalent.

The implementation of the static functions has also been put into a
private header, to not scare people who want to see how things are
implemented.

bitmask: Allocate GtkBitmap data inline, not using GArray

This alone saves ~240k of GtkBitmap data after just starting up
nautilus.

bitmask: Make setters return a new value

(Actually, it's not a real 'new' value yet, but will be soon.

This is the first step to make bitmasks immutable.

testgtk: Fix compiler warnings

Fix up rendering of non-double-buffered overlays

My previous fix for this broke the progress bar in epiphany. This fix
makes it work again, and keeps the gimp bug fixed.

Basically, whenever we do a non-double-buffered rendering we have to
flush the entire window as it might be drawn outside the double
buffering machinery.

css: Fix variable

And you'd think I'd test my code...

Updated Telugu Translations

cssprovider: Redo styles as an array

Saves even more memory and avoids an extra copy during assigning.