/*
* Copyright © 2018 Benjamin Otte
*
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
* 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
#include "gtkaccelgroupprivate.h"
#include "gtkprivate.h"
+#include "gtkintl.h"
-typedef struct _GtkShortcutTriggerClass GtkShortcutTriggerClass;
-
-#define GTK_IS_SHORTCUT_TRIGGER_TYPE(trigger,type) (GTK_IS_SHORTCUT_TRIGGER (trigger) && (trigger)->trigger_class->trigger_type == (type))
+#define GTK_SHORTCUT_TRIGGER_HASH_NEVER 0u
+#define GTK_SHORTCUT_TRIGGER_HASH_KEYVAL 1u
+#define GTK_SHORTCUT_TRIGGER_HASH_MNEMONIC 2u
+#define GTK_SHORTCUT_TRIGGER_HASH_ALTERNATIVE 3u
struct _GtkShortcutTrigger
{
- const GtkShortcutTriggerClass *trigger_class;
-
- gatomicrefcount ref_count;
+ GObject parent_instance;
};
struct _GtkShortcutTriggerClass
{
- GtkShortcutTriggerType trigger_type;
- gsize struct_size;
- const char *type_name;
+ GObjectClass parent_class;
- void (* finalize) (GtkShortcutTrigger *trigger);
GtkShortcutTriggerMatch
(* trigger) (GtkShortcutTrigger *trigger,
GdkEvent *event,
GString *string);
};
-G_DEFINE_BOXED_TYPE (GtkShortcutTrigger, gtk_shortcut_trigger,
- gtk_shortcut_trigger_ref,
- gtk_shortcut_trigger_unref)
+G_DEFINE_ABSTRACT_TYPE (GtkShortcutTrigger, gtk_shortcut_trigger, G_TYPE_OBJECT)
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
- */
-static GtkShortcutTrigger *
-gtk_shortcut_trigger_new (const GtkShortcutTriggerClass *trigger_class)
-{
- GtkShortcutTrigger *self;
-
- g_return_val_if_fail (trigger_class != NULL, NULL);
-
- self = g_malloc0 (trigger_class->struct_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)
+gtk_shortcut_trigger_class_init (GtkShortcutTriggerClass *klass)
{
- 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)
+static void
+gtk_shortcut_trigger_init (GtkShortcutTrigger *self)
{
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), GTK_SHORTCUT_TRIGGER_NEVER);
-
- return self->trigger_class->trigger_type;
}
/**
{
g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), GTK_SHORTCUT_TRIGGER_MATCH_NONE);
- return self->trigger_class->trigger (self, event, enable_mnemonics);
+ return GTK_SHORTCUT_TRIGGER_GET_CLASS (self)->trigger (self, event, enable_mnemonics);
}
/**
- * gtk_shortcut_trigger_parse_string:
+ * gtk_shortcut_trigger_parse_string: (constructor)
* @string: the string to parse
*
* Tries to parse the given string into a trigger. On success,
* the parsed trigger is returned. When parsing failed, %NULL is
* returned.
*
- * FIXME: Document the supported format here once we've figured
- * it out.
- * For now, this function only supports gtk_accelerator_parse() and
- * can only return a trigger of type %GTK_SHORTCUT_TRIGGER_KEYVAL.
+ * The accepted strings are:
*
- * Returns: a new #GtkShortcutTrigger or %NULL on error
- **/
+ * - `never`, for #GtkNeverTrigger
+ * - a string parsed by gtk_accelerator_parse(), for a #GtkKeyvalTrigger
+ * - underscore, followed by a single character, for #GtkMnemonicTrigger
+ *
+ * Returns: (nullable): a new #GtkShortcutTrigger or %NULL on error
+ */
GtkShortcutTrigger *
gtk_shortcut_trigger_parse_string (const char *string)
{
g_return_val_if_fail (string != NULL, NULL);
+ if (g_str_equal (string, "never"))
+ return gtk_never_trigger_get ();
+
+ if (string[0] == '_')
+ {
+ if (gtk_accelerator_parse (string + 1, &keyval, &modifiers))
+ return gtk_mnemonic_trigger_new (keyval);
+ }
+
if (gtk_accelerator_parse (string, &keyval, &modifiers))
return gtk_keyval_trigger_new (keyval, modifiers);
* to help when debugging.
*
* Returns: (transfer full): a new string
- **/
+ */
char *
gtk_shortcut_trigger_to_string (GtkShortcutTrigger *self)
{
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);
*
* 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_GET_CLASS (self)->print (self, string);
}
/**
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (string != NULL, FALSE);
- return self->trigger_class->print_label (self, display, string);
+ return GTK_SHORTCUT_TRIGGER_GET_CLASS (self)->print_label (self, display, string);
}
/**
{
GtkShortcutTrigger *t = (GtkShortcutTrigger *) trigger;
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (trigger), 0);
+ g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (t), 0);
- return t->trigger_class->hash (t);
+ return GTK_SHORTCUT_TRIGGER_GET_CLASS (t)->hash (t);
}
/**
{
GtkShortcutTrigger *t1 = (GtkShortcutTrigger *) trigger1;
GtkShortcutTrigger *t2 = (GtkShortcutTrigger *) trigger2;
+ GType type1, type2;
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (trigger1), -1);
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (trigger2), 1);
+ g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (t1), -1);
+ g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (t2), 1);
- if (t1->trigger_class != t2->trigger_class)
- return t1->trigger_class->trigger_type - t2->trigger_class->trigger_type;
+ type1 = G_OBJECT_TYPE (t1);
+ type2 = G_OBJECT_TYPE (t2);
- return t1->trigger_class->compare (t1, t2);
+ if (type1 == type2)
+ {
+ return GTK_SHORTCUT_TRIGGER_GET_CLASS (t1)->compare (t1, t2);
+ }
+ else
+ { /* never < keyval < mnemonic < alternative */
+ if (type1 == GTK_TYPE_NEVER_TRIGGER ||
+ type2 == GTK_TYPE_ALTERNATIVE_TRIGGER)
+ return -1;
+ if (type2 == GTK_TYPE_NEVER_TRIGGER ||
+ type1 == GTK_TYPE_ALTERNATIVE_TRIGGER)
+ return 1;
+
+ if (type1 == GTK_TYPE_KEYVAL_TRIGGER)
+ return -1;
+ else
+ return 1;
+ }
}
-/*** GTK_SHORTCUT_TRIGGER_NEVER ***/
-
-typedef struct _GtkNeverTrigger GtkNeverTrigger;
-
struct _GtkNeverTrigger
{
- GtkShortcutTrigger trigger;
+ GtkShortcutTrigger parent_instance;
guint never;
GdkModifierType modifiers;
};
+struct _GtkNeverTriggerClass
+{
+ GtkShortcutTriggerClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkNeverTrigger, gtk_never_trigger, GTK_TYPE_SHORTCUT_TRIGGER)
+
static void
-gtk_never_trigger_finalize (GtkShortcutTrigger *trigger)
+gtk_never_trigger_finalize (GObject *gobject)
{
g_assert_not_reached ();
+
+ G_OBJECT_CLASS (gtk_never_trigger_parent_class)->finalize (gobject);
}
static GtkShortcutTriggerMatch
static guint
gtk_never_trigger_hash (GtkShortcutTrigger *trigger)
{
- return GTK_SHORTCUT_TRIGGER_NEVER;
+ return GTK_SHORTCUT_TRIGGER_HASH_NEVER;
}
static int
return FALSE;
}
-static const GtkShortcutTriggerClass GTK_NEVER_TRIGGER_CLASS = {
- GTK_SHORTCUT_TRIGGER_NEVER,
- sizeof (GtkNeverTrigger),
- "GtkNeverTrigger",
- gtk_never_trigger_finalize,
- gtk_never_trigger_trigger,
- gtk_never_trigger_hash,
- gtk_never_trigger_compare,
- gtk_never_trigger_print,
- gtk_never_trigger_print_label
-};
+static void
+gtk_never_trigger_class_init (GtkNeverTriggerClass *klass)
+{
+ GtkShortcutTriggerClass *trigger_class = GTK_SHORTCUT_TRIGGER_CLASS (klass);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-static GtkNeverTrigger never = { { >K_NEVER_TRIGGER_CLASS, 1 } };
+ gobject_class->finalize = gtk_never_trigger_finalize;
+
+ trigger_class->trigger = gtk_never_trigger_trigger;
+ trigger_class->hash = gtk_never_trigger_hash;
+ trigger_class->compare = gtk_never_trigger_compare;
+ trigger_class->print = gtk_never_trigger_print;
+ trigger_class->print_label = gtk_never_trigger_print_label;
+}
+
+static void
+gtk_never_trigger_init (GtkNeverTrigger *self)
+{
+}
/**
* gtk_never_trigger_get:
* that never triggers. Use this trigger instead of %NULL
* because it implements all virtual functions.
*
- * Returns: (transfer none): The never trigger
+ * Returns: (type GtkNeverTrigger) (transfer none): The never trigger
*/
GtkShortcutTrigger *
gtk_never_trigger_get (void)
{
- return &never.trigger;
-}
+ static GtkShortcutTrigger *never = NULL;
-/*** GTK_KEYVAL_TRIGGER ***/
+ if (G_UNLIKELY (never == NULL))
+ never = g_object_new (GTK_TYPE_NEVER_TRIGGER, NULL);
-typedef struct _GtkKeyvalTrigger GtkKeyvalTrigger;
+ return never;
+}
struct _GtkKeyvalTrigger
{
- GtkShortcutTrigger trigger;
+ GtkShortcutTrigger parent_instance;
guint keyval;
GdkModifierType modifiers;
};
-static void
-gtk_keyval_trigger_finalize (GtkShortcutTrigger *trigger)
+struct _GtkKeyvalTriggerClass
{
-}
+ GtkShortcutTriggerClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkKeyvalTrigger, gtk_keyval_trigger, GTK_TYPE_SHORTCUT_TRIGGER)
+
+enum
+{
+ KEYVAL_PROP_KEYVAL = 1,
+ KEYVAL_PROP_MODIFIERS,
+ KEYVAL_N_PROPS
+};
+
+static GParamSpec *keyval_props[KEYVAL_N_PROPS];
static GtkShortcutTriggerMatch
gtk_keyval_trigger_trigger (GtkShortcutTrigger *trigger,
GdkEvent *event,
gboolean enable_mnemonics)
{
- GtkKeyvalTrigger *self = (GtkKeyvalTrigger *) trigger;
+ GtkKeyvalTrigger *self = GTK_KEYVAL_TRIGGER (trigger);
guint keycode;
GdkModifierType state;
GdkModifierType mask;
static guint
gtk_keyval_trigger_hash (GtkShortcutTrigger *trigger)
{
- GtkKeyvalTrigger *self = (GtkKeyvalTrigger *) trigger;
+ GtkKeyvalTrigger *self = GTK_KEYVAL_TRIGGER (trigger);
return (self->modifiers << 24)
| (self->modifiers >> 8)
| (self->keyval << 16)
- | GTK_SHORTCUT_TRIGGER_KEYVAL;
+ | GTK_SHORTCUT_TRIGGER_HASH_KEYVAL;
}
static int
gtk_keyval_trigger_compare (GtkShortcutTrigger *trigger1,
GtkShortcutTrigger *trigger2)
{
- GtkKeyvalTrigger *self1 = (GtkKeyvalTrigger *) trigger1;
- GtkKeyvalTrigger *self2 = (GtkKeyvalTrigger *) trigger2;
+ GtkKeyvalTrigger *self1 = GTK_KEYVAL_TRIGGER (trigger1);
+ GtkKeyvalTrigger *self2 = GTK_KEYVAL_TRIGGER (trigger2);
if (self1->modifiers != self2->modifiers)
return self2->modifiers - self1->modifiers;
gtk_keyval_trigger_print (GtkShortcutTrigger *trigger,
GString *string)
{
- GtkKeyvalTrigger *self = (GtkKeyvalTrigger *) trigger;
+ GtkKeyvalTrigger *self = GTK_KEYVAL_TRIGGER (trigger);
char *accelerator_name;
accelerator_name = gtk_accelerator_name (self->keyval, self->modifiers);
GdkDisplay *display,
GString *string)
{
- GtkKeyvalTrigger *self = (GtkKeyvalTrigger *) trigger;
+ GtkKeyvalTrigger *self = GTK_KEYVAL_TRIGGER (trigger);
gtk_accelerator_print_label (string, self->keyval, self->modifiers);
return TRUE;
}
-static const GtkShortcutTriggerClass GTK_KEYVAL_TRIGGER_CLASS = {
- GTK_SHORTCUT_TRIGGER_KEYVAL,
- sizeof (GtkKeyvalTrigger),
- "GtkKeyvalTrigger",
- gtk_keyval_trigger_finalize,
- gtk_keyval_trigger_trigger,
- gtk_keyval_trigger_hash,
- gtk_keyval_trigger_compare,
- gtk_keyval_trigger_print,
- gtk_keyval_trigger_print_label
-};
+static void
+gtk_keyval_trigger_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkKeyvalTrigger *self = GTK_KEYVAL_TRIGGER (gobject);
+
+ switch (prop_id)
+ {
+ case KEYVAL_PROP_KEYVAL:
+ {
+ guint keyval = g_value_get_uint (value);
+
+ /* 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);
+ }
+ break;
+
+ case KEYVAL_PROP_MODIFIERS:
+ self->modifiers = g_value_get_flags (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ }
+}
+
+static void
+gtk_keyval_trigger_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkKeyvalTrigger *self = GTK_KEYVAL_TRIGGER (gobject);
+
+ switch (prop_id)
+ {
+ case KEYVAL_PROP_KEYVAL:
+ g_value_set_uint (value, self->keyval);
+ break;
+
+ case KEYVAL_PROP_MODIFIERS:
+ g_value_set_flags (value, self->modifiers);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ }
+}
+
+static void
+gtk_keyval_trigger_class_init (GtkKeyvalTriggerClass *klass)
+{
+ GtkShortcutTriggerClass *trigger_class = GTK_SHORTCUT_TRIGGER_CLASS (klass);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->set_property = gtk_keyval_trigger_set_property;
+ gobject_class->get_property = gtk_keyval_trigger_get_property;
+
+ trigger_class->trigger = gtk_keyval_trigger_trigger;
+ trigger_class->hash = gtk_keyval_trigger_hash;
+ trigger_class->compare = gtk_keyval_trigger_compare;
+ trigger_class->print = gtk_keyval_trigger_print;
+ trigger_class->print_label = gtk_keyval_trigger_print_label;
+
+ /**
+ * GtkKeyvalTrigger:keyval:
+ *
+ * The key value for the trigger.
+ */
+ keyval_props[KEYVAL_PROP_KEYVAL] =
+ g_param_spec_uint (I_("keyval"),
+ P_("Key value"),
+ P_("The key value for the trigger"),
+ 0, G_MAXINT,
+ 0,
+ G_PARAM_STATIC_STRINGS |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE);
+
+ /**
+ * GtkKeyvalTrigger:modifiers:
+ *
+ * The key modifiers for the trigger.
+ */
+ keyval_props[KEYVAL_PROP_MODIFIERS] =
+ g_param_spec_flags (I_("modifiers"),
+ P_("Modifiers"),
+ P_("The key modifiers for the trigger"),
+ GDK_TYPE_MODIFIER_TYPE,
+ 0,
+ G_PARAM_STATIC_STRINGS |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE);
+
+ g_object_class_install_properties (gobject_class, KEYVAL_N_PROPS, keyval_props);
+}
+
+static void
+gtk_keyval_trigger_init (GtkKeyvalTrigger *self)
+{
+}
/**
* gtk_keyval_trigger_new:
gtk_keyval_trigger_new (guint keyval,
GdkModifierType modifiers)
{
- GtkKeyvalTrigger *self;
-
- self = (GtkKeyvalTrigger *) gtk_shortcut_trigger_new (>K_KEYVAL_TRIGGER_CLASS);
-
- /* 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;
+ return g_object_new (GTK_TYPE_KEYVAL_TRIGGER,
+ "keyval", keyval,
+ "modifiers", modifiers,
+ NULL);
}
/**
* Returns: the modifiers
**/
GdkModifierType
-gtk_keyval_trigger_get_modifiers (GtkShortcutTrigger *self)
+gtk_keyval_trigger_get_modifiers (GtkKeyvalTrigger *self)
{
- GtkKeyvalTrigger *trigger = (GtkKeyvalTrigger *) self;
-
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (self, GTK_SHORTCUT_TRIGGER_KEYVAL), 0);
+ g_return_val_if_fail (GTK_IS_KEYVAL_TRIGGER (self), 0);
- return trigger->modifiers;
+ return self->modifiers;
}
/**
* Returns: the keyval
**/
guint
-gtk_keyval_trigger_get_keyval (GtkShortcutTrigger *self)
+gtk_keyval_trigger_get_keyval (GtkKeyvalTrigger *self)
{
- GtkKeyvalTrigger *trigger = (GtkKeyvalTrigger *) self;
-
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (self, GTK_SHORTCUT_TRIGGER_KEYVAL), 0);
+ g_return_val_if_fail (GTK_IS_KEYVAL_TRIGGER (self), 0);
- return trigger->keyval;
+ return self->keyval;
}
/*** GTK_MNEMONIC_TRIGGER ***/
-typedef struct _GtkMnemonicTrigger GtkMnemonicTrigger;
-
struct _GtkMnemonicTrigger
{
- GtkShortcutTrigger trigger;
+ GtkShortcutTrigger parent_instance;
guint keyval;
};
-static void
-gtk_mnemonic_trigger_finalize (GtkShortcutTrigger *trigger)
+struct _GtkMnemonicTriggerClass
{
-}
+ GtkShortcutTriggerClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkMnemonicTrigger, gtk_mnemonic_trigger, GTK_TYPE_SHORTCUT_TRIGGER)
+
+enum
+{
+ MNEMONIC_PROP_KEYVAL = 1,
+ MNEMONIC_N_PROPS
+};
+
+static GParamSpec *mnemonic_props[MNEMONIC_N_PROPS];
static GtkShortcutTriggerMatch
gtk_mnemonic_trigger_trigger (GtkShortcutTrigger *trigger,
GdkEvent *event,
gboolean enable_mnemonics)
{
- GtkMnemonicTrigger *self = (GtkMnemonicTrigger *) trigger;
+ GtkMnemonicTrigger *self = GTK_MNEMONIC_TRIGGER (trigger);
guint keyval;
if (!enable_mnemonics)
static guint
gtk_mnemonic_trigger_hash (GtkShortcutTrigger *trigger)
{
- GtkMnemonicTrigger *self = (GtkMnemonicTrigger *) trigger;
+ GtkMnemonicTrigger *self = GTK_MNEMONIC_TRIGGER (trigger);
return (self->keyval << 8)
- | GTK_SHORTCUT_TRIGGER_MNEMONIC;
+ | GTK_SHORTCUT_TRIGGER_HASH_MNEMONIC;
}
static int
gtk_mnemonic_trigger_compare (GtkShortcutTrigger *trigger1,
GtkShortcutTrigger *trigger2)
{
- GtkMnemonicTrigger *self1 = (GtkMnemonicTrigger *) trigger1;
- GtkMnemonicTrigger *self2 = (GtkMnemonicTrigger *) trigger2;
+ GtkMnemonicTrigger *self1 = GTK_MNEMONIC_TRIGGER (trigger1);
+ GtkMnemonicTrigger *self2 = GTK_MNEMONIC_TRIGGER (trigger2);
return self1->keyval - self2->keyval;
}
gtk_mnemonic_trigger_print (GtkShortcutTrigger *trigger,
GString *string)
{
- GtkMnemonicTrigger *self = (GtkMnemonicTrigger *) trigger;
+ GtkMnemonicTrigger *self = GTK_MNEMONIC_TRIGGER (trigger);
const char *keyval_str;
keyval_str = gdk_keyval_name (self->keyval);
GdkDisplay *display,
GString *string)
{
- GtkMnemonicTrigger *self = (GtkMnemonicTrigger *) trigger;
+ GtkMnemonicTrigger *self = GTK_MNEMONIC_TRIGGER (trigger);
const char *keyval_str;
keyval_str = gdk_keyval_name (self->keyval);
return TRUE;
}
-static const GtkShortcutTriggerClass GTK_MNEMONIC_TRIGGER_CLASS = {
- GTK_SHORTCUT_TRIGGER_MNEMONIC,
- sizeof (GtkMnemonicTrigger),
- "GtkMnemonicTrigger",
- gtk_mnemonic_trigger_finalize,
- gtk_mnemonic_trigger_trigger,
- gtk_mnemonic_trigger_hash,
- gtk_mnemonic_trigger_compare,
- gtk_mnemonic_trigger_print,
- gtk_mnemonic_trigger_print_label
-};
+static void
+gtk_mnemonic_trigger_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkMnemonicTrigger *self = GTK_MNEMONIC_TRIGGER (gobject);
+
+ switch (prop_id)
+ {
+ case MNEMONIC_PROP_KEYVAL:
+ {
+ guint keyval = g_value_get_uint (value);
+
+ /* 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);
+ }
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ }
+}
+
+static void
+gtk_mnemonic_trigger_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkMnemonicTrigger *self = GTK_MNEMONIC_TRIGGER (gobject);
+
+ switch (prop_id)
+ {
+ case MNEMONIC_PROP_KEYVAL:
+ g_value_set_uint (value, self->keyval);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ }
+}
+
+static void
+gtk_mnemonic_trigger_class_init (GtkMnemonicTriggerClass *klass)
+{
+ GtkShortcutTriggerClass *trigger_class = GTK_SHORTCUT_TRIGGER_CLASS (klass);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->set_property = gtk_mnemonic_trigger_set_property;
+ gobject_class->get_property = gtk_mnemonic_trigger_get_property;
+
+ trigger_class->trigger = gtk_mnemonic_trigger_trigger;
+ trigger_class->hash = gtk_mnemonic_trigger_hash;
+ trigger_class->compare = gtk_mnemonic_trigger_compare;
+ trigger_class->print = gtk_mnemonic_trigger_print;
+ trigger_class->print_label = gtk_mnemonic_trigger_print_label;
+
+ /**
+ * GtkMnemonicTrigger:keyval:
+ *
+ * The key value for the trigger.
+ */
+ mnemonic_props[KEYVAL_PROP_KEYVAL] =
+ g_param_spec_uint (I_("keyval"),
+ P_("Key value"),
+ P_("The key value for the trigger"),
+ 0, G_MAXINT,
+ 0,
+ G_PARAM_STATIC_STRINGS |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE);
+
+ g_object_class_install_properties (gobject_class, MNEMONIC_N_PROPS, mnemonic_props);
+}
+
+static void
+gtk_mnemonic_trigger_init (GtkMnemonicTrigger *self)
+{
+}
/**
* gtk_mnemonic_trigger_new:
* Mnemonics are activated by calling code when a key event with the right
* modifiers is detected.
*
- * Returns: A new #GtkShortcutTrigger
+ * Returns: (transfer full) (type GtkMnemonicTrigger): A new #GtkShortcutTrigger
*/
GtkShortcutTrigger *
gtk_mnemonic_trigger_new (guint keyval)
{
- GtkMnemonicTrigger *self;
-
- self = (GtkMnemonicTrigger *) gtk_shortcut_trigger_new (>K_MNEMONIC_TRIGGER_CLASS);
-
- /* 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);
-
- return &self->trigger;
+ return g_object_new (GTK_TYPE_MNEMONIC_TRIGGER,
+ "keyval", keyval,
+ NULL);
}
/**
* gtk_mnemonic_trigger_get_keyval:
- * @trigger: a mnemonic #GtkShortcutTrigger
+ * @self: a mnemonic #GtkShortcutTrigger
*
* Gets the keyval that must be pressed to succeed triggering @self.
*
* Returns: the keyval
**/
guint
-gtk_mnemonic_trigger_get_keyval (GtkShortcutTrigger *trigger)
+gtk_mnemonic_trigger_get_keyval (GtkMnemonicTrigger *self)
{
- GtkMnemonicTrigger *self = (GtkMnemonicTrigger *) trigger;
-
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (trigger, GTK_SHORTCUT_TRIGGER_MNEMONIC), 0);
+ g_return_val_if_fail (GTK_IS_MNEMONIC_TRIGGER (self), 0);
return self->keyval;
}
/*** GTK_ALTERNATIVE_TRIGGER ***/
-typedef struct _GtkAlternativeTrigger GtkAlternativeTrigger;
-
struct _GtkAlternativeTrigger
{
- GtkShortcutTrigger trigger;
+ GtkShortcutTrigger parent_instance;
GtkShortcutTrigger *first;
GtkShortcutTrigger *second;
};
+struct _GtkAlternativeTriggerClass
+{
+ GtkShortcutTriggerClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkAlternativeTrigger, gtk_alternative_trigger, GTK_TYPE_SHORTCUT_TRIGGER)
+
+enum
+{
+ ALTERNATIVE_PROP_FIRST = 1,
+ ALTERNATIVE_PROP_SECOND,
+ ALTERNATIVE_N_PROPS
+};
+
+static GParamSpec *alternative_props[ALTERNATIVE_N_PROPS];
+
static void
-gtk_alternative_trigger_finalize (GtkShortcutTrigger *trigger)
+gtk_alternative_trigger_dispose (GObject *gobject)
{
- GtkAlternativeTrigger *self = (GtkAlternativeTrigger *) trigger;
+ GtkAlternativeTrigger *self = GTK_ALTERNATIVE_TRIGGER (gobject);
+
+ g_clear_object (&self->first);
+ g_clear_object (&self->second);
- gtk_shortcut_trigger_unref (self->first);
- gtk_shortcut_trigger_unref (self->second);
+ G_OBJECT_CLASS (gtk_alternative_trigger_parent_class)->dispose (gobject);
}
static GtkShortcutTriggerMatch
GdkEvent *event,
gboolean enable_mnemonics)
{
- GtkAlternativeTrigger *self = (GtkAlternativeTrigger *) trigger;
+ GtkAlternativeTrigger *self = GTK_ALTERNATIVE_TRIGGER (trigger);
return MAX (gtk_shortcut_trigger_trigger (self->first, event, enable_mnemonics),
gtk_shortcut_trigger_trigger (self->second, event, enable_mnemonics));
static guint
gtk_alternative_trigger_hash (GtkShortcutTrigger *trigger)
{
- GtkAlternativeTrigger *self = (GtkAlternativeTrigger *) trigger;
+ GtkAlternativeTrigger *self = GTK_ALTERNATIVE_TRIGGER (trigger);
guint result;
result = gtk_shortcut_trigger_hash (self->first);
result |= gtk_shortcut_trigger_hash (self->second);
result <<= 5;
- return result | GTK_SHORTCUT_TRIGGER_ALTERNATIVE;
+ return result | GTK_SHORTCUT_TRIGGER_HASH_ALTERNATIVE;
}
static int
gtk_alternative_trigger_compare (GtkShortcutTrigger *trigger1,
GtkShortcutTrigger *trigger2)
{
- GtkAlternativeTrigger *self1 = (GtkAlternativeTrigger *) trigger1;
- GtkAlternativeTrigger *self2 = (GtkAlternativeTrigger *) trigger2;
+ GtkAlternativeTrigger *self1 = GTK_ALTERNATIVE_TRIGGER (trigger1);
+ GtkAlternativeTrigger *self2 = GTK_ALTERNATIVE_TRIGGER (trigger2);
int cmp;
cmp = gtk_shortcut_trigger_compare (self1->first, self2->first);
gtk_alternative_trigger_print (GtkShortcutTrigger *trigger,
GString *string)
{
- GtkAlternativeTrigger *self = (GtkAlternativeTrigger *) trigger;
+ GtkAlternativeTrigger *self = GTK_ALTERNATIVE_TRIGGER (trigger);
gtk_shortcut_trigger_print (self->first, string);
g_string_append (string, ", ");
GdkDisplay *display,
GString *string)
{
- GtkAlternativeTrigger *self = (GtkAlternativeTrigger *) trigger;
+ GtkAlternativeTrigger *self = GTK_ALTERNATIVE_TRIGGER (trigger);
if (gtk_shortcut_trigger_print_label (self->first, display, string))
{
}
}
-static const GtkShortcutTriggerClass GTK_ALTERNATIVE_TRIGGER_CLASS = {
- GTK_SHORTCUT_TRIGGER_ALTERNATIVE,
- sizeof (GtkAlternativeTrigger),
- "GtkAlternativeTrigger",
- gtk_alternative_trigger_finalize,
- gtk_alternative_trigger_trigger,
- gtk_alternative_trigger_hash,
- gtk_alternative_trigger_compare,
- gtk_alternative_trigger_print,
- gtk_alternative_trigger_print_label
-};
+static void
+gtk_alternative_trigger_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkAlternativeTrigger *self = GTK_ALTERNATIVE_TRIGGER (gobject);
+
+ switch (prop_id)
+ {
+ case ALTERNATIVE_PROP_FIRST:
+ self->first = g_value_dup_object (value);
+ break;
+
+ case ALTERNATIVE_PROP_SECOND:
+ self->second = g_value_dup_object (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ }
+}
+
+static void
+gtk_alternative_trigger_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkAlternativeTrigger *self = GTK_ALTERNATIVE_TRIGGER (gobject);
+
+ switch (prop_id)
+ {
+ case ALTERNATIVE_PROP_FIRST:
+ g_value_set_object (value, self->first);
+ break;
+
+ case ALTERNATIVE_PROP_SECOND:
+ g_value_set_object (value, self->second);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ }
+}
+
+static void
+gtk_alternative_trigger_constructed (GObject *gobject)
+{
+ GtkAlternativeTrigger *self = GTK_ALTERNATIVE_TRIGGER (gobject);
+
+ if (self->first == NULL || self->second == NULL)
+ {
+ g_critical ("Invalid alternative trigger, disabling");
+ self->first = g_object_ref (gtk_never_trigger_get ());
+ self->second = g_object_ref (gtk_never_trigger_get ());
+ }
+
+ G_OBJECT_CLASS (gtk_alternative_trigger_parent_class)->constructed (gobject);
+}
+
+static void
+gtk_alternative_trigger_class_init (GtkAlternativeTriggerClass *klass)
+{
+ GtkShortcutTriggerClass *trigger_class = GTK_SHORTCUT_TRIGGER_CLASS (klass);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->constructed = gtk_alternative_trigger_constructed;
+ gobject_class->set_property = gtk_alternative_trigger_set_property;
+ gobject_class->get_property = gtk_alternative_trigger_get_property;
+ gobject_class->dispose = gtk_alternative_trigger_dispose;
+
+ trigger_class->trigger = gtk_alternative_trigger_trigger;
+ trigger_class->hash = gtk_alternative_trigger_hash;
+ trigger_class->compare = gtk_alternative_trigger_compare;
+ trigger_class->print = gtk_alternative_trigger_print;
+ trigger_class->print_label = gtk_alternative_trigger_print_label;
+
+ /**
+ * GtkAlternativeTrigger:first:
+ *
+ * The first #GtkShortcutTrigger to check.
+ */
+ alternative_props[ALTERNATIVE_PROP_FIRST] =
+ g_param_spec_object (I_("first"),
+ P_("First"),
+ P_("The first trigger to check"),
+ GTK_TYPE_SHORTCUT_TRIGGER,
+ G_PARAM_STATIC_STRINGS |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE);
+ /**
+ * GtkAlternativeTrigger:second:
+ *
+ * The second #GtkShortcutTrigger to check.
+ */
+ alternative_props[ALTERNATIVE_PROP_SECOND] =
+ g_param_spec_object (I_("second"),
+ P_("Second"),
+ P_("The second trigger to check"),
+ GTK_TYPE_SHORTCUT_TRIGGER,
+ G_PARAM_STATIC_STRINGS |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE);
+
+ g_object_class_install_properties (gobject_class, ALTERNATIVE_N_PROPS, alternative_props);
+}
+
+static void
+gtk_alternative_trigger_init (GtkAlternativeTrigger *self)
+{
+}
/**
* gtk_alternative_trigger_new:
gtk_alternative_trigger_new (GtkShortcutTrigger *first,
GtkShortcutTrigger *second)
{
- GtkAlternativeTrigger *self;
+ GtkShortcutTrigger *res;
g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (first), NULL);
g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (second), NULL);
- self = (GtkAlternativeTrigger *) gtk_shortcut_trigger_new (>K_ALTERNATIVE_TRIGGER_CLASS);
+ res = g_object_new (GTK_TYPE_ALTERNATIVE_TRIGGER,
+ "first", first,
+ "second", second,
+ NULL);
- self->first = first;
- self->second = second;
+ g_object_unref (first);
+ g_object_unref (second);
- return &self->trigger;
+ return res;
}
/**
* Returns: (transfer none): the first alternative trigger
**/
GtkShortcutTrigger *
-gtk_alternative_trigger_get_first (GtkShortcutTrigger *self)
+gtk_alternative_trigger_get_first (GtkAlternativeTrigger *self)
{
- GtkAlternativeTrigger *trigger = (GtkAlternativeTrigger *) self;
-
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (self, GTK_SHORTCUT_TRIGGER_ALTERNATIVE), 0);
+ g_return_val_if_fail (GTK_IS_ALTERNATIVE_TRIGGER (self), NULL);
- return trigger->first;
+ return self->first;
}
/**
* Returns: (transfer none): the second alternative trigger
**/
GtkShortcutTrigger *
-gtk_alternative_trigger_get_second (GtkShortcutTrigger *self)
+gtk_alternative_trigger_get_second (GtkAlternativeTrigger *self)
{
- GtkAlternativeTrigger *trigger = (GtkAlternativeTrigger *) self;
-
- g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (self, GTK_SHORTCUT_TRIGGER_ALTERNATIVE), 0);
+ g_return_val_if_fail (GTK_IS_ALTERNATIVE_TRIGGER (self), NULL);
- return trigger->second;
+ return self->second;
}
projects / gtk4.git / commitdiff