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; }