gint
scorearea_keypress_event (GtkWidget * widget, GdkEventKey * event)
{
if(!Denemo.keyboard_state_locked)
{
Denemo.keyboard_state |= (0xf & klock_mask (event->keyval));
Denemo.keyboard_state ^= llock_mask (event->keyval);
// if((event->keyval==GDK_Alt_L)||(event->keyval==GDK_Alt_R))
// Denemo.keyboard_state |= CHORD_MASK;
set_midi_in_status ();
}
//g_print("press Denemo %x state %x klock %x\n", Denemo.keyboard_state, event->state, klock_mask(event->keyval));
//g_debug("State eored %x\n", (lock_mask(event->keyval)^event->state));
if (divert_key_event && !isModifier (event) && divert_key_id == Denemo.project->id)
{
dnm_clean_event (event);
*divert_key_event = event;
//g_object_ref(event); FIXME do we need to keep it around?
gtk_main_quit ();
return TRUE; //*is* reached main loop exits to the caller of the loop when it next gains control
}
(void) process_key_event (event, perform_command);
return TRUE; //I think this means do not run any other handlers after this.
}
bool HotkeyWidget::isValid(int key) const
{
switch (key) {
case 0:
case Qt::Key_Escape:
case Qt::Key_unknown:
return false;
}
return !isModifier(key);
}
QString ConvertASCIIToEnc::getSequence(int &i)
{
QString seq = nextSequence(i);
static QRegExp reBraces("\\{([a-zA-Z]?)\\}");
if(isModifier(seq)) {
KILE_DEBUG_MAIN << "\tisModifier true : " << seq;
if(seq[seq.length() - 1].isLetter()) {
seq += ' ';
}
while(m_io->currentLine()[i].isSpace()) {
++i;
}
if(m_io->currentLine().mid(i, 2) == "{}") {
i = i + 2;
}
if(m_io->currentLine()[i] == '\\') {
seq += nextSequence(i);
}
else {
if(reBraces.exactMatch(m_io->currentLine().mid(i, 3))) {
KILE_DEBUG_MAIN << "\tbraces detected";
i = i + 3;
seq += reBraces.cap(1);
}
else {
QChar nextChar = m_io->currentLine()[i++];
if(!nextChar.isSpace()) {
seq += (QString)nextChar;
}
}
}
}
else if(m_map->canEncode(seq)) {
if(m_io->currentLine().mid(i, 2) == "{}") {
i = i + 2;
}
else if(m_io->currentLine()[i].isSpace()) {
++i;
}
}
return seq;
}
std::string EventManager::getGDKEventStr(GdkEventKey* event) {
std::string returnValue("");
// Don't react on modifiers only (no actual key like A, 2, U, etc.)
if (isModifier(event)) {
return returnValue;
}
// Convert the GDKEvent state into modifier flags
const unsigned int modifierFlags = _modifiers.getKeyboardFlags(event->state);
// Construct the complete string
returnValue += _modifiers.getModifierStr(modifierFlags, true);
returnValue += (returnValue != "") ? "-" : "";
returnValue += gdk_keyval_name(gdk_keyval_to_upper(event->keyval));
return returnValue;
}
void HotkeyWidget::keyPressEvent(QKeyEvent *event)
{
if (mKeyboardFocus) {
return;
}
if (isModifier(event->key())) {
return;
}
if (!isValid(event->key())) {
setText(tr("Invalid hotkey"));
parentWidget()->setFocus();
return;
}
mHotkey = QKeySequence(event->key() + (event->modifiers() & ~Qt::KeypadModifier));
setHotkeyText();
}
static gboolean
capture_look_binding (GtkWidget * widget, GdkEventKey * event, gpointer user_data)
{
GdkModifierType modifiers;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreePath *path;
gint command_idx;
keyboard_dialog_data *cbdata = (keyboard_dialog_data *) user_data;
gtk_statusbar_pop (cbdata->statusbar, cbdata->context_id);
//get the shortcut
if (isModifier (event))
return TRUE;
dnm_clean_event (event);
modifiers = dnm_sanitize_key_state (event);
//look for the keybinding
command_idx = lookup_command_for_keybinding (Denemo.map, event->keyval, modifiers);
//if the binding is associated to a command
if (command_idx == -1)
{
gchar *name = dnm_accelerator_name (event->keyval, event->state);
GList *g = (GList *) g_hash_table_lookup (Denemo.map->continuations_table, name);
GString *continuations = g_string_new ("");
GString *final_list = g_string_new ("");
for (; g; g = g->next)
{
g_string_append_printf (continuations, "%s%s%s", name, ",", (gchar *) g->data);
command_idx = lookup_command_for_keybinding_name (Denemo.map, continuations->str);
const gchar *this = lookup_name_from_idx (Denemo.map, command_idx);
g_string_append_printf (final_list, "%s,%s=%s ", name, (gchar *) g->data, this);
g_string_assign (continuations, "");
}
if (final_list->len)
cbdata->twokeylist = final_list;
}
static gboolean
capture_add_binding (GtkWidget * widget, GdkEventKey * event, gpointer user_data)
{
GdkModifierType modifiers;
guint command_idx;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreePath *path;
gint *array;
keyboard_dialog_data *cbdata = (keyboard_dialog_data *) user_data;
//get the shortcut
if (isModifier (event))
return TRUE;
dnm_clean_event (event);
modifiers = dnm_sanitize_key_state (event);
gchar *name = dnm_accelerator_name (event->keyval, event->state);
if (!strcmp(name, "VoidSymbol"))
{
warningdialog (_("VoidSymbol not allowed"));
return TRUE;
}
if (cbdata->two_key == 1)
{
gint command_idx = lookup_command_for_keybinding_name (Denemo.map, name);
if (command_idx == -1)
{
cbdata->first_keyval = event->keyval;
cbdata->first_modifiers = modifiers;
cbdata->two_key = 2;
return TRUE;
}
else
{
cbdata->two_key = 0;
gchar *msg = g_strdup_printf (_("The command %s has the shortcut: %s\nDelete it first or start again selecting an unused keypress."), lookup_name_from_idx (Denemo.map, command_idx), name);
warningdialog (msg);
g_free (msg);
g_free (name);
g_warning ("trying to set a two key starting with a single");
return TRUE;
}
}
//get the command_index
selection = gtk_tree_view_get_selection (cbdata->command_view);
gtk_tree_selection_get_selected (selection, &model, &iter);
path = gtk_tree_model_get_path (model, &iter);
array = gtk_tree_path_get_indices (path);
command_idx = array[0]; //this fails in general, yielding the value in cbdata, instead ...
gchar* cname = NULL;
gtk_tree_model_get (model, &iter, COL_NAME, &cname, -1);
command_idx = lookup_command_from_name (Denemo.map, cname);
if(command_idx != cbdata->command_id)
g_warning("correct command idx %d compare %d for action of name %s\n", command_idx, cbdata->command_id, cname);
gtk_tree_path_free (path);
if (cbdata->two_key == 0 && (GList *) g_hash_table_lookup (Denemo.map->continuations_table, name))
{
//g_warning("There is a two key binding starting with this");
gchar *msg = g_strdup_printf (_("There is at least one two-key shortcut that starts with: %s\nFind them using the Find button\nDelete it/those first or start again selecting an unused keypress."), name);
warningdialog (msg);
g_free (msg);
g_free (name);
return TRUE;
}
g_free (name);
//set the new binding
if (cbdata->two_key == 2)
add_twokeybinding_to_idx (Denemo.map, cbdata->first_keyval, cbdata->first_modifiers, event->keyval, modifiers, command_idx, POS_FIRST);
else
add_keybinding_to_idx (Denemo.map, event->keyval, modifiers, command_idx, POS_FIRST);
command_row* row = NULL;
keymap_get_command_row (Denemo.map, &row, command_idx);
GtkListStore* bindings_model = GTK_LIST_STORE(gtk_tree_view_get_model(cbdata->binding_view));
update_bindings_model(bindings_model, row->bindings);
gtk_statusbar_pop (cbdata->statusbar, cbdata->context_id);
g_signal_handler_disconnect (GTK_WIDGET (widget), cbdata->handler_key_press);
g_signal_handler_disconnect (GTK_WIDGET (widget), cbdata->handler_focus_out);
cbdata->two_key = 0;
return TRUE;
}
bool belongsTo(uint16_t scancode) const { return isKey(scancode) || isModifier(scancode); }
//return the value of perform_command if executed or "" if keypress is part of a two-key shortcut, or NULL toherwise
gchar *
process_key_event (GdkEventKey * event, gchar * perform_command ())
{
keymap *the_keymap = Denemo.map;
//g_debug("\n********\nCaps Lock %x?\n\n********\nShifted %x?\n", event->state&GDK_LOCK_MASK, event->state&GDK_SHIFT_MASK );
{
gint state;
state = (lock_mask (event->keyval) ^ event->state);
if (state || ((event->keyval == GDK_Caps_Lock) || (event->keyval == GDK_Num_Lock)))
set_cursor_for (state); // MUST LOOK AHEAD to state after keypress HERE CATCH modifiers and set the cursor for them.....
}
dnm_clean_event (event);
if (isModifier (event))
return NULL;
/* Look up the keystroke in the keymap and execute the appropriate
* function */
static GString *prefix_store = NULL;
if (!prefix_store)
prefix_store = g_string_new ("");
gint command_idx = lookup_command_for_keyevent (event);
if ((prefix_store->len == 0) && (command_idx != -1))
{
const gchar *command_name = lookup_name_from_idx (the_keymap, command_idx);
if (command_name)
{
if (Denemo.prefs.learning)
{
gchar *name = dnm_accelerator_name (event->keyval, event->state);
KeyStrokeShow (name, command_idx, TRUE);
g_free (name);
}
if (Denemo.ScriptRecording)
if (idx_has_callback (the_keymap, command_idx))
{
append_scheme_call ((gchar *) command_name);
}
//g_debug("Single Key shortcut %s invokes %s\n", dnm_accelerator_name(event->keyval, event->state), command_name);
return perform_command (command_name, event);
}
else
{
g_warning ("Error: action %i has no name", command_idx);
return NULL;
}
}
/* we create a store for the prefix char and look to see if it is populated when a keystroke is received. If it is populated, we try for the two-key combination, {???else we try for the single key, and if that fails populate the store. OR if it fails clear store}. If the two-key combination works we clear the store. If the two-key combination fails we try for the single key, if that succeeds we clear the store if it fails we set the store to the unresolved keystroke. */
gchar *ret = NULL;
if (prefix_store->len)
{
gchar *name = dnm_accelerator_name (event->keyval, event->state);
//g_debug("second key %s\n", name);
g_string_append_printf (prefix_store, "%c%s", ',', name);
command_idx = lookup_command_for_keybinding_name (Denemo.map, prefix_store->str);
if (command_idx != -1)
{
const gchar *command_name = lookup_name_from_idx (the_keymap, command_idx);
if (command_name)
{
if (Denemo.prefs.learning)
{
KeyStrokeShow (prefix_store->str, command_idx, FALSE);
}
if (Denemo.ScriptRecording)
if (idx_has_callback (the_keymap, command_idx))
{
append_scheme_call ((gchar *) command_name);
}
ret = perform_command (command_name, event);
}
}
else
{ //Two key name was not a binding
ret = NULL;
write_status (Denemo.project);
if ((Denemo.project->view != DENEMO_MENU_VIEW) || Denemo.prefs.learning)
{
Denemo.prefs.learning = TRUE;
KeyStrokeDecline (prefix_store->str);
}
toggle_to_drawing_area (TRUE); //restore menus, in case the user is lost and needs to look up a keypress
if (Denemo.project->view != DENEMO_MENU_VIEW)
toggle_to_drawing_area (TRUE);
}
g_string_assign (prefix_store, "");
Denemo.continuations = NULL;
return ret;
}
else
{ //no prefix stored
gchar *name = dnm_accelerator_name (event->keyval, event->state); //FIXME free name
if ((Denemo.continuations = (GList *) g_hash_table_lookup (Denemo.map->continuations_table, name)))
{
GList *g;
GString *continuations = g_string_new ("");
for (g = Denemo.continuations; g; g = g->next)
g_string_append_printf (continuations, "%s%s", (gchar *) g->data, _(", or "));
g_string_printf (prefix_store, _( "Prefix Key %s, waiting for key %stype Esc to abort"), name, continuations->str);
g_string_free (continuations, TRUE);
if (Denemo.prefs.immediateplayback)
play_note (DEFAULT_BACKEND, 0, 9, 61, 300, 127 * Denemo.project->movement->master_volume);
//gtk_statusbar_pop (GTK_STATUSBAR (Denemo.statusbar), Denemo.status_context_id);
gtk_label_set_text (GTK_LABEL (Denemo.statuslabel), prefix_store->str);
g_string_assign (prefix_store, name);
if (Denemo.prefs.learning)
{
KeyStrokeAwait (name);
}
return ""; //continuation available
}
else
{
if ((Denemo.project->view != DENEMO_MENU_VIEW) || Denemo.prefs.learning)
{
Denemo.prefs.learning = TRUE;
KeyStrokeDecline (name);
}
toggle_to_drawing_area (TRUE); //restore menus, in case the user is lost and needs to look up a keypress
if (Denemo.project->view != DENEMO_MENU_VIEW)
toggle_to_drawing_area (TRUE);
}
return NULL;
}
return NULL;
}