Merge branch 'wip/matthiasc/shortcut-4' into 'master'

Shortcuts

See merge request GNOME/gtk!1569

Some documentation fixes

shortcutmanager: Add some more docs

shortcuttrigger: Some documentation fixups

shortcutaction: Some documentation fixups

shortcutcontroller: Expand the docs

docs: Update the overview input chapter

Update the wording around events to reflect current
usage, and add information about shortcuts and the
shortcut controller.

popovermenu: Show mnemonics on keynav

This is the expected behavior for menus.

popover: Implement auto mnemonics

Unfortunately, this involves copying a bunch of
code from gtkwindow.c. The only difference here
is that we add a private method to turn this off,
which will be used by GtkPopoverMenu to implement
its own auto mnemonics.

label: Respect GtkPopover::mnemonics-visible

When inside a popover, look to the popover for
whether to show mnemonics or not.

popover: Add a mnemonics-visible property

This will be handled separately for popovers, so we
need our own property for it.

label: Disconnect visible mnemonics in popovers

The controller handling mnemonics is limited to same-native,
so showing mnemonics in other natives.

modelbutton: Install accels when inside a popover

When a model button in a popover displays a shortcut,
it is probably from the global shortcut controllers,
and will not work inside the popover, since that is
a different native. Install a shortcut using the same
trigger that just activates the model button. This
shortcut will end up in the managed shortcut controller
of the popover.

popovermenu: Make mnemonics work without Alt

This is expected menu behavior.

shortcutcontroller: Inject accels into the action muxer

This is the way model button pic up accels for their actions.

popover: Implement GtkShortcutManager

This makes mnemonics work in popovers.

modelbutton: Make activatable

This is expected of button-like widgets, and is necessary
to make keynav in popover menus work as expected.

modelbutton: Remove accel poking

Stop manually poking GtkApplication for accels.
GtkApplication already feeds them into the action
muxer machinery, so that is where will get them.

Turn GtkShortcutAction into a GObject

Just like we did for GtkShortcutTrigger.

This allows language bindings to properly deal with all the actions.

Turn GtkShortcutTrigger into an object

The lightweight inheritance mechanism used for GtkShortcutTrigger is not
going to be usable by bindings, because boxed types cannot have derived
types.

We could use GTypeInstance and derive everything from that, like
GParamSpec, but in the end shortcuts are not really a performance
critical paths, unlike CSS values or render nodes.

Add definition macro for internal types

GTK defines various types that are meant to be derivable only within GTK
itself, and "final" from the perspective of consumers of the GTK API.
The existing macros defined by GObject, such as G_DECLARE_FINAL_TYPE and
G_DECLARE_DERIVABLE_TYPE, lack this functionality.

While we wait for GObject to get this kind of macro, we should define
our own.

widget: Remove some leftover accel group plumbing

The ::can-activate-accel and ::accel-closures-changed signals
are not used anymore, remove them.

shortcutcontroller: Only activate shortcuts of visible widgets

Our shortcuts are like mnemonics in this respect - they only
activate when the widget is viewable.

Drop GtkKeyHash

window: Remove GtkKeyHash remnants

It is not used anymore.

Drop the keyhash test

GtkKeyHash is going away.

shortcutcontroller: Implement mnemonic cycling

