int gKey::fromString(char *str) { char *lstr; int key; if (!str || !*str) return 0; lstr = g_ascii_strup(str, -1); key = gdk_keyval_from_name(lstr); g_free(lstr); if (key) return key; lstr = g_ascii_strdown(str, -1); key = gdk_keyval_from_name(lstr); g_free(lstr); if (key) return key; key = gdk_keyval_from_name(str); if (key) return key; if (!str[1] && isascii(str[0])) return str[0]; else return 0; }
gboolean parse_keystr(const gchar* keystr, GtkWidget* widget, HotkeyEntry* key) { guint keyval; GdkKeymapKey *keys; gint n; GdkDisplay* display; if (!keystr || strlen(keystr) < 1) return FALSE; keyval = gdk_keyval_from_name(keystr); if (keyval == GDK_VoidSymbol) return FALSE; display = widget ? gtk_widget_get_display(widget) : gdk_display_get_default(); if (!display) return FALSE; gdk_keymap_get_entries_for_keyval( gdk_keymap_get_for_display(display), keyval, &keys, &n); if (n < 1) return FALSE; key->code = keys[0].keycode; return TRUE; }
static gboolean backspace_key_clicked(GtkWidget *widget, GdkEventKey *event, XmiMsimGuiLayerDialog *dialog) { if (event->keyval == gdk_keyval_from_name("BackSpace")) { remove_button_clicked(NULL, dialog); return TRUE; } return FALSE; }
GladeAccelInfo * glade_accel_read (GladeXmlNode * node, gboolean require_signal) { GladeAccelInfo *ainfo; gchar *key, *modifiers, *signal; g_return_val_if_fail (node != NULL, NULL); if (!glade_xml_node_verify (node, GLADE_TAG_ACCEL)) return NULL; /* Get from xml... */ key = glade_xml_get_property_string_required (node, GLADE_TAG_ACCEL_KEY, NULL); if (require_signal) signal = glade_xml_get_property_string_required (node, GLADE_TAG_ACCEL_SIGNAL, NULL); else signal = glade_xml_get_property_string (node, GLADE_TAG_ACCEL_SIGNAL); modifiers = glade_xml_get_property_string (node, GLADE_TAG_ACCEL_MODIFIERS); /* translate to GladeAccelInfo... */ ainfo = g_new0 (GladeAccelInfo, 1); ainfo->key = gdk_keyval_from_name (key); ainfo->signal = signal; /* take string ownership... */ ainfo->modifiers = glade_gtk_parse_modifiers (modifiers); g_free (modifiers); return ainfo; }
int termit_parse_keys_str(const gchar* keybinding, struct KeyWithState* kws) { gchar *modifier = NULL, *key = NULL; // token[0] - modifier. Only Alt, Ctrl or Shift allowed. gchar** tokens = g_strsplit(keybinding, "-", 2); if (!tokens[0]) { ERROR("failed to parse: [%s]", keybinding); return -1; } if (!tokens[1]) { key = tokens[0]; } else { modifier = tokens[0]; key = tokens[1]; } gint tmp_state = 0; if (modifier) { tmp_state = get_modifier_state(modifier); if (tmp_state == GDK_NOTHING) { TRACE("Bad modifier: %s", keybinding); return -1; } } guint tmp_keyval = gdk_keyval_from_name(key); if (tmp_keyval == GDK_KEY_VoidSymbol) { TRACE("Bad keyval: %s", keybinding); return -1; } g_strfreev(tokens); kws->state = tmp_state; kws->keyval = gdk_keyval_to_lower(tmp_keyval); return 0; }
/** * spice_grab_sequence_new_from_string: * @str: a string of '+' seperated key names (ex: "Control_L+Alt_L") * * Returns: a new #SpiceGrabSequence. **/ SpiceGrabSequence *spice_grab_sequence_new_from_string(const gchar *str) { gchar **keysymstr; int i; SpiceGrabSequence *sequence; sequence = g_slice_new0(SpiceGrabSequence); keysymstr = g_strsplit(str, "+", 5); sequence->nkeysyms = 0; while (keysymstr[sequence->nkeysyms]) sequence->nkeysyms++; sequence->keysyms = g_new0(guint, sequence->nkeysyms); for (i = 0 ; i < sequence->nkeysyms ; i++) { sequence->keysyms[i] = (guint)gdk_keyval_from_name(keysymstr[i]); if (sequence->keysyms[i] == 0) { g_critical("Invalid key: %s", keysymstr[i]); } } g_strfreev(keysymstr); return sequence; }
static guint _gdk_keyval_from_name (const gchar *keyval_name) { if (keyval_name != NULL) return gdk_keyval_from_name (keyval_name); else return GDK_KEY_VoidSymbol; }
/* Converts a key name to a key value. */ int clip_GDK_KEYVALFROMNAME(ClipMachine * ClipMachineMemory) { gchar *keyval_name = CHAR_OPTION(ClipMachineMemory, 1, ""); _clip_retni(ClipMachineMemory, gdk_keyval_from_name(keyval_name)); return 0; }
signed long kbd_arch_keyname_to_keynum(char *keyname) { guint sym = gdk_keyval_from_name(keyname); if (sym == KEYSYM_VoidSymbol) { return -1; } return (signed long)sym; }
guint EventManager::getGDKCode(const std::string& keyStr) { guint returnValue = gdk_keyval_to_upper(gdk_keyval_from_name(keyStr.c_str())); if (returnValue == GDK_VoidSymbol) { rWarning() << "EventManager: Could not recognise key " << keyStr << std::endl; } return returnValue; }
static void AddAccelorator(GtkAccelGroup *accel,char *shortcut, GtkWidget *mi) { static struct { char *modifier; int mask; } modifiers[] = { { "Ctl", GDK_CONTROL_MASK }, { "Control", GDK_CONTROL_MASK }, { "Shft", GDK_SHIFT_MASK }, { "Shift", GDK_SHIFT_MASK }, { "CapsLk", GDK_LOCK_MASK }, { "CapsLock", GDK_LOCK_MASK }, { "Meta", GDK_MOD1_MASK }, { "Alt", GDK_MOD1_MASK }, { "Flag0x01", 0x01 }, { "Flag0x02", 0x02 }, { "Flag0x04", 0x04 }, { "Flag0x08", 0x08 }, { "Flag0x10", 0x10 }, { "Flag0x20", 0x20 }, { "Flag0x40", 0x40 }, { "Flag0x80", 0x80 }, { "Opt", 0x2000 }, { "Option", 0x2000 }, { NULL }}; char *pt; int mask, keysym, temp, i; mask = 0; keysym = '\0'; pt = strchr(shortcut,'|'); if ( pt!=NULL ) shortcut = pt+1; if ( *shortcut=='\0' || strcmp(shortcut,"No Shortcut")==0 ) return; mask = 0; while ( (pt=strchr(shortcut,'+'))!=NULL && pt!=shortcut ) { /* A '+' can also occur as the short cut char itself */ for ( i=0; modifiers[i].modifier!=NULL; ++i ) { if ( strncasecmp(shortcut,modifiers[i].modifier,pt-shortcut)==0 ) break; } if ( modifiers[i].modifier!=NULL ) mask |= modifiers[i].mask; else if ( sscanf( shortcut, "0x%x", &temp)==1 ) mask |= temp; else { fprintf( stderr, "Could not parse short cut: %s\n", shortcut ); return; } shortcut = pt+1; } keysym = gdk_keyval_from_name(shortcut); gtk_widget_add_accelerator (GTK_WIDGET(mi), "activate", accel, keysym, mask, GTK_ACCEL_VISIBLE); }
unsigned int global_keys_find( const char* name ){ guint k; if ( !name || !*name ) { return 0; } k = gdk_keyval_from_name( name ); if ( k == GDK_KEY_VoidSymbol ) { return 0; } return k; }
bool App2::EnergiesGrid::on_backspace_clicked(GdkEventKey *event) { if (event->keyval == gdk_keyval_from_name("BackSpace") || event->keyval == gdk_keyval_from_name("Delete")) { Glib::RefPtr<Gtk::TreeSelection> selection = tv.get_selection(); std::vector<Gtk::TreeModel::Path> paths = selection->get_selected_rows(); for (std::vector<Gtk::TreeModel::Path>::reverse_iterator rit = paths.rbegin() ; rit != paths.rend() ; ++rit) { Gtk::TreeModel::Row row = *(model->get_iter(*rit)); //remove samples_grid page assistant->remove_page(row[columns.col_samples_grid_page_index]); assistant->samples_grid_vec.erase(assistant->samples_grid_vec.begin()+row[columns.col_pures_grid_page_index]-2); //remove pures_grid page assistant->remove_page(row[columns.col_pures_grid_page_index]); assistant->pures_grid_vec.erase(assistant->pures_grid_vec.begin()+row[columns.col_pures_grid_page_index]-2); model->erase(row); } //update col_pures_grid_page_index and col_samples_grid_page_index for all unsigned int counter = 0; for (Gtk::TreeModel::Children::iterator iter = model->children().begin() ; iter != model->children().end() ; ++iter) { Gtk::TreeModel::Row row = *iter; row[columns.col_pures_grid_page_index] = counter + 2; row[columns.col_samples_grid_page_index] = model->children().size() + counter + 2; } if (model->children().size() >= 1) { assistant->set_page_complete(*this, true); } else { assistant->set_page_complete(*this, false); } //In case the samples_summary_grid was complete, undo this assistant->set_page_complete(assistant->samples_summary_grid, false); assistant->show_all_children(); assistant->update_buttons_state(); return true; } return false; }
static void temu_parse_bind_switch (terms_t *terms, char **subs, bind_actions_t action) { bind_t *bind = calloc (1, sizeof (bind_t)); bind->next = terms->keys; terms->keys = bind; bind->action = action; bind->base = strtol(subs[0], NULL, 0); bind->state = strtol(subs[1], NULL, 0); bind->key_min = gdk_keyval_from_name (subs[2]); if (subs[4]) bind->key_max = gdk_keyval_from_name (subs[4]); else bind->key_max = bind->key_min; if (subs[5]) bind->cmd = strdup (subs[5]); terms->n_active += bind->key_max - bind->key_min; terms->n_active++; }
static guint remmina_pref_get_keyval_from_str (const gchar *str) { guint k; if (!str) return 0; k = gdk_keyval_from_name (str); if (!k) { if (sscanf (str, "%x", &k) < 1) k = 0; } return k; }
void install_keyboard_bindings() { GtkAccelGroup *gtk_accel = gtk_accel_group_new (); GClosure *closure; // Horizontal split closure = g_cclosure_new(G_CALLBACK(new_view_horizontal), (gpointer)NULL, NULL); gtk_accel_group_connect(gtk_accel, gdk_keyval_from_name("d"), GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE, closure); g_closure_unref(closure); // Vertical split closure = g_cclosure_new(G_CALLBACK(new_view_vertical), (gpointer)NULL, NULL); gtk_accel_group_connect(gtk_accel, gdk_keyval_from_name("s"), GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE, closure); g_closure_unref(closure); closure = g_cclosure_new(G_CALLBACK(next_view), (gpointer)NULL, NULL); gtk_accel_group_connect(gtk_accel, gdk_keyval_from_name("w"), GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE, closure); g_closure_unref(closure); gtk_window_add_accel_group (GTK_WINDOW(chrome->window), gtk_accel); }
gboolean advanceLine(GtkWidget *widget, GdkEventKey *event, gpointer user_data) { guint keycode = event->keyval; UpdateData *data = (UpdateData *) user_data; if(keycode == gdk_keyval_from_name("F5")) { printf("Running Next Instruction\n"); data->unit->nextInst(data->unit); refresh_lists(data); } return 1; }
static void temu_parse_bind_action (terms_t *terms, char **subs) { bind_t *bind = calloc (1, sizeof (bind_t)); bind->next = terms->keys; terms->keys = bind; if (!strcasecmp(subs[0], "CUT")) { bind->action = BIND_ACT_CUT; } else if (!strcasecmp(subs[0], "PASTE")) { bind->action = BIND_ACT_PASTE; } else { return; } bind->state = strtol (subs[1], NULL, 0); bind->key_min = bind->key_max = gdk_keyval_from_name (subs[2]); // printf ("Binding: keyval: %d, state: 0x%x, action: %d\n", bind->key_min, bind->state, bind->action); }
/* * parse key string */ int hotkey_parse(char *hotkey, guint *key, guint *mask) { char c; char *tmp = g_new0(char, strlen(hotkey)); int i, idx = 0; begin_func("hotkey_parse"); *mask = 0; for (i = 0; i < strlen(hotkey); i++) { c = hotkey[i]; if (isalpha(c)) { tmp[idx++] = c; tmp[idx] = '\0'; } else if (c == '+' || c == '-') { idx = 0; if (strcasecmp(tmp, "control") == 0 || strcasecmp(tmp, "ctrl") == 0) *mask |= ControlMask; else if (strcasecmp(tmp, "alt") == 0) *mask |= Mod1Mask; else if (strcasecmp(tmp, "shift") == 0) *mask |= ShiftMask; else { fprintf(stderr, "Invalid key modifier: %s\n", tmp); g_free(tmp); return_val(-1); } } } if ((*key = gdk_keyval_from_name(tmp)) == GDK_KEY_VoidSymbol) { g_free(tmp); return_val(-1); } g_free(tmp); return_val(0); }
static void ghtml_window_initialize(int width, int height, bool as_dialog, void *file) { ghtml_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (ghtml_window)); GdkVisual *visual = gdk_screen_get_rgba_visual (screen); if (visual == NULL) visual = gdk_screen_get_system_visual (screen); gtk_widget_set_visual (ghtml_window, visual); g_signal_connect(ghtml_window, "destroy", G_CALLBACK(ghtml_window_destroy), NULL); void *ghtml_window_scrollable_content_area = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy( ghtml_window_scrollable_content_area, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); if (ghtml_app_title) gtk_window_set_title(ghtml_window, ghtml_app_title); gtk_window_set_default_size(ghtml_window, width, height); ghtml_webview = WEBKIT_WEB_VIEW(webkit_web_view_new()); gtk_container_add(ghtml_window, ghtml_window_scrollable_content_area); if (as_dialog) { gtk_window_set_type_hint((void*) ghtml_window, GDK_WINDOW_TYPE_HINT_DIALOG); GtkAccelGroup *gtk_accel = gtk_accel_group_new (); GClosure *closure; closure = g_cclosure_new (G_CALLBACK (ghtml_window_escaped), NULL, NULL); gtk_accel_group_connect (gtk_accel, gdk_keyval_from_name ("Escape"), 0, GTK_ACCEL_LOCKED, closure); gtk_window_add_accel_group (ghtml_window, gtk_accel); } ghtml_webview_initialize(ghtml_window_scrollable_content_area, file, true); }
/** * egg_accelerator_parse_virtual: * @accelerator: string representing an accelerator * @accelerator_key: return location for accelerator keyval * @accelerator_mods: return location for accelerator modifier mask * * Parses a string representing a virtual accelerator. The format * looks like "<Control>a" or "<Shift><Alt>F1" or * "<Release>z" (the last one is for key release). The parser * is fairly liberal and allows lower or upper case, and also * abbreviations such as "<Ctl>" and "<Ctrl>". * * If the parse fails, @accelerator_key and @accelerator_mods will * be set to 0 (zero) and %FALSE will be returned. If the string contains * only modifiers, @accelerator_key will be set to 0 but %TRUE will be * returned. * * The virtual vs. concrete accelerator distinction is a relic of * how the X Window System works; there are modifiers Mod2-Mod5 that * can represent various keyboard keys (numlock, meta, hyper, etc.), * the virtual modifier represents the keyboard key, the concrete * modifier the actual Mod2-Mod5 bits in the key press event. * * Returns: %TRUE on success. */ gboolean egg_accelerator_parse_virtual (const gchar *accelerator, guint *accelerator_key, EggVirtualModifierType *accelerator_mods) { guint keyval; GdkModifierType mods; gint len; gboolean bad_keyval; if (accelerator_key) *accelerator_key = 0; if (accelerator_mods) *accelerator_mods = 0; g_return_val_if_fail (accelerator != NULL, FALSE); bad_keyval = FALSE; keyval = 0; mods = 0; len = strlen (accelerator); while (len) { if (*accelerator == '<') { if (len >= 9 && is_release (accelerator)) { accelerator += 9; len -= 9; mods |= EGG_VIRTUAL_RELEASE_MASK; } else if (len >= 9 && is_control (accelerator)) { accelerator += 9; len -= 9; mods |= EGG_VIRTUAL_CONTROL_MASK; } else if (len >= 7 && is_shift (accelerator)) { accelerator += 7; len -= 7; mods |= EGG_VIRTUAL_SHIFT_MASK; } else if (len >= 6 && is_shft (accelerator)) { accelerator += 6; len -= 6; mods |= EGG_VIRTUAL_SHIFT_MASK; } else if (len >= 6 && is_ctrl (accelerator)) { accelerator += 6; len -= 6; mods |= EGG_VIRTUAL_CONTROL_MASK; } else if (len >= 6 && is_modx (accelerator)) { static const guint mod_vals[] = { EGG_VIRTUAL_ALT_MASK, EGG_VIRTUAL_MOD2_MASK, EGG_VIRTUAL_MOD3_MASK, EGG_VIRTUAL_MOD4_MASK, EGG_VIRTUAL_MOD5_MASK }; len -= 6; accelerator += 4; mods |= mod_vals[*accelerator - '1']; accelerator += 2; } else if (len >= 5 && is_ctl (accelerator)) { accelerator += 5; len -= 5; mods |= EGG_VIRTUAL_CONTROL_MASK; } else if (len >= 5 && is_alt (accelerator)) { accelerator += 5; len -= 5; mods |= EGG_VIRTUAL_ALT_MASK; } else if (len >= 6 && is_meta (accelerator)) { accelerator += 6; len -= 6; mods |= EGG_VIRTUAL_META_MASK; } else if (len >= 7 && is_hyper (accelerator)) { accelerator += 7; len -= 7; mods |= EGG_VIRTUAL_HYPER_MASK; } else if (len >= 7 && is_super (accelerator)) { accelerator += 7; len -= 7; mods |= EGG_VIRTUAL_SUPER_MASK; } else if (len >= 9 && is_primary (accelerator)) { accelerator += 9; len -= 9; mods |= EGG_VIRTUAL_CONTROL_MASK; } else { gchar last_ch; last_ch = *accelerator; while (last_ch && last_ch != '>') { last_ch = *accelerator; accelerator += 1; len -= 1; } } } else { keyval = gdk_keyval_from_name (accelerator); if (keyval == 0) bad_keyval = TRUE; accelerator += len; len -= len; } } if (accelerator_key) *accelerator_key = gdk_keyval_to_lower (keyval); if (accelerator_mods) *accelerator_mods = mods; return !bad_keyval; }
static int key_load_kbs (void) { char *buf, *ibuf; struct stat st; struct key_binding *kb = NULL; int fd, len, state = 0, pnt = 0; guint keyval; GdkModifierType mod = 0; off_t size; fd = hexchat_open_file ("keybindings.conf", O_RDONLY, 0, 0); if (fd < 0) { ibuf = g_strdup (default_kb_cfg); size = strlen (default_kb_cfg); } else { if (fstat (fd, &st) != 0) { close (fd); return 1; } ibuf = g_malloc(st.st_size); read (fd, ibuf, st.st_size); size = st.st_size; close (fd); } if (keybind_list) { g_slist_free_full (keybind_list, key_free); keybind_list = NULL; } while (buf_get_line (ibuf, &buf, &pnt, size)) { if (buf[0] == '#') continue; if (strlen (buf) == 0) continue; switch (state) { case KBSTATE_MOD: kb = g_new0 (struct key_binding, 1); /* New format */ if (strncmp (buf, "ACCEL=", 6) == 0) { buf += 6; gtk_accelerator_parse (buf, &keyval, &mod); kb->keyval = keyval; kb->mod = key_modifier_get_valid (mod); state = KBSTATE_ACT; continue; } if (key_load_kbs_helper_mod (buf, &mod)) goto corrupt_file; kb->mod = mod; state = KBSTATE_KEY; continue; case KBSTATE_KEY: STRIP_WHITESPACE keyval = gdk_keyval_from_name (buf); if (keyval == 0) { g_free (ibuf); return 2; } kb->keyval = keyval; state = KBSTATE_ACT; continue; case KBSTATE_ACT: STRIP_WHITESPACE kb->action = key_get_action_from_string (buf); if (kb->action == KEY_MAX_ACTIONS + 1) { g_free (ibuf); return 3; } state = KBSTATE_DT1; continue; case KBSTATE_DT1: case KBSTATE_DT2: if (state == KBSTATE_DT1) kb->data1 = kb->data2 = NULL; while (buf[0] == ' ' || buf[0] == '\t') buf++; if (buf[0] != 'D') { g_free (ibuf); return 4; } switch (buf[1]) { case '1': if (state != KBSTATE_DT1) goto corrupt_file; break; case '2': if (state != KBSTATE_DT2) goto corrupt_file; break; default: goto corrupt_file; } if (buf[2] == ':') { len = strlen (buf); /* Add one for the NULL, subtract 3 for the "Dx:" */ len++; len -= 3; if (state == KBSTATE_DT1) { kb->data1 = g_strndup (&buf[3], len); } else { kb->data2 = g_strndup (&buf[3], len); } } else if (buf[2] == '!') { if (state == KBSTATE_DT1) kb->data1 = NULL; else kb->data2 = NULL; } if (state == KBSTATE_DT1) { state = KBSTATE_DT2; continue; } else { keybind_list = g_slist_append (keybind_list, kb); state = KBSTATE_MOD; } continue; } } g_free (ibuf); return 0; corrupt_file: g_free (ibuf); g_free (kb); return 5; }
/* Open the configuration file and fill in the key_sequences hash table * with key/character-list pairs taken from the [keys] group of the file. */ static void load_config (GtkImContextMultipress *self) { GKeyFile *key_file; GError *error = NULL; gchar **keys; gsize n_keys = 0; gsize i; key_file = g_key_file_new (); if (!g_key_file_load_from_file (key_file, CONFIGURATION_FILENAME, G_KEY_FILE_NONE, &error)) { g_warning ("Error while trying to open the %s configuration file: %s", CONFIGURATION_FILENAME, error->message); g_error_free (error); g_key_file_free (key_file); return; } keys = g_key_file_get_keys (key_file, "keys", &n_keys, &error); if (error != NULL) { g_warning ("Error while trying to read the %s configuration file: %s", CONFIGURATION_FILENAME, error->message); g_error_free (error); g_key_file_free (key_file); return; } for (i = 0; i < n_keys; ++i) { KeySequence *seq; guint keyval; keyval = gdk_keyval_from_name (keys[i]); if (keyval == GDK_VoidSymbol) { g_warning ("Error while trying to read the %s configuration file: " "invalid key name \"%s\"", CONFIGURATION_FILENAME, keys[i]); continue; } seq = g_slice_new (KeySequence); seq->characters = g_key_file_get_string_list (key_file, "keys", keys[i], &seq->n_characters, &error); if (error != NULL) { g_warning ("Error while trying to read the %s configuration file: %s", CONFIGURATION_FILENAME, error->message); g_error_free (error); error = NULL; g_slice_free (KeySequence, seq); continue; } /* Ownership of the KeySequence is taken over by the hash table */ g_hash_table_insert (self->key_sequences, GUINT_TO_POINTER (keyval), seq); } g_strfreev (keys); g_key_file_free (key_file); }
static int key_load_kbs (char *filename) { char *buf, *ibuf; struct stat st; struct key_binding *kb = NULL, *last = NULL; int fd, len, pnt = 0, state = 0, n; if (filename == NULL) fd = xchat_open_file ("keybindings.conf", O_RDONLY, 0, 0); else fd = xchat_open_file (filename, O_RDONLY, 0, XOF_FULLPATH); if (fd < 0) return 1; if (fstat (fd, &st) != 0) return 1; ibuf = malloc (st.st_size); read (fd, ibuf, st.st_size); close (fd); while (buf_get_line (ibuf, &buf, &pnt, st.st_size)) { if (buf[0] == '#') continue; if (strlen (buf) == 0) continue; switch (state) { case KBSTATE_MOD: kb = (struct key_binding *) malloc (sizeof (struct key_binding)); if (key_load_kbs_helper_mod (buf, &kb->mod)) goto corrupt_file; state = KBSTATE_KEY; continue; case KBSTATE_KEY: /* First strip off the fluff */ while (buf[0] == ' ' || buf[0] == '\t') buf++; len = strlen (buf); while (buf[len] == ' ' || buf[len] == '\t') { buf[len] = 0; len--; } n = gdk_keyval_from_name (buf); if (n == 0) { /* Unknown keyname, abort */ if (last) last->next = NULL; free (ibuf); ibuf = malloc (1024); snprintf (ibuf, 1024, _("Unknown keyname %s in key bindings config file\nLoad aborted, please fix %s/keybindings.conf\n"), buf, get_xdir_utf8 ()); fe_message (ibuf, FE_MSG_ERROR); free (ibuf); return 2; } kb->keyname = gdk_keyval_name (n); kb->keyval = n; state = KBSTATE_ACT; continue; case KBSTATE_ACT: /* First strip off the fluff */ while (buf[0] == ' ' || buf[0] == '\t') buf++; len = strlen (buf); while (buf[len] == ' ' || buf[len] == '\t') { buf[len] = 0; len--; } for (n = 0; n < KEY_MAX_ACTIONS + 1; n++) { if (strcmp (key_actions[n].name, buf) == 0) { kb->action = n; break; } } if (n == KEY_MAX_ACTIONS + 1) { if (last) last->next = NULL; free (ibuf); ibuf = malloc (1024); snprintf (ibuf, 1024, _("Unknown action %s in key bindings config file\nLoad aborted, Please fix %s/keybindings\n"), buf, get_xdir_utf8 ()); fe_message (ibuf, FE_MSG_ERROR); free (ibuf); return 3; } state = KBSTATE_DT1; continue; case KBSTATE_DT1: case KBSTATE_DT2: if (state == KBSTATE_DT1) kb->data1 = kb->data2 = NULL; while (buf[0] == ' ' || buf[0] == '\t') buf++; if (buf[0] != 'D') { free (ibuf); ibuf = malloc (1024); snprintf (ibuf, 1024, _("Expecting Data line (beginning Dx{:|!}) but got:\n%s\n\nLoad aborted, Please fix %s/keybindings\n"), buf, get_xdir_utf8 ()); fe_message (ibuf, FE_MSG_ERROR); free (ibuf); return 4; } switch (buf[1]) { case '1': if (state != KBSTATE_DT1) goto corrupt_file; break; case '2': if (state != KBSTATE_DT2) goto corrupt_file; break; default: goto corrupt_file; } if (buf[2] == ':') { len = strlen (buf); /* Add one for the NULL, subtract 3 for the "Dx:" */ len++; len -= 3; if (state == KBSTATE_DT1) { kb->data1 = malloc (len); memcpy (kb->data1, &buf[3], len); } else { kb->data2 = malloc (len); memcpy (kb->data2, &buf[3], len); } } else if (buf[2] == '!') { if (state == KBSTATE_DT1) kb->data1 = NULL; else kb->data2 = NULL; } if (state == KBSTATE_DT1) { state = KBSTATE_DT2; continue; } else { if (last) last->next = kb; else keys_root = kb; last = kb; state = KBSTATE_MOD; } continue; } } if (last) last->next = NULL; free (ibuf); return 0; corrupt_file: /*if (getenv ("XCHAT_DEBUG")) abort ();*/ snprintf (ibuf, 1024, _("Key bindings config file is corrupt, load aborted\n" "Please fix %s/keybindings.conf\n"), get_xdir_utf8 ()); fe_message (ibuf, FE_MSG_ERROR); free (ibuf); return 5; }
gint main (gint argc, gchar **argv) { PopplerDocument *document; GtkWidget *win; GtkWidget *hbox; GtkWidget *notebook; GtkWidget *treeview; GtkTreeSelection *selection; GFile *file; GTimer *timer; GError *error = NULL; GtkAccelGroup *gtk_accel; GClosure *closure; if (argc != 2) { g_print ("Usage: poppler-glib-demo FILE\n"); return 1; } gtk_init (&argc, &argv); file = g_file_new_for_commandline_arg (argv[1]); timer = g_timer_new (); document = poppler_document_new_from_gfile (file, NULL, NULL, &error); g_timer_stop (timer); if (error) { while (g_error_matches (error, POPPLER_ERROR, POPPLER_ERROR_ENCRYPTED)) { GtkDialog *dialog; const gchar *password; dialog = pgd_demo_get_auth_dialog (file); if (gtk_dialog_run (dialog) != GTK_RESPONSE_OK) { g_print ("Error: no password provided\n"); g_object_unref (file); return 1; } g_clear_error (&error); password = g_object_get_data (G_OBJECT (dialog), "pgd-password"); g_timer_start (timer); document = poppler_document_new_from_gfile (file, password, NULL, &error); g_timer_stop (timer); gtk_widget_destroy (GTK_WIDGET (dialog)); } if (error) { g_print ("Error: %s\n", error->message); g_error_free (error); g_object_unref (file); return 1; } } g_object_unref (file); g_print ("Document successfully loaded in %.4f seconds\n", g_timer_elapsed (timer, NULL)); g_timer_destroy (timer); /* Main window */ win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (win), 600, 600); gtk_window_set_title (GTK_WINDOW (win), "Poppler GLib Demo"); g_signal_connect (G_OBJECT (win), "delete-event", G_CALLBACK (gtk_main_quit), NULL); gtk_accel = gtk_accel_group_new (); closure = g_cclosure_new (G_CALLBACK (gtk_main_quit), NULL, NULL); gtk_accel_group_connect (gtk_accel, gdk_keyval_from_name ("q"), GDK_CONTROL_MASK, 0, closure); g_closure_unref (closure); gtk_window_add_accel_group (GTK_WINDOW(win), gtk_accel); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); treeview = pgd_demo_list_create (); gtk_box_pack_start (GTK_BOX (hbox), treeview, FALSE, TRUE, 0); gtk_widget_show (treeview); notebook = pdg_demo_notebook_create (document); gtk_box_pack_start (GTK_BOX (hbox), notebook, TRUE, TRUE, 0); gtk_widget_show (notebook); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (pgd_demo_changed), (gpointer) notebook); gtk_container_add (GTK_CONTAINER (win), hbox); gtk_widget_show (hbox); gtk_widget_show (win); gtk_main (); g_object_unref (document); return 0; }
void uGlobalMenuItem::SyncAccelFromContent() { if (!mKeyContent) { dbusmenu_menuitem_property_remove(mDbusMenuItem, DBUSMENU_MENUITEM_PROP_SHORTCUT); return; } nsAutoString modStr; mKeyContent->GetAttr(kNameSpaceID_None, uWidgetAtoms::modifiers, modStr); PRUint32 modifier = 0; if (!modStr.IsEmpty()) { char* str = ToNewUTF8String(modStr); char *token = strtok(str, ", \t"); while(token) { if (strcmp(token, "shift") == 0) { modifier |= GDK_SHIFT_MASK; } else if (strcmp(token, "alt") == 0) { modifier |= GDK_MOD1_MASK; } else if (strcmp(token, "meta") == 0) { modifier |= GDK_META_MASK; } else if (strcmp(token, "control") == 0) { modifier |= GDK_CONTROL_MASK; } else if (strcmp(token, "accel") == 0) { nsIPrefBranch *prefs = uGlobalMenuService::GetPrefService(); PRInt32 accel; prefs->GetIntPref("ui.key.accelKey", &accel); if (accel == nsIDOMKeyEvent::DOM_VK_META) { modifier |= GDK_META_MASK; } else if (accel == nsIDOMKeyEvent::DOM_VK_ALT) { modifier |= GDK_MOD1_MASK; } else { modifier |= GDK_CONTROL_MASK; } } token = strtok(nullptr, ", \t"); } nsMemory::Free(str); } nsAutoString keyStr; guint key = 0; mKeyContent->GetAttr(kNameSpaceID_None, uWidgetAtoms::key, keyStr); nsAutoCString cKeyStr; CopyUTF16toUTF8(keyStr, cKeyStr); if (!cKeyStr.IsEmpty()) { key = gdk_keyval_from_name(cKeyStr.get()); } if (key == 0 && !keyStr.IsEmpty()) { key = gdk_unicode_to_keyval(*keyStr.BeginReading()); } if (key == 0) { mKeyContent->GetAttr(kNameSpaceID_None, uWidgetAtoms::keycode, keyStr); if (!keyStr.IsEmpty()) key = MozKeyCodeToGdkKeyCode(GetKeyCode(keyStr)); } if (key == 0) { key = GDK_VoidSymbol; } if (key != GDK_VoidSymbol) { dbusmenu_menuitem_property_set_shortcut(mDbusMenuItem, key, static_cast<GdkModifierType>(modifier)); } else { dbusmenu_menuitem_property_remove(mDbusMenuItem, DBUSMENU_MENUITEM_PROP_SHORTCUT); } }
/** * egg_accelerator_parse_virtual: * @accelerator: string representing an accelerator * @accelerator_key: return location for accelerator keyval * @accelerator_mods: return location for accelerator modifier mask * * Parses a string representing a virtual accelerator. The format * looks like "<Control>a" or "<Shift><Alt>F1" or * "<Release>z" (the last one is for key release). The parser * is fairly liberal and allows lower or upper case, and also * abbreviations such as "<Ctl>" and "<Ctrl>". * * If the parse fails, @accelerator_key and @accelerator_mods will * be set to 0 (zero) and %FALSE will be returned. If the string contains * only modifiers, @accelerator_key will be set to 0 but %TRUE will be * returned. * * The virtual vs. concrete accelerator distinction is a relic of * how the X Window System works; there are modifiers Mod2-Mod5 that * can represent various keyboard keys (numlock, meta, hyper, etc.), * the virtual modifier represents the keyboard key, the concrete * modifier the actual Mod2-Mod5 bits in the key press event. * * Returns: %TRUE on success. */ gboolean egg_accelerator_parse_virtual (const gchar *accelerator, guint *accelerator_key, guint *keycode, EggVirtualModifierType *accelerator_mods) { guint keyval; GdkModifierType mods; gint len; gboolean bad_keyval; if (accelerator_key) *accelerator_key = 0; if (accelerator_mods) *accelerator_mods = 0; if (keycode) *keycode = 0; g_return_val_if_fail (accelerator != NULL, FALSE); bad_keyval = FALSE; keyval = 0; mods = 0; len = strlen (accelerator); while (len) { if (*accelerator == '<') { if (len >= 9 && is_release (accelerator)) { accelerator += 9; len -= 9; mods |= EGG_VIRTUAL_RELEASE_MASK; } else if (len >= 9 && is_control (accelerator)) { accelerator += 9; len -= 9; mods |= EGG_VIRTUAL_CONTROL_MASK; } else if (len >= 7 && is_shift (accelerator)) { accelerator += 7; len -= 7; mods |= EGG_VIRTUAL_SHIFT_MASK; } else if (len >= 6 && is_shft (accelerator)) { accelerator += 6; len -= 6; mods |= EGG_VIRTUAL_SHIFT_MASK; } else if (len >= 6 && is_ctrl (accelerator)) { accelerator += 6; len -= 6; mods |= EGG_VIRTUAL_CONTROL_MASK; } else if (len >= 6 && is_modx (accelerator)) { static const guint mod_vals[] = { EGG_VIRTUAL_ALT_MASK, EGG_VIRTUAL_MOD2_MASK, EGG_VIRTUAL_MOD3_MASK, EGG_VIRTUAL_MOD4_MASK, EGG_VIRTUAL_MOD5_MASK }; len -= 6; accelerator += 4; mods |= mod_vals[*accelerator - '1']; accelerator += 2; } else if (len >= 5 && is_ctl (accelerator)) { accelerator += 5; len -= 5; mods |= EGG_VIRTUAL_CONTROL_MASK; } else if (len >= 5 && is_alt (accelerator)) { accelerator += 5; len -= 5; mods |= EGG_VIRTUAL_ALT_MASK; } else if (len >= 6 && is_meta (accelerator)) { accelerator += 6; len -= 6; mods |= EGG_VIRTUAL_META_MASK; } else if (len >= 7 && is_hyper (accelerator)) { accelerator += 7; len -= 7; mods |= EGG_VIRTUAL_HYPER_MASK; } else if (len >= 7 && is_super (accelerator)) { accelerator += 7; len -= 7; mods |= EGG_VIRTUAL_SUPER_MASK; } else { gchar last_ch; last_ch = *accelerator; while (last_ch && last_ch != '>') { last_ch = *accelerator; accelerator += 1; len -= 1; } } } else { keyval = gdk_keyval_from_name (accelerator); if (keyval == 0) { /* If keyval is 0, than maybe it's a keycode. Check for 0x## */ if (len >= 4 && is_keycode (accelerator)) { char keystring[5]; gchar *endptr; gint tmp_keycode; memcpy (keystring, accelerator, 4); keystring [4] = '\000'; tmp_keycode = strtol (keystring, &endptr, 16); if (endptr == NULL || *endptr != '\000') { bad_keyval = TRUE; } else if (keycode != NULL) { *keycode = tmp_keycode; /* 0x00 is an invalid keycode too. */ if (*keycode == 0) bad_keyval = TRUE; } } } else if (keycode != NULL) *keycode = XKeysymToKeycode (GDK_DISPLAY(), keyval); accelerator += len; len -= len; } } if (accelerator_key) *accelerator_key = gdk_keyval_to_lower (keyval); if (accelerator_mods) *accelerator_mods = mods; return !bad_keyval; }