AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2025-01-14 22:30:22 +00:00
Code Issues Projects Releases Wiki Activity

shortcut: Add GtkShortcutTrigger

Browse Source 
Triggers are meant to describe how to trigger a shortcut.
So far only a keyval + modifiers trigger exists.
This commit is contained in:
Matthias Clasen 2020-03-15 09:49:50 -04:00
parent d51b8ff058
commit 6d452f1eb8
12 changed files with 599 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/reference/gtk/gtk4-docs.xml
View File

@ -342,6 +342,7 @@
<chapter>
<title>Keyboard shortcuts</title>
<xi:include href="xml/gtkshortcut.xml" />
<xi:include href="xml/gtkshortcuttrigger.xml" />
</chapter>
<chapter>

21
docs/reference/gtk/gtk4-sections.txt
View File

@ -6065,6 +6065,25 @@ GTK_EVENT_CONTROLLER_MOTION_GET_CLASS
gtk_event_controller_motion_get_type
</SECTION>
<SECTION>
<FILE>gtkshortcuttrigger</FILE>
<TITLE>GtkShortcutTrigger</TITLE>
GtkShortcutTrigger
gtk_shortcut_trigger_ref
gtk_shortcut_trigger_unref
GtkShortcutTriggerType
gtk_shortcut_trigger_get_trigger_type
gtk_shortcut_trigger_trigger
<SUBSECTION>
gtk_keyval_trigger_new
gtk_keyval_trigger_get_modifiers
gtk_keyval_trigger_get_keyval
<SUBSECTION Private>
gtk_shortcut_trigger_get_type
</SECTION>
<SECTION>
<FILE>gtkshortcut</FILE>
<TITLE>GtkShortcut</TITLE>
@ -6072,6 +6091,8 @@ GtkShortcut
gtk_shortcut_new
gtk_shortcut_set_keyval
gtk_shortcut_activate
gtk_shortcut_get_trigger
gtk_shortcut_set_trigger
gtk_shortcut_get_arguments
gtk_shortcut_set_arguments
gtk_shortcut_get_signal

1
gtk/gtk.h
View File

@ -205,6 +205,7 @@
#include <gtk/gtkshortcutssection.h>
#include <gtk/gtkshortcutsshortcut.h>
#include <gtk/gtkshortcutswindow.h>
#include <gtk/gtkshortcuttrigger.h>
#include <gtk/gtkshow.h>
#include <gtk/gtksingleselection.h>
#include <gtk/gtkslicelistmodel.h>

116
gtk/gtkshortcut.c
View File