Make GtkShortcutController collect matching shortcuts
in the same way GtkKeyHash did (accept fuzzy matches
if we don't have any exact matches), and cycle among
the matches if we have multiple.

shortcuttrigger: Do elaborate matching for key events

Copy the logic from GtkKeyHash for matching key events
to shortcuts.

Adapt shortcuts test to work with the better matching,
by creating more complete key events.

shortcuttrigger: Introduce partial matches

Allow GtkShortcutTrigger to return partial matches.
Currently, no triggers produce such results, and
GtkShortcutController treats partial matches like
exact ones.

Add tests for shortcut actions

Add a test for shortcut triggers

widget: Drop the ::popup-menu signal

This is now done in widgets which have context
menus.

placesview: Stop using ::popup-menu

This signal is going away.

filechooser: Stop using ::popup-menu

This signal is going away.

mountoperation: Stop using ::popup-menu

We can just use a shortcut controller directly.

gtk-demo: Stop emitting ::popup-menu

The signal was not used anyway, in the font explorer demo.

colorchooser: Stop using ::popup-menu

This signal is going away. Use an action instead.

range: Remove ::popup-menu emission

This signal is going away, and having context menus
on sliders is not really a thing anyway.

scrollbar: Remove :popup-menu forwarding

This signal is going away.

emojichooser: Stop using ::popup-menu

This signal is going away. Use an action instead.

Use an action for the context menu keybinding

The ::popup-menu signal is going away.

Print mnemonic triggers clearly

inspector: Show shortcuts

At a tab that lists the shortcuts contained in a
GtkShortcutController.

filechooser: Trigger the location popup via bindings

Simplifies code quite a bit.

accels: Remove GtkAccelGroup

testmenubutton: Don't create a GtkAccelGroup

It's unused.

testsuite: Remove GtkAccelGroup usage

widget: Remove gtk_widget_add_accelerator()

People should use shortcut controllers instead (global, capture).

A side effect of this is that GtkAccelLabel now lost its method to
magically look up accelerators to display. Somebody needs to add that
back later.

doc tools: Create AccelLabel image without using GtkAccelGroup

testgtk: Port keyval example to shortcut controllers

shortcutcontroller: Implement GtkBuildable

Use it to allow adding shortcuts to the controller via the usual <child>
method.

shortcutaction: Integrate with GtkBuilder property parsing

<property name="action">action(win.quit)</property> style action
specifications now work for GtkShortcutAction properties.

shortcuttrigger: Add gtk_shortcut_triger_new_parse_string()

And hook it up into the GtkBuilder infrastructure.

application: Replace accelerator handling with shortcuts

API remains the same, but activation is now done via a
shortcutcontroller.

The code uses a controller with global scope so that the
shortcuts are managed with all the other global shortcuts.

accel: Add display arg to gtk_accelerator_parse_with_keycode()

It was using the default display unconditionally.

accelerators: Make gtk_accelerator_parse() return TRUE/FALSE

A parse function should return success or not. So do that.

shortcuttrigger: Add hash(), equal(), and compare() functions

Those are useful for putting triggers in hash tables or getting sorted
output.

shortcutmanager: Use list models

shortcutcontroller: Use a list model for shortcuts

shortcutaction: Add gtk_shortcut_action_to_string()

For all but the callback action, we can print something useful.

widget: Only create a controller if we have shortcuts

No point in creating objects that just hold empty lists.

widget: Keep keybindings as a GListStore

This way, we can use shortcut_controller_new_for_model() and avoid all
the special casing about run_class.

shortcutcontroller: Add gtk_shortcut_controller_new_for_model()

This is mainly for internal use, but I can't see a reason to not have it
public for people who want to maintain their own lists.

I'm sure gnome-builder will never ever find a way to misuse it.

shortcutcontroller: Implement GListModel

After all, this controller is a list of shortcuts.

gtk-demo: Port the sliding puzzle demo to shortcuts

shortcut: Change the API for creating shortcuts

When creating shortcuts, there almost always are a trigger and an action
available for use. So make gtk_shortcut_new() take those as arguments.

Also add gtk_shortcut_new_with_arguments() so people can easily pass
those in, too.

shortcut: Add GtkShortcutAction

Similar to GtkShortcutTrigger, GtkShortCutAction provides all the
different ways to activate a shortcut.

So far, these different ways are supported:

 - do nothing
 - Call a user-provided callback
 - Call gtk_widget_activate()
 - Call gtk_widget_mnemonic_activate()
 - Emit an action signal
 - Activate an action from the widget's action muxer

accelgroup: Remove unneeded APIs

After the removal of GtkAccelMap, these things are no longer necessary.

gtk: Remove GtkAccelMap

Now that accel paths are gone, the object managing them isn't needed
anymore either.

gtk: Remove accel paths

It's an outdated technology now that everybody is using GActionGroups.

If somebody wanted to support changeable shortcuts, they'd need to
reintroduce it in another way.

Remove GtkMnemonicHash

It's not used anymore.

window: Remove all old mnemonic handling API

Add GtkShortcutManager

This adds an interface for taking care of shortcut controllers with
managed scope.

Only GtkWindow currently implements this interface, so we need to ensure
that we check if any top-level widget we reach is a shortcuts manager
before we call into it.

label: Implement mnemonics using shortcuts

shortcut: Add gtk_shortcut_set_mnemonic_activate()

Makes the shortcut call gtk_widget_mnemonic_activate() upon activation.

shortcuttrigger: Add support for mnemonics

Mnemonics need to be triggered with help from the controllers (who
determine the modifiers). Support for that has been added, too.

Mnemonics do not use this yet though.

window: Put F10 accelerator into its own shortcut controller

So instead of relying on gtk_window_activate_key(), it's now using
proper infrastructure.

window: Get rid of public APIs that shouldn't be

Event controllers should have replaced all of them.
And if they haven't, apps need to fix their code (I'm
looking at you Gimp).

gdk: Remove GDK_RELEASE_MASK

It was only ever supported by keybindings and those are gone now.

gtk-demo: Add a dumb demo for shortcut triggers

shortcutcontroller: Add GtkShortcutScope

Allow setting the scope for a controller. The scope determines at what
point in event propagation the shortcuts will be activated.

Local scope is the usual activation, global scope means that the root
widget activates the shortcuts - ie they are activated at the very
start of event propagation (for global capture events) or the very end
(for global bubble events).
Managed scope so far is unimplemented.

This is supposed to be used to replace accelerators and mnemonics.

shortcuttrigger: Add gtk_shortcut_trigger_to_label()

Provide a user-presentable string.

accelgroup: Add gtk_accel_group_print_label()

accellabel: Move gtk_accelerator_get_label() code

The function lives in gtkaccelgroup.c, so there's no need to have that
call a private function in another source file. Instead, make that
other source file call gtk_accelerator_get_label() instead.

accellabel: Get rid of class variables

We can just look them up as-needed, no need to cache them.

gtk: Remove bindings

The whole binding functionality is now handled by shortcuts.

Remove bindings activation from GtkEventControllerKey

We're going to use shortcuts soon.

popover: Add keynav keybindings

The shortcut controllers are limited to same-native,
so we need to duplicate the Tab and arrow key bindings
for focus handling, as well as the Enter bindings for
activation.

popovermenu: Port to shortcuts

accelgroup: Actually have a default mod mask

Don't just use a value without initializing it.

treeview: Redo event forwarding hack

Reorder the event controllers so that key forwarding to the search
entries really happens after shortcut triggering.

combobox: Redo key event forwarding hack

Instead of manualling invoking bindings, we now reorder event
controllers inside the treemenu, so that shortcuts run before the event
forwarding.

widget: Add private accessor to event controllers

iconview: Port bindings to use shortcuts

infobar: Port bindings to use shortcuts

label: Port bindings to use shortcuts

listbox: Port bindings to use shortcuts

notebook: Port bindings to use shortcuts

scale: Port bindings to use shortcuts

scalebutton: Port bindings to use shortcuts