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