@ -23,6 +23,7 @@
#include "gtkbindingsprivate.h"
#include "gtkintl.h"
#include "gtkshortcuttrigger.h"
#include "gtkwidget.h"
/**
@ -53,9 +54,7 @@ struct _GtkShortcut
{
GObject parent_instance;
GdkModifierType mods;
guint keyval;
GtkShortcutTrigger *trigger;
char *signal;
GVariant *args;
};
@ -65,6 +64,7 @@ enum
PROP_0,
PROP_ARGUMENTS,
PROP_SIGNAL,
PROP_TRIGGER,
N_PROPS
};
@ -78,6 +78,7 @@ gtk_shortcut_dispose (GObject *object)
{
GtkShortcut *self = GTK_SHORTCUT (object);
g_clear_pointer (&self->trigger, gtk_shortcut_trigger_unref);
g_clear_pointer (&self->signal, g_free);
g_clear_pointer (&self->args, g_variant_unref);
@ -102,6 +103,10 @@ gtk_shortcut_get_property (GObject *object,
g_value_set_string (value, self->signal);
break;
case PROP_TRIGGER:
g_value_set_boxed (value, self->trigger);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
@ -126,6 +131,10 @@ gtk_shortcut_set_property (GObject *object,
gtk_shortcut_set_signal (self, g_value_get_string (value));
break;
case PROP_TRIGGER:
gtk_shortcut_set_trigger (self, g_value_dup_boxed (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
@ -166,12 +175,25 @@ gtk_shortcut_class_init (GtkShortcutClass *klass)
NULL,
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
/**
* GtkShortcut:trigger:
*
* The trigger that triggers this shortcut.
*/
properties[PROP_TRIGGER] =
g_param_spec_boxed ("trigger",
P_("Trigger"),
P_("The trigger for this shortcut"),
GTK_TYPE_SHORTCUT_TRIGGER,
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (gobject_class, N_PROPS, properties);
}
static void
gtk_shortcut_init (GtkShortcut *self)
{
self->trigger = gtk_shortcut_trigger_ref (gtk_never_trigger_get ());
}
/**
@ -187,50 +209,11 @@ gtk_shortcut_new (void)
return g_object_new (GTK_TYPE_SHORTCUT, NULL);
}
void
gtk_shortcut_set_keyval (GtkShortcut *self,
guint keyval,
GdkModifierType mods)
{
g_return_if_fail (GTK_IS_SHORTCUT (self));
/* To deal with <Shift>, we need to uppercase
* or lowercase depending on situation.
*/
if (mods & GDK_SHIFT_MASK)
{
if (keyval == GDK_KEY_Tab)
keyval = GDK_KEY_ISO_Left_Tab;
else
keyval = gdk_keyval_to_upper (keyval);
}
else
{
if (keyval == GDK_KEY_ISO_Left_Tab)
keyval = GDK_KEY_Tab;
else
keyval = gdk_keyval_to_lower (keyval);
}
self->keyval = keyval;
self->mods = mods;
}
gboolean
gtk_shortcut_trigger (GtkShortcut *self,
GdkEvent *event)
{
GdkModifierType mods;
guint keyval;
if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
return FALSE;
/* XXX: This needs to deal with groups */
mods = gdk_event_get_modifier_state (event);
keyval = gdk_key_event_get_keyval (event);
return keyval == self->keyval && mods == self->mods;
return gtk_shortcut_trigger_trigger (self->trigger, event);
}
gboolean
@ -251,7 +234,7 @@ gtk_shortcut_activate (GtkShortcut *self,
&handled,
&error))
{
char *accelerator = gtk_accelerator_name (self->keyval, self->mods);
char *accelerator = gtk_shortcut_trigger_to_string (self->trigger);
g_warning ("gtk_shortcut_activate(): \":%s\": %s",
accelerator,
error->message);
@ -268,6 +251,51 @@ gtk_shortcut_activate (GtkShortcut *self,
}
}
/**
* gtk_shortcut_get_trigger:
* @self: a #GtkShortcut
*
* Gets the trigger used to trigger @self.
*
* Returns: (transfer none): the trigger used
**/
GtkShortcutTrigger *
gtk_shortcut_get_trigger (GtkShortcut *self)
{
g_return_val_if_fail (GTK_IS_SHORTCUT (self), NULL);
return self->trigger;
}
/**
* gtk_shortcut_set_trigger:
* @self: a #GtkShortcut
* @trigger: (transfer full) (nullable): The new trigger.
* If the @trigger is %NULL, the never trigger will be used.
*
* Sets the new trigger for @self to be @trigger.
**/
void
gtk_shortcut_set_trigger (GtkShortcut *self,
GtkShortcutTrigger *trigger)
{
g_return_if_fail (GTK_IS_SHORTCUT (self));
if (trigger == NULL)
trigger = gtk_shortcut_trigger_ref (gtk_never_trigger_get ());
if (self->trigger == trigger)
{
gtk_shortcut_trigger_unref (trigger);
return;
}
gtk_shortcut_trigger_unref (self->trigger);
self->trigger = trigger;
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TRIGGER]);
}
GVariant *
gtk_shortcut_get_arguments (GtkShortcut *self)
{

8
gtk/gtkshortcut.h
View File

@ -33,9 +33,11 @@ GDK_AVAILABLE_IN_ALL
GtkShortcut * gtk_shortcut_new (void);
GDK_AVAILABLE_IN_ALL
void gtk_shortcut_set_keyval (GtkShortcut *self,
guint keyval,
GdkModifierType mods);
void gtk_shortcut_set_trigger (GtkShortcut *self,
GtkShortcutTrigger *trigger);
GDK_AVAILABLE_IN_ALL
GtkShortcutTrigger *
gtk_shortcut_get_trigger (GtkShortcut *self);
GDK_AVAILABLE_IN_ALL
gboolean gtk_shortcut_trigger (GtkShortcut *self,

2
gtk/gtkshortcutcontroller.c
View File

@ -62,7 +62,7 @@ gtk_shortcut_controller_finalize (GObject *object)
static gboolean
gtk_shortcut_controller_trigger_shortcut (GtkShortcutController *self,
GtkShortcut *shortcut,
const GdkEvent *event)
GdkEvent *event)
{
if (!gtk_shortcut_trigger (shortcut, event))
return FALSE;

405
gtk/gtkshortcuttrigger.c Normal file
View File

@ -0,0 +1,405 @@
/*
* Copyright © 2018 Benjamin Otte
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Authors: Benjamin Otte <otte@gnome.org>
*/
/**
* SECTION:gtkshortcuttrigger
* @Title: GtkShortcutTrigger
* @Short_description: Triggers to track if shortcuts should be activated
* @See_also: #GtkShortcut
*
* #GtkShortcutTrigger is the object used to track if a #GtkShortcut should be
* activated. For this purpose, gtk_shortcut_trigger_trigger() can be called
* on a #GdkEvent.
*
* #GtkShortcutTriggers contain functions that allow easy presentation to end
* users as well as being printed for debugging.
*
* All #GtkShortcutTriggers are immutable, you can only specify their properties
* during construction. If you want to change a trigger, you have to replace it
* with a new one.
*/
#include "config.h"
#include "gtkshortcuttrigger.h"
#include "gtkaccelgroup.h"
typedef struct _GtkShortcutTriggerClass GtkShortcutTriggerClass;
#define GTK_IS_SHORTCUT_TRIGGER_TYPE(trigger,type) (GTK_IS_SHORTCUT_TRIGGER (trigger) && (trigger)->trigger_class->trigger_type == (type))
struct _GtkShortcutTrigger
{
const GtkShortcutTriggerClass *trigger_class;
gatomicrefcount ref_count;
};
struct _GtkShortcutTriggerClass
{
GtkShortcutTriggerType trigger_type;
gsize struct_size;
const char *type_name;
void (* finalize) (GtkShortcutTrigger *trigger);
gboolean (* trigger) (GtkShortcutTrigger *trigger,
GdkEvent *event);
void (* print) (GtkShortcutTrigger *trigger,
GString *string);
};
static GtkShortcutTrigger * gtk_shortcut_trigger_new (const GtkShortcutTriggerClass *trigger_class,
gsize extra_size);
G_DEFINE_BOXED_TYPE (GtkShortcutTrigger, gtk_shortcut_trigger,
gtk_shortcut_trigger_ref,
gtk_shortcut_trigger_unref)
static void
gtk_shortcut_trigger_finalize (GtkShortcutTrigger *self)
{
self->trigger_class->finalize (self);
g_free (self);
}
/*< private >
* gtk_shortcut_trigger_new:
* @trigger_class: class structure for this trigger
*
* Returns: (transfer full): the newly created #GtkShortcutTrigger
*/
GtkShortcutTrigger *
gtk_shortcut_trigger_new (const GtkShortcutTriggerClass *trigger_class,
gsize extra_size)
{
GtkShortcutTrigger *self;
g_return_val_if_fail (trigger_class != NULL, NULL);
self = g_malloc0 (trigger_class->struct_size + extra_size);
g_atomic_ref_count_init (&self->ref_count);
self->trigger_class = trigger_class;
return self;
}
/**
* gtk_shortcut_trigger_ref:
* @self: a #GtkShortcutTrigger
*
* Acquires a reference on the given #GtkShortcutTrigger.
*
* Returns: (transfer full): the #GtkShortcutTrigger with
* an additional reference
*/
GtkShortcutTrigger *
gtk_shortcut_trigger_ref (GtkShortcutTrigger *self)
{
g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), NULL);
g_atomic_ref_count_inc (&self->ref_count);
return self;
}
/**
* gtk_shortcut_trigger_unref:
* @self: (transfer full): a #GtkShortcutTrigger
*
* Releases a reference on the given #GtkShortcutTrigger.
*
* If the reference was the last, the resources associated
* to the trigger are freed.
*/
void
gtk_shortcut_trigger_unref (GtkShortcutTrigger *self)
{
g_return_if_fail (GTK_IS_SHORTCUT_TRIGGER (self));
if (g_atomic_ref_count_dec (&self->ref_count))
gtk_shortcut_trigger_finalize (self);
}
/**
* gtk_shortcut_trigger_get_trigger_type:
* @self: a #GtkShortcutTrigger
*
* Returns the type of the @trigger.
*
* Returns: the type of the #GtkShortcutTrigger
*/
GtkShortcutTriggerType
gtk_shortcut_trigger_get_trigger_type (GtkShortcutTrigger *self)
{
g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), GTK_SHORTCUT_TRIGGER_NEVER);
return self->trigger_class->trigger_type;
}
/**
* gtk_shortcut_trigger_trigger:
* @self: a #GtkShortcutTrigger
* @event: the event to check
*
* Checks if the given @event triggers @self. If so,
* returns %TRUE.
*
* Returns: %TRUE if this event triggered the trigger
**/
gboolean
gtk_shortcut_trigger_trigger (GtkShortcutTrigger *self,
GdkEvent *event)
{
g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), FALSE);
return self->trigger_class->trigger (self, event);
}
/**
* gtk_shortcut_trigger_to_string:
* @self: a #GtkShortcutTrigger
*
* Prints the given trigger into a human-readable string.
* This is a small wrapper around gdk_content_formats_print()
* to help when debugging.
*
* Returns: (transfer full): a new string
**/
char *
gtk_shortcut_trigger_to_string (GtkShortcutTrigger *self)
{
GString *string;
g_return_val_if_fail (self != NULL, NULL);
string = g_string_new (NULL);
gtk_shortcut_trigger_print (self, string);
return g_string_free (string, FALSE);
}
/**
* gtk_shortcut_trigger_print:
* @self: a #GtkShortcutTrigger
* @string: a #GString to print into
*
* Prints the given trigger into a string for the developer.
* This is meant for debugging and logging.
*
* The form of the representation may change at any time
* and is not guaranteed to stay identical.
**/
void
gtk_shortcut_trigger_print (GtkShortcutTrigger *self,
GString *string)
{
g_return_if_fail (GTK_IS_SHORTCUT_TRIGGER (self));
g_return_if_fail (string != NULL);
return self->trigger_class->print (self, string);
}
/*** GTK_SHORTCUT_TRIGGER_NEVER ***/
typedef struct _GtkNeverTrigger GtkNeverTrigger;
struct _GtkNeverTrigger
{
GtkShortcutTrigger trigger;
guint never;
GdkModifierType modifiers;
};
static void
gsk_never_trigger_finalize (GtkShortcutTrigger *trigger)
{
g_assert_not_reached ();
}
static gboolean
gsk_never_trigger_trigger (GtkShortcutTrigger *trigger,
GdkEvent *event)
{
return FALSE;
}
static void
gsk_never_trigger_print (GtkShortcutTrigger *trigger,
GString *string)
{
g_string_append (string, "<never>");
}
static const GtkShortcutTriggerClass GTK_NEVER_TRIGGER_CLASS = {
GTK_SHORTCUT_TRIGGER_NEVER,
sizeof (GtkNeverTrigger),
"GtkNeverTrigger",
gsk_never_trigger_finalize,
gsk_never_trigger_trigger,
gsk_never_trigger_print
};
static GtkNeverTrigger never = { { &GTK_NEVER_TRIGGER_CLASS, 1 } };
/**
* gsk_never_trigger_get:
*
* Gets the never trigger. This is a singleton for a trigger
* that never triggers. Use this trigger instead of %NULL
* because it implements all virtual functions.
*
* Returns: (transfer none): The never trigger
*/
GtkShortcutTrigger *
gtk_never_trigger_get (void)
{
return &never.trigger;
}
/*** GTK_KEYVAL_TRIGGER ***/
typedef struct _GtkKeyvalTrigger GtkKeyvalTrigger;
struct _GtkKeyvalTrigger
{
GtkShortcutTrigger trigger;
guint keyval;
GdkModifierType modifiers;
};
static void
gsk_keyval_trigger_finalize (GtkShortcutTrigger *trigger)
{
}
static gboolean
gsk_keyval_trigger_trigger (GtkShortcutTrigger *trigger,
GdkEvent *event)
{
GtkKeyvalTrigger *self = (GtkKeyvalTrigger *) trigger;
GdkModifierType modifiers;
guint keyval;
if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
return FALSE;
/* XXX: This needs to deal with groups */
modifiers = gdk_event_get_modifier_state (event);
keyval = gdk_key_event_get_keyval (event);
if (keyval == GDK_KEY_ISO_Left_Tab)
keyval = GDK_KEY_Tab;
else
keyval = gdk_keyval_to_lower (keyval);
return keyval == self->keyval && modifiers == self->modifiers;
}
static void
gsk_keyval_trigger_print (GtkShortcutTrigger *trigger,
GString *string)
{
GtkKeyvalTrigger *self = (GtkKeyvalTrigger *) trigger;
char *accelerator_name;
accelerator_name = gtk_accelerator_name (self->keyval, self->modifiers);
g_string_append (string, accelerator_name);
g_free (accelerator_name);
}
static const GtkShortcutTriggerClass GTK_KEYVAL_TRIGGER_CLASS = {
GTK_SHORTCUT_TRIGGER_KEYVAL,
sizeof (GtkKeyvalTrigger),
"GtkKeyvalTrigger",
gsk_keyval_trigger_finalize,
gsk_keyval_trigger_trigger,
gsk_keyval_trigger_print
};
/**
* gsk_keyval_trigger_new:
* @keyval: The keyval to trigger for
* @modifiers: the modifiers that need to be present
*
* Creates a #GtkShortcutTrigger that will trigger whenever
* the key with the given @keyval and @modifiers is pressed.
*
* Returns: A new #GtkShortcutTrigger
*/
GtkShortcutTrigger *
gtk_keyval_trigger_new (guint keyval,
GdkModifierType modifiers)
{
GtkKeyvalTrigger *self;
self = (GtkKeyvalTrigger *) gtk_shortcut_trigger_new (&GTK_KEYVAL_TRIGGER_CLASS, 0);
/* We store keyvals as lower key */
if (keyval == GDK_KEY_ISO_Left_Tab)
self->keyval = GDK_KEY_Tab;
else
self->keyval = gdk_keyval_to_lower (keyval);
self->modifiers = modifiers;
return &self->trigger;
}
/**
* gtk_keyval_trigger_get_modifiers:
* @self: a keyval #GtkShortcutTrigger
*
* Gets the modifiers that must be present to succeed
* triggering @self.
*
* Returns: the modifiers
**/
GdkModifierType
gtk_keyval_trigger_get_modifiers (GtkShortcutTrigger *self)
{
GtkKeyvalTrigger *trigger = (GtkKeyvalTrigger *) self;
g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (self, GTK_SHORTCUT_TRIGGER_KEYVAL), 0);
return trigger->modifiers;
}
/**
* gtk_keyval_trigger_get_keyval:
* @self: a keyval #GtkShortcutTrigger
*
* Gets the keyval that must be pressed to succeed
* triggering @self.
*
* Returns: the keyval
**/
guint
gtk_keyval_trigger_get_keyval (GtkShortcutTrigger *self)
{
GtkKeyvalTrigger *trigger = (GtkKeyvalTrigger *) self;
g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (self, GTK_SHORTCUT_TRIGGER_KEYVAL), 0);
return trigger->keyval;
}

