static void
meta_ui_accelerator_parse (const char *accel,
guint *keysym,
guint *keycode,
GdkModifierType *keymask)
{
const char *above_tab;
if (accel[0] == '0' && accel[1] == 'x')
{
*keysym = 0;
*keycode = (guint) strtoul (accel, NULL, 16);
*keymask = 0;
return;
}
/* The key name 'Above_Tab' is special - it's not an actual keysym name,
* but rather refers to the key above the tab key. In order to use
* the GDK parsing for modifiers in combination with it, we substitute
* it with 'Tab' temporarily before calling gtk_accelerator_parse().
*/
#define is_word_character(c) (g_ascii_isalnum(c) || ((c) == '_'))
#define ABOVE_TAB "Above_Tab"
#define ABOVE_TAB_LEN 9
above_tab = strstr (accel, ABOVE_TAB);
if (above_tab &&
(above_tab == accel || !is_word_character (above_tab[-1])) &&
!is_word_character (above_tab[ABOVE_TAB_LEN]))
{
char *before = g_strndup (accel, above_tab - accel);
char *after = g_strdup (above_tab + ABOVE_TAB_LEN);
char *replaced = g_strconcat (before, "Tab", after, NULL);
gtk_accelerator_parse (replaced, NULL, keymask);
g_free (before);
g_free (after);
g_free (replaced);
*keysym = META_KEY_ABOVE_TAB;
return;
}
#undef is_word_character
#undef ABOVE_TAB
#undef ABOVE_TAB_LEN
gtk_accelerator_parse (accel, keysym, keymask);
}
void snippets_set_accelerator (GuSnippets* sc, gchar* config) {
/* config has the form: Key,Accel_key,Name */
GClosure* closure = NULL;
GdkModifierType mod;
guint keyval = 0;
gchar** configs = g_strsplit (config, ",", 0);
Tuple2* data = g_new0 (Tuple2, 1);
Tuple2* closure_data = g_new0 (Tuple2, 1);
/* Return if config does not contains accelerator */
if (strlen (configs[1]) == 0) {
g_strfreev (configs);
return;
}
data->first = (gpointer)sc;
data->second = (gpointer)g_strdup (configs[0]);
closure = g_cclosure_new (G_CALLBACK (snippets_accel_cb), data, NULL);
closure_data->first = (gpointer)data->second;
closure_data->second = (gpointer)closure;
sc->closure_data = g_list_append (sc->closure_data, closure_data);
gtk_accelerator_parse (configs[1], &keyval, &mod);
/* Return without connect if accel is not valid */
if (!gtk_accelerator_valid (keyval, mod)) return;
snippets_accel_connect (sc, keyval, mod, closure);
g_strfreev (configs);
}
/* Specific "focus-out-event" handler for shortcut GtkEntry events */
static gboolean preferences_dialog_shortcut_focus_out_event(GtkWidget * widget, GdkEventFocus * event, gchar * s)
{
guint key = 0;
GdkModifierType mods = 0;
const gchar * cur = gtk_entry_get_text(GTK_ENTRY(widget));
GList * sib;
if(g_strcmp0(s, cur) == 0)
/* Nothing changed. */
return FALSE;
/* Look for dupplicate accelerator. */
for(sib = gtk_container_get_children(GTK_CONTAINER(gtk_widget_get_parent(widget))); sib; sib = sib->next)
if(GTK_IS_ENTRY(sib->data) && GTK_WIDGET(sib->data) != widget && !g_strcmp0(cur, gtk_entry_get_text(GTK_ENTRY(sib->data))))
{
gtk_entry_set_text(GTK_ENTRY(widget), s);
return FALSE;
}
gtk_accelerator_parse(cur, &key, &mods);
/* Make sure accelerator is valid. */
if( ! (key == 0 && mods == 0) && gtk_accelerator_valid(key, mods))
{
g_free(s);
s = g_strdup(cur);
} else {
gtk_entry_set_text(GTK_ENTRY(widget), s);
}
return FALSE;
}
/**
* rb_button_bar_remove_accelerators:
* @bar: a #RBButtonBar
* @group: the #GtkAccelGroup to remove accelerators from
*
* Reverses the effects of @rb_button_bar_add_accelerators.
*/
void
rb_button_bar_remove_accelerators (RBButtonBar *bar, GtkAccelGroup *group)
{
GList *c, *l;
c = gtk_container_get_children (GTK_CONTAINER (bar));
for (l = c; l != NULL; l = l->next) {
GtkWidget *widget = l->data;
const char *accel_text;
guint accel_key;
GdkModifierType accel_mods;
accel_text = g_object_get_data (G_OBJECT (widget), "rb-accel");
if (accel_text != NULL) {
gtk_accelerator_parse (accel_text, &accel_key, &accel_mods);
if (accel_key != 0) {
gtk_widget_remove_accelerator (widget, group, accel_key, accel_mods);
}
}
/* handle menus attached to menu buttons */
if (GTK_IS_MENU_BUTTON (widget)) {
RBApplication *app = RB_APPLICATION (g_application_get_default ());
GMenuModel *model;
model = g_object_get_data (G_OBJECT (widget), "rb-menu-model");
if (model != NULL)
rb_application_set_menu_accelerators (app, model, FALSE);
}
}
g_list_free (c);
}
/**
* g_paste_keybinding_activate:
* @self: a #GPasteKeybinding instance
*
* Activate the keybinding
*
* Returns:
*/
G_PASTE_VISIBLE void
g_paste_keybinding_activate (GPasteKeybinding *self)
{
g_return_if_fail (G_PASTE_IS_KEYBINDING (self));
GPasteKeybindingPrivate *priv = self->priv;
g_return_if_fail (!priv->active);
GPasteXcbWrapper *xcb_wrapper = priv->xcb_wrapper;
xcb_connection_t *connection = (xcb_connection_t *) g_paste_xcb_wrapper_get_connection (xcb_wrapper);
xcb_screen_t *screen = (xcb_screen_t *) g_paste_xcb_wrapper_get_screen (xcb_wrapper);
guint keysym;
g_return_if_fail (screen); /* This should never happen */
gtk_accelerator_parse (priv->binding, &keysym, (GdkModifierType *) &priv->modifiers);
priv->keycodes = xcb_key_symbols_get_keycode ((xcb_key_symbols_t *) g_paste_xcb_wrapper_get_keysyms (xcb_wrapper), keysym);
gdk_error_trap_push ();
for (xcb_keycode_t *keycode = priv->keycodes; *keycode; ++keycode)
{
xcb_grab_key (connection,
FALSE,
screen->root,
priv->modifiers,
*keycode,
XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC);
}
xcb_flush (connection);
gdk_error_trap_pop_ignored ();
priv->active = TRUE;
}
static void
cc_wacom_button_row_update_shortcut (CcWacomButtonRow *row,
GsdWacomActionType action_type)
{
CcWacomButtonRowPrivate *priv;
GsdWacomTabletButton *button;
GtkDirectionType dir;
guint keyval;
GdkModifierType mask;
char *shortcut;
if (action_type != GSD_WACOM_ACTION_TYPE_CUSTOM)
return;
priv = row->priv;
button = priv->button;
dir = priv->direction;
if (button->type == WACOM_TABLET_BUTTON_TYPE_STRIP ||
button->type == WACOM_TABLET_BUTTON_TYPE_RING)
{
char *str;
char **strv;
strv = g_settings_get_strv (button->settings, KEY_CUSTOM_ELEVATOR_ACTION);
if (strv != NULL)
{
if (dir == GTK_DIR_UP)
str = strv[0];
else
str = strv[1];
shortcut = g_strdup (str);
g_strfreev (strv);
}
else
{
shortcut = NULL;
}
}
else
shortcut = g_settings_get_string (button->settings, CUSTOM_ACTION_KEY);
if (shortcut != NULL)
{
gtk_accelerator_parse (shortcut, &keyval, &mask);
g_object_set (priv->key_shortcut_button,
"key-value", keyval,
"key-mods", mask,
NULL);
g_free (shortcut);
}
}
static void
key_dialog_save (GtkWidget *wid, gpointer userdata)
{
GtkTreeModel *store = get_store ();
GtkTreeIter iter;
struct key_binding *kb;
char *data1, *data2, *accel, *actiontext;
guint keyval;
GdkModifierType mod;
if (keybind_list)
{
g_slist_free_full (keybind_list, key_free);
keybind_list = NULL;
}
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter))
{
do
{
kb = g_new0 (struct key_binding, 1);
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ACCEL_COLUMN, &accel,
ACTION_COLUMN, &actiontext,
D1_COLUMN, &data1,
D2_COLUMN, &data2,
-1);
kb->data1 = data1;
kb->data2 = data2;
if (accel)
{
gtk_accelerator_parse (accel, &keyval, &mod);
kb->keyval = keyval;
kb->mod = key_modifier_get_valid (mod);
g_free (accel);
}
if (actiontext)
{
kb->action = key_get_action_from_string (actiontext);
g_free (actiontext);
}
if (!accel || !actiontext)
key_free (kb);
else
keybind_list = g_slist_append (keybind_list, kb);
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter));
}
if (key_save_kbs () == 0)
key_dialog_close (wid, NULL);
}
/**
* dbusmenu_menuitem_property_get_shortcut:
* @menuitem: The #DbusmenuMenuitem to get the shortcut off
* @key: (out): Location to put the key value
* @modifier: (out): Location to put the modifier mask
*
* This function gets a GTK shortcut as a key and a mask
* for use to set the accelerators.
*/
void
dbusmenu_menuitem_property_get_shortcut (DbusmenuMenuitem * menuitem, guint * key, GdkModifierType * modifier)
{
guint dummykey;
GdkModifierType dummymodifier;
if (key == NULL) {
key = &dummykey;
}
if (modifier == NULL) {
modifier = &dummymodifier;
}
*key = 0;
*modifier = 0;
g_return_if_fail(DBUSMENU_IS_MENUITEM(menuitem));
GVariant * wrapper = dbusmenu_menuitem_property_get_variant(menuitem, DBUSMENU_MENUITEM_PROP_SHORTCUT);
if (wrapper == NULL) {
return;
}
if (g_variant_n_children(wrapper) != 1) {
g_warning("Unable to parse shortcut, too many keys");
return;
}
GVariantIter iter;
GVariant * child = g_variant_get_child_value(wrapper, 0);
g_variant_iter_init(&iter, child);
gchar * string;
while(g_variant_iter_loop(&iter, "s", &string)) {
if (g_strcmp0(string, DBUSMENU_MENUITEM_SHORTCUT_CONTROL) == 0) {
*modifier |= GDK_CONTROL_MASK;
} else if (g_strcmp0(string, DBUSMENU_MENUITEM_SHORTCUT_ALT) == 0) {
*modifier |= GDK_MOD1_MASK;
} else if (g_strcmp0(string, DBUSMENU_MENUITEM_SHORTCUT_SHIFT) == 0) {
*modifier |= GDK_SHIFT_MASK;
} else if (g_strcmp0(string, DBUSMENU_MENUITEM_SHORTCUT_SUPER) == 0) {
*modifier |= GDK_SUPER_MASK;
} else {
GdkModifierType tempmod;
gtk_accelerator_parse(string, key, &tempmod);
}
}
g_variant_unref(child);
return;
}
static void _add_hotkey (const gchar *hotkey, GtkAccelGroup *accelgroup,
GCallback callback, gpointer user_data) {
GClosure *keycallback;
guint accelkey;
GdkModifierType accelmod;
gtk_accelerator_parse (hotkey, &accelkey, &accelmod);
keycallback = g_cclosure_new_swap (callback, user_data, NULL);
gtk_accel_group_connect(accelgroup, accelkey, accelmod, 0, keycallback);
g_closure_unref(keycallback);
}
static void
spice_hotkey_set_accel(const gchar *accel_path, const gchar *key)
{
gchar *accel;
guint accel_key;
GdkModifierType accel_mods;
accel = spice_hotkey_to_gtk_accelerator(key);
gtk_accelerator_parse(accel, &accel_key, &accel_mods);
g_free(accel);
gtk_accel_map_change_entry(accel_path, accel_key, accel_mods, TRUE);
}
CAMLprim value ml_gtk_accelerator_parse(value acc)
{
CAMLparam0();
CAMLlocal2(vmods, tup);
guint key;
GdkModifierType mods;
gtk_accelerator_parse(String_val(acc), &key, &mods);
vmods = mods ? Val_GdkModifier_flags(mods) : Val_emptylist;
tup = alloc_small(2, 0);
Field(tup, 0) = Val_int(key);
Field(tup, 1) = vmods;
CAMLreturn(tup);
}
void gtkui_page_attach_shortcut(GtkWidget *win, void (*attacher)(void))
{
GtkAccelGroup *accel;
GClosure *closure = NULL;
GdkModifierType mods;
gint keyval;
accel = gtk_accel_group_new ();
gtk_window_add_accel_group(GTK_WINDOW (win), accel);
closure = g_cclosure_new(G_CALLBACK(attacher), NULL, NULL);
gtk_accelerator_parse ("<control>D", &keyval, &mods);
gtk_accel_group_connect(accel, keyval, mods, 0, closure);
}
static void
extract_accel_from_menu_item(GMenuModel * model,
gint item,
GActionMap * action_map,
GtkAccelGroup * accel_group)
{
GMenuAttributeIter *iter;
const gchar *key;
GVariant *value;
const gchar *accel = NULL;
const gchar *action = NULL;
GVariant *target = NULL;
iter = g_menu_model_iterate_item_attributes(model, item);
while (g_menu_attribute_iter_get_next(iter, &key, &value)) {
if (g_str_equal(key, "action")
&& g_variant_is_of_type(value, G_VARIANT_TYPE_STRING))
action = g_variant_get_string(value, NULL);
else if (g_str_equal(key, "accel")
&& g_variant_is_of_type(value, G_VARIANT_TYPE_STRING))
accel = g_variant_get_string(value, NULL);
else if (g_str_equal(key, "target"))
target = g_variant_ref(value);
g_variant_unref(value);
}
g_object_unref(iter);
if (accel && action) {
guint accel_key;
GdkModifierType accel_mods;
AccelInfo *info;
const gchar *basename;
GClosure *closure;
gtk_accelerator_parse(accel, &accel_key, &accel_mods);
basename = strchr(action, '.');
basename = basename ? basename + 1 : action;
info = g_new(AccelInfo, 1);
info->action = g_action_map_lookup_action(action_map, basename);
info->parameter = target ? g_variant_ref(target) : NULL;
closure = g_cclosure_new(G_CALLBACK(accel_activate), info,
(GClosureNotify) accel_info_free);
gtk_accel_group_connect(accel_group, accel_key, accel_mods, 0,
closure);
}
if (target)
g_variant_unref(target);
}
static gboolean install_keygrab(const char *accelerator, struct keygrab_data *data)
{
GdkDisplay *display = gdk_display_get_default();
int i;
int xerr;
g_return_val_if_fail(accelerator, FALSE);
g_return_val_if_fail(data, FALSE);
gtk_accelerator_parse(accelerator,
&data->keyval,
&data->modifiers);
if(data->keyval==0) {
fprintf(stderr,
"error: invalid accelerator: '%s'\n",
accelerator);
return FALSE;
}
gdk_error_trap_push();
data->keycode=XKeysymToKeycode(GDK_DISPLAY(), data->keyval);
for (i = 0; i < gdk_display_get_n_screens (display); i++) {
GdkScreen *screen;
GdkWindow *root;
screen = gdk_display_get_screen (display, i);
if (!screen) {
continue;
}
root = gdk_screen_get_root_window (screen);
XGrabKey(GDK_DISPLAY(),
data->keycode,
data->modifiers,
GDK_WINDOW_XID(root),
True,
GrabModeAsync,
GrabModeAsync);
}
gdk_flush();
xerr=gdk_error_trap_pop();
if(xerr!=0) {
return FALSE;
}
printf("ocha: Type %s to open the seach window.\n",
accelerator);
return TRUE;
}
static void
meta_ui_accelerator_parse (const char *accel,
guint *keysym,
guint *keycode,
GdkModifierType *keymask)
{
if (accel[0] == '0' && accel[1] == 'x')
{
*keysym = 0;
*keycode = (guint) strtoul (accel, NULL, 16);
*keymask = 0;
}
else
gtk_accelerator_parse (accel, keysym, keymask);
}
static bool nsgtk_menu_add_image_item(GtkMenu *menu,
GtkImageMenuItem **item, const char *message,
const char *messageAccel, GtkAccelGroup *group)
{
unsigned int key;
GdkModifierType mod;
*item = GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_with_mnemonic(
messages_get(message)));
if (*item == NULL)
return false;
gtk_accelerator_parse(messages_get(messageAccel), &key, &mod);
if (key > 0)
gtk_widget_add_accelerator(GTK_WIDGET(*item), "activate",
group, key, mod, GTK_ACCEL_VISIBLE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), GTK_WIDGET(*item));
gtk_widget_show(GTK_WIDGET(*item));
return true;
}
static void
panel_bindings_mouse_modifier_set_from_string (const char *str)
{
guint modifier_keysym;
guint modifier_keymask;
gtk_accelerator_parse (str, &modifier_keysym, &modifier_keymask);
if (modifier_keysym == 0 && modifier_keymask == 0) {
g_warning ("Unable to parse mouse modifier '%s'\n", str);
return;
}
if (modifier_keymask)
mouse_button_modifier_keymask = modifier_keymask;
else
mouse_button_modifier_keymask = DEFAULT_MOUSE_MODIFIER;
}
static void
wxGetGtkAccel(const wxMenuItem* item, guint* accel_key, GdkModifierType* accel_mods)
{
*accel_key = 0;
const wxString string = GetGtkHotKey(*item);
if (!string.empty())
gtk_accelerator_parse(wxGTK_CONV_SYS(string), accel_key, accel_mods);
else
{
GtkStockItem stock_item;
const char* stockid = wxGetStockGtkID(item->GetId());
if (stockid && gtk_stock_lookup(stockid, &stock_item))
{
*accel_key = stock_item.keyval;
*accel_mods = stock_item.modifier;
}
}
}
void add_shortcuts(void)
{
long i = 0;
guint acc_key;
GdkModifierType mod;
if(macros == NULL)
return;
while(macros[i].shortcut != NULL)
{
macros[i].closure = g_cclosure_new_swap(G_CALLBACK(shortcut_callback), (gpointer)i, NULL);
gtk_accelerator_parse(macros[i].shortcut, &acc_key, &mod);
if(acc_key != 0)
gtk_accel_group_connect(shortcuts, acc_key, mod, GTK_ACCEL_MASK, macros[i].closure);
i++;
}
}
static gboolean
variant_to_keyval (GVariant *value,
gpointer *result,
KeyEntry *entry)
{
if (value == NULL) {
entry->keyval = GDK_KEY_VoidSymbol;
entry->modifiers = 0;
return TRUE;
}
gtk_accelerator_parse (g_variant_get_string (value, NULL),
&entry->keyval, &entry->modifiers);
if (entry->keyval == 0 && entry->modifiers == 0)
return FALSE;
return TRUE;
}
/**
* dbusmenu_menuitem_property_set_shortcut_string:
* @menuitem: The #DbusmenuMenuitem to set the shortcut on
* @shortcut: String describing the shortcut
*
* This function takes a GTK shortcut string as defined in
* #gtk_accelerator_parse and turns that into the information
* required to send it over DBusmenu.
*
* Return value: Whether it was successful at setting the property.
*/
gboolean
dbusmenu_menuitem_property_set_shortcut_string (DbusmenuMenuitem * menuitem, const gchar * shortcut)
{
g_return_val_if_fail(DBUSMENU_IS_MENUITEM(menuitem), FALSE);
g_return_val_if_fail(shortcut != NULL, FALSE);
guint key = 0;
GdkModifierType modifier = 0;
gtk_accelerator_parse(shortcut, &key, &modifier);
if (key == 0) {
g_warning("Unable to parse shortcut string '%s'", shortcut);
return FALSE;
}
return dbusmenu_menuitem_property_set_shortcut(menuitem, key, modifier);
}
static guint
accel_map_parse_accel_path (GScanner *scanner)
{
guint accel_key = 0;
GdkModifierType accel_mods = 0;
gchar *path, *accel;
/* parse accel path */
g_scanner_get_next_token (scanner);
if (scanner->token != G_TOKEN_STRING)
return G_TOKEN_STRING;
/* test if the next token is an accelerator */
g_scanner_peek_next_token (scanner);
if (scanner->next_token != G_TOKEN_STRING)
{
/* if not so, eat that token and error out */
g_scanner_get_next_token (scanner);
return G_TOKEN_STRING;
}
/* get the full accelerator specification */
path = g_strdup (scanner->value.v_string);
g_scanner_get_next_token (scanner);
accel = g_strdup (scanner->value.v_string);
/* ensure the entry is present */
gtk_accel_map_add_entry (path, 0, 0);
/* and propagate it */
gtk_accelerator_parse (accel, &accel_key, &accel_mods);
gtk_accel_map_change_entry (path, accel_key, accel_mods, TRUE);
g_free (accel);
g_free (path);
/* check correct statement end */
g_scanner_get_next_token (scanner);
if (scanner->token != ')')
return ')';
else
return G_TOKEN_NONE;
}
static void
panel_binding_set_from_string (PanelBinding *binding,
const char *str)
{
g_assert (binding->keyval == 0);
g_assert (binding->modifiers == 0);
if (!str || !str [0] || !strcmp (str, "disabled")) {
binding->keyval = 0;
binding->modifiers = 0;
return;
}
gtk_accelerator_parse (str, &binding->keyval, &binding->modifiers);
if (binding->keyval == 0 && binding->modifiers == 0) {
g_warning ("Enable to parse binding '%s'\n", str);
return;
}
}
int
clip_GTK_ACCELERATORPARSE(ClipMachine * ClipMachineMemory)
{
gchar *accelerator = _clip_parc(ClipMachineMemory, 1);
guint keyval;
GdkModifierType modifiers;
CHECKARG(1, CHARACTER_type_of_ClipVarType);
gtk_accelerator_parse(accelerator, &keyval, &modifiers);
_clip_storni(ClipMachineMemory, keyval, 2, 0);
_clip_storni(ClipMachineMemory, modifiers, 3, 0);
return 0;
err:
return 1;
}
static gboolean
binding_from_string (const char *str,
guint *accelerator_key,
GdkModifierType *accelerator_mods)
{
if (str == NULL ||
strcmp (str, "disabled") == 0)
{
*accelerator_key = 0;
*accelerator_mods = 0;
return TRUE;
}
gtk_accelerator_parse (str, accelerator_key, accelerator_mods);
if (*accelerator_key == 0 &&
*accelerator_mods == 0)
return FALSE;
return TRUE;
}
static void
set_accel (GtkApplication *app, GtkWidget *widget)
{
GtkWidget *accel_label;
const gchar *action;
gchar **accels;
guint key;
GdkModifierType mods;
accel_label = gtk_bin_get_child (GTK_BIN (widget));
g_assert (GTK_IS_ACCEL_LABEL (accel_label));
action = gtk_actionable_get_action_name (GTK_ACTIONABLE (widget));
accels = gtk_application_get_accels_for_action (app, action);
gtk_accelerator_parse (accels[0], &key, &mods);
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (accel_label), key, mods);
g_strfreev (accels);
}
static gboolean
do_grab_key (struct Binding *binding)
{
gboolean success;
GdkWindow *rootwin = gdk_get_default_root_window ();
GdkKeymap *keymap = gdk_keymap_get_default ();
GdkModifierType modifiers;
guint keysym = 0;
if (keymap == NULL || rootwin == NULL)
return FALSE;
gtk_accelerator_parse(binding->keystring, &keysym, &modifiers);
if (keysym == 0)
return FALSE;
binding->keyval = keysym;
binding->modifiers = modifiers;
TRACE (g_print ("Grabbing keyval: %d, vmodifiers: 0x%x, name: %s\n",
keysym, modifiers, binding->keystring));
/* Map virtual modifiers to non-virtual modifiers */
gdk_keymap_map_virtual_modifiers(keymap, &modifiers);
if (modifiers == binding->modifiers &&
(GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK) & modifiers) {
g_warning ("Failed to map virtual modifiers");
return FALSE;
}
success = grab_ungrab (rootwin, keysym, modifiers, TRUE /* grab */);
/*
if (!success) {
g_warning ("Binding '%s' failed!", binding->keystring);
}
*/
return success;
}
void
libbalsa_window_add_accelerator(GtkApplicationWindow * window,
const gchar * accel,
const gchar * action_name)
{
GActionMap *action_map = G_ACTION_MAP(window);
guint accel_key;
GdkModifierType accel_mods;
const gchar *basename;
GAction *action;
AccelInfo *info;
GClosure *closure;
GtkAccelGroup *accel_group;
gtk_accelerator_parse(accel, &accel_key, &accel_mods);
if (!accel_key) {
g_print("%s: could not parse accelerator “%s”\n", __func__,
accel);
return;
}
basename = strchr(action_name, '.');
basename = basename ? basename + 1 : action_name;
action = g_action_map_lookup_action(action_map, basename);
if (!action) {
g_print("%s: could not lookup action “%s”\n", __func__,
action_name);
return;
}
info = g_new(AccelInfo, 1);
info->action = action;
info->parameter = NULL;
closure = g_cclosure_new(G_CALLBACK(accel_activate), info,
(GClosureNotify) accel_info_free);
accel_group = gtk_accel_group_new();
gtk_accel_group_connect(accel_group, accel_key, accel_mods, 0,
closure);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
}
void visit( const char* name, Accelerator& accelerator ){
char value[1024];
if ( read_var( m_filename, "Commands", name, value ) ) {
if ( string_empty( value ) ) {
accelerator.key = 0;
accelerator.modifiers = (GdkModifierType)0;
return;
}
gtk_accelerator_parse( value, &accelerator.key, &accelerator.modifiers );
accelerator = accelerator; // fix modifiers
if ( accelerator.key != 0 ) {
++m_count;
}
else
{
globalOutputStream() << "WARNING: failed to parse user command " << makeQuoted( name ) << ": unknown key " << makeQuoted( value ) << "\n";
}
}
}
bool cterm_register_accel(CTerm* term, const char* keyspec, GCallback callback_func) {
guint key;
GdkModifierType mod;
GClosure* closure;
/* Empty key spec */
if(keyspec[0] == '\0') {
return true;
}
if(term->config.keys == NULL) {
term->config.keys = gtk_accel_group_new();
}
gtk_accelerator_parse(keyspec, &key, &mod);
if(key == 0 || mod == 0) {
return false;
}
closure = g_cclosure_new_swap(callback_func, (gpointer)term, NULL);
gtk_accel_group_connect(term->config.keys, key, mod, GTK_ACCEL_LOCKED, closure);
return true;
}