82
gtk/gtkshortcuttrigger.h Normal file
View File

@ -0,0 +1,82 @@
/*
* Copyright © 2018 Benjamin Otte
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Authors: Benjamin Otte <otte@gnome.org>
*/
#ifndef __GTK_SHORTCUT_TRIGGER_H__
#define __GTK_SHORTCUT_TRIGGER_H__
#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
#error "Only <gtk/gtk.h> can be included directly."
#endif
#include <gtk/gtktypes.h>
G_BEGIN_DECLS
#define GTK_TYPE_SHORTCUT_TRIGGER (gtk_shortcut_trigger_get_type ())
#define GTK_IS_SHORTCUT_TRIGGER(obj) ((obj) != NULL)
/**
* GtkShortcutTriggerType:
* @GTK_SHORTCUT_TRIGGER_NEVER: Never ever trigger
* @GTK_SHORTCUT_TRIGGER_KEYVAL: Trigger if a key even with matching
* modifiers and keyval is received.
*
* The type of a trigger determines what the trigger triggers on.
**/
typedef enum {
GTK_SHORTCUT_TRIGGER_NEVER,
GTK_SHORTCUT_TRIGGER_KEYVAL
} GtkShortcutTriggerType;
GDK_AVAILABLE_IN_ALL
GType gtk_shortcut_trigger_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
GtkShortcutTrigger * gtk_shortcut_trigger_ref (GtkShortcutTrigger *self);
GDK_AVAILABLE_IN_ALL
void gtk_shortcut_trigger_unref (GtkShortcutTrigger *self);
GDK_AVAILABLE_IN_ALL
GtkShortcutTriggerType gtk_shortcut_trigger_get_trigger_type (GtkShortcutTrigger *self);
GDK_AVAILABLE_IN_ALL
char * gtk_shortcut_trigger_to_string (GtkShortcutTrigger *self);
GDK_AVAILABLE_IN_ALL
void gtk_shortcut_trigger_print (GtkShortcutTrigger *self,
GString *string);
GDK_AVAILABLE_IN_ALL
gboolean gtk_shortcut_trigger_trigger (GtkShortcutTrigger *self,
GdkEvent *event);
GDK_AVAILABLE_IN_ALL
GtkShortcutTrigger * gtk_never_trigger_get (void);
GDK_AVAILABLE_IN_ALL
GtkShortcutTrigger * gtk_keyval_trigger_new (guint keyval,
GdkModifierType modifiers);
GDK_AVAILABLE_IN_ALL
GdkModifierType gtk_keyval_trigger_get_modifiers (GtkShortcutTrigger *self);
GDK_AVAILABLE_IN_ALL
guint gtk_keyval_trigger_get_keyval (GtkShortcutTrigger *self);
G_END_DECLS
#endif /* __GTK_SHORTCUT_TRIGGER_H__ */

1
gtk/gtktypes.h
View File

@ -46,6 +46,7 @@ typedef struct _GtkRequisition GtkRequisition;
typedef struct _GtkRoot GtkRoot;
typedef struct _GtkSettings GtkSettings;
typedef struct _GtkShortcut GtkShortcut;
typedef struct _GtkShortcutTrigger GtkShortcutTrigger;
typedef GdkSnapshot GtkSnapshot;
typedef struct _GtkStyleContext GtkStyleContext;
typedef struct _GtkTooltip GtkTooltip;

7
gtk/gtkwidget.c
View File

@ -61,6 +61,7 @@
#include "gtksettingsprivate.h"
#include "gtkshortcut.h"
#include "gtkshortcutcontroller.h"
#include "gtkshortcuttrigger.h"
#include "gtksizegroup-private.h"
#include "gtksnapshotprivate.h"
#include "gtkstylecontextprivate.h"
@ -4306,8 +4307,8 @@ gtk_widget_real_size_allocate (GtkWidget *widget,
/**
* gtk_widget_class_add_binding_signal: (skip)
* @widget_class: the class to add the binding to
* @mods: key modifier of binding to install
* @keyval: key value of binding to install
* @mods: key modifier of binding to install
* @signal: the signal to execute
* @format_string: GVariant format string for arguments or %NULL for
* no arguments
@ -4324,8 +4325,8 @@ gtk_widget_real_size_allocate (GtkWidget *widget,
*/
void
gtk_widget_class_add_binding_signal (GtkWidgetClass *widget_class,
GdkModifierType mods,
guint keyval,
GdkModifierType mods,
const gchar *signal,
const gchar *format_string,
...)
@ -4337,7 +4338,7 @@ gtk_widget_class_add_binding_signal (GtkWidgetClass *widget_class,
/* XXX: validate variant format for signal */
shortcut = gtk_shortcut_new ();
gtk_shortcut_set_keyval (shortcut, mods, keyval);
gtk_shortcut_set_trigger (shortcut, gtk_keyval_trigger_new (keyval, mods));
gtk_shortcut_set_signal (shortcut, signal);
if (format_string)
{

2
gtk/meson.build
View File

@ -338,6 +338,7 @@ gtk_public_sources = files([
'gtkshortcutssection.c',
'gtkshortcutsshortcut.c',
'gtkshortcutswindow.c',
'gtkshortcuttrigger.c',
'gtkshow.c',
'gtksidebarrow.c',
'gtksingleselection.c',
@ -577,6 +578,7 @@ gtk_public_headers = files([
'gtkshortcutssection.h',
'gtkshortcutsshortcut.h',
'gtkshortcutswindow.h',
'gtkshortcuttrigger.h',
'gtkshow.h',
'gtksingleselection.h',
'gtksizegroup.h',

4
testsuite/gtk/defaultvalue.c
View File

@ -324,6 +324,10 @@ G_GNUC_END_IGNORE_DEPRECATIONS
if (g_type_is_a (type, GTK_TYPE_SETTINGS))
continue;
if (g_type_is_a (type, GTK_TYPE_SHORTCUT) &&
strcmp (pspec->name, "trigger") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_SPIN_BUTTON) &&
(strcmp (pspec->name, "adjustment") == 0))
continue